Java ArrayUtils.maxIndex方法代码示例

import org.openimaj.util.array.ArrayUtils; //导入方法依赖的package包/类
@Override
public FeatureVector extract(MBFImage image, FImage mask) {
	final FeatureVector fv = super.extract(image, mask);
	final double[] vals = fv.asDoubleVector();
	final int index = ArrayUtils.maxIndex(vals);
	return new FloatFV(hm.colourAverage(index));
}
 

import org.openimaj.util.array.ArrayUtils; //导入方法依赖的package包/类
@Override
public Rectangle calculateRegularBoundingBox() {

	// Differentiate the parametrics form of the ellipse equation to get
	// tan(t) = -semiMinor * tan(rotation) / semiMajor (which gives us the
	// min/max X)
	// tan(t) = semiMinor * cot(rotation) / semiMajor (which gives us the
	// min/max Y)
	//
	// We find a value for t, add PI to get another value of t, we use this
	// to find our min/max x/y

	final double[] minmaxx = new double[2];
	final double[] minmaxy = new double[2];
	final double tanrot = Math.tan(rotation);
	final double cosrot = Math.cos(rotation);
	final double sinrot = Math.sin(rotation);

	double tx = Math.atan(-minor * tanrot / major);
	double ty = Math.atan(minor * (1 / tanrot) / major);

	minmaxx[0] = x + (major * Math.cos(tx) * cosrot - minor * Math.sin(tx) * sinrot);
	tx += Math.PI;
	minmaxx[1] = x + (major * Math.cos(tx) * cosrot - minor * Math.sin(tx) * sinrot);
	minmaxy[0] = y + (major * Math.cos(ty) * sinrot + minor * Math.sin(ty) * cosrot);
	ty += Math.PI;
	minmaxy[1] = y + (major * Math.cos(ty) * sinrot + minor * Math.sin(ty) * cosrot);

	double minx, miny, maxx, maxy;
	minx = minmaxx[ArrayUtils.minIndex(minmaxx)];
	miny = minmaxy[ArrayUtils.minIndex(minmaxy)];
	maxx = minmaxx[ArrayUtils.maxIndex(minmaxx)];
	maxy = minmaxy[ArrayUtils.maxIndex(minmaxy)];

	return new Rectangle((float) minx, (float) miny, (float) (maxx - minx), (float) (maxy - miny));
}
 

import org.openimaj.util.array.ArrayUtils; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final SummedAreaTable sat = new SummedAreaTable(image);
	final FImage output = new FImage(image.width, image.height);

	for (int vote = 0; vote < maxVotes; vote++) {
		// First step
		int widthR = (int) Math.pow(2, rng.nextIntFromTo(rangeMin, rangeMax));
		int heightR = (int) Math.pow(2, rng.nextIntFromTo(rangeMin, rangeMax));
		int xR = rng.nextIntFromTo(0, image.width - widthR);
		int yR = rng.nextIntFromTo(0, image.height - heightR);

		// Second step
		while (widthR > 2 && heightR > 2) {
			final int hw = widthR / 2;
			final int hh = heightR / 2;

			final float[] r = {
					sat.calculateArea(xR, yR, xR + hw, yR + hh),
					sat.calculateArea(xR + hw, yR, xR + widthR, yR + hh),
					sat.calculateArea(xR, yR + hh, xR + hw, yR + heightR),
					sat.calculateArea(xR + hw, yR + hh, xR + widthR, yR + heightR),
			};

			final int[] f = ArrayUtils.indexSort(r);
			if (r[f[3]] == r[f[2]])
				break;

			final int maxIdx = ArrayUtils.maxIndex(r);

			widthR = hw;
			heightR = hh;
			if (maxIdx == 1) {
				xR = xR + hw;
			} else if (maxIdx == 2) {
				yR = yR + hh;
			} else if (maxIdx == 3) {
				xR = xR + hw;
				yR = yR + hh;
			}
		}

		// Third step
		final int xLoc = Math.round(xR + widthR / 2);
		final int yLoc = Math.round(yR + heightR / 2);
		output.pixels[yLoc][xLoc]++;
	}

	output.processInplace(new FGaussianConvolve(sigma));
	image.internalAssign(output.normalise());
}
 

import org.openimaj.util.array.ArrayUtils; //导入方法依赖的package包/类
/**
 * Predict the class (the index of the most-probable gaussian) to which the
 * given data point belongs.
 * 
 * @param data
 *            the data point
 * @return the class index
 */
public int predict(double[] data) {
	final double[] posterior = predictLogPosterior(data);
	return ArrayUtils.maxIndex(posterior);
}