Java FImage.divideInplace方法代码示例

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	//1st pass
	image.divideInplace(firstPassDivisor(image, mask));
	
	//2nd pass
	image.divideInplace(secondPassDivisor(image, mask));
	
	//3rd pass
	for (int y=0; y<image.height; y++) {
		for (int x=0; x<image.width; x++) {
			if (mask.pixels[y][x] == 1) {
				image.pixels[y][x] = (float) (tau * Math.tanh(image.pixels[y][x] / tau));
			} else {
				image.pixels[y][x] = 0;
			}
		}
	}
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
/**
 * Create a kernel image with given kernel size and variance.
 * 
 * @param width
 *            image width.
 * @param height
 *            image height.
 * @param sigma
 *            variance.
 * @return new kernel image.
 */
public static FImage createKernelImage(int width, int height, float sigma) {
	final FImage f = new FImage(width, height);
	final int hw = (width - 1) / 2;
	final int hh = (height - 1) / 2;
	final float sigmasq = sigma * sigma;

	for (int y = -hh, j = 0; y <= hh; y++, j++) {
		for (int x = -hw, i = 0; x <= hw; x++, i++) {
			final int radsqrd = x * x + y * y;
			f.pixels[j][i] = (float) exp(-radsqrd / (2 * sigmasq));
		}
	}
	final float sum = FloatArrayStatsUtils.sum(f.pixels);
	return f.divideInplace(sum);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
/**
 * Makes a disk averaging filter with the given radius.
 * @param radius
 * @return the filter image
 */
public static FImage createKernelImage(int radius) {
	int sze = 2*radius+1;
	FImage f = new FImage(sze, sze);
	int hsz = (sze-1)/2;
	
	for (int y=-hsz, j=0; y<hsz; y++, j++) {
		for (int x=-hsz, i=0; x<hsz; x++, i++) {
			double rad = Math.sqrt(x*x + y*y);
			f.pixels[j][i] = rad < radius ? 1 : 0; 				
		}
	}
	float sum = FloatArrayStatsUtils.sum(f.pixels);
	return f.divideInplace(sum);		
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {
	final TestImageClass tic = new TestImageClass();

	final FImage trainPhoto = ResizeProcessor.halfSize(ResizeProcessor.halfSize(ImageUtilities.readF(new File(
			"/Users/jon/Desktop/images50cm4band/sp7034.jpeg"))));
	final FImage trainClass = ResizeProcessor.halfSize(ResizeProcessor.halfSize(ImageUtilities.readF(new File(
			"/Users/jon/Desktop/images50cm4band/sp7034-classes.PNG"))));

	tic.extractFeaturePatches(trainPhoto, 20000, 8);
	tic.extractClassifierTrainingPatches(trainPhoto, trainClass, 1000, 32);
	tic.learnDictionary(100);

	// Note: should really use sparse version!!
	/*
	 * final LiblinearAnnotator<FImage, Boolean> ann = new
	 * LiblinearAnnotator<FImage, Boolean>(tic, Mode.MULTICLASS,
	 * SolverType.L2R_L2LOSS_SVC, 1, 0.0001);
	 * 
	 * final MapBackedDataset<Boolean, ListBackedDataset<FImage>, FImage>
	 * data = new MapBackedDataset<Boolean, ListBackedDataset<FImage>,
	 * FImage>(); data.add(true, new
	 * ListBackedDataset<FImage>(Arrays.asList(tic.ruralPatches)));
	 * data.add(false, new
	 * ListBackedDataset<FImage>(Arrays.asList(tic.urbanPatches)));
	 * ann.train(data);
	 */
	final FImage test = ResizeProcessor.halfSize(ResizeProcessor.halfSize(ImageUtilities.readF(new File(
			"/Users/jon/Desktop/images50cm4band/test.jpeg")))).normalise();

	/*
	 * final FImage result = test.extractCenter(test.width - 32, test.height
	 * - 32); final FImage tmp = new FImage(32, 32); for (int y = 0; y <
	 * test.height - 32; y++) { for (int x = 0; x < test.width - 32; x++) {
	 * test.extractROI(x, y, tmp);
	 * 
	 * final ClassificationResult<Boolean> r = ann.classify(tmp); final
	 * Boolean clz = r.getPredictedClasses().iterator().next();
	 * 
	 * if (clz) result.pixels[y][x] = 1;
	 * 
	 * DisplayUtilities.displayName(result, "result"); } }
	 */

	final FImage tmp = new FImage(8 * 10, 8 * 10);
	for (int i = 0, y = 0; y < 10; y++) {
		for (int x = 0; x < 10; x++, i++) {
			final FImage p = new FImage(tic.dictionary[i], 8, 8);
			p.divideInplace(2 * Math.max(p.min(), p.max()));
			p.addInplace(0.5f);
			tmp.drawImage(p, x * 8, y * 8);
		}
	}
	DisplayUtilities.display(tmp);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException {
	final File patchesFile = new File("patches.bin");

	// final RandomPatchSampler sampler =
	// new
	// RandomPatchSampler(Caltech101.getImages(ImageUtilities.FIMAGE_READER),
	// 8, 8, 100000);
	// sampler.save(patchesFile);
	final List<FImage> patches = RandomPatchSampler.loadPatches(patchesFile);

	final double[][] data = new double[patches.size()][];
	for (int i = 0; i < data.length; i++)
		data[i] = patches.get(i).getDoublePixelVector();

	// final PCAWhitening whitening = new PCAWhitening();
	final WhiteningTransform whitening = new ZCAWhitening(0.1, new PerExampleMeanCenterVar(10f / 255f));
	whitening.train(data);
	final double[][] wd = whitening.whiten(data);

	// final double[][] comps =
	// whitening.getTransform().transpose().getArray();
	// for (int i = 0; i < comps.length; i++)
	// DisplayUtilities.di play(ResizeProcessor.resample(new
	// FImage(comps[i], 8, 8).normalise(), 128, 128));

	// final FImage tmp1 = new FImage(100 * 8, 100 * 8);
	// final FImage tmp2 = new FImage(100 * 8, 100 * 8);
	// final FImage tmp3 = new FImage(100 * 8, 100 * 8);
	// for (int i = 0; i < 100; i++) {
	// for (int j = 0; j < 100; j++) {
	// final double[] d = new PerExampleMeanCenterVar(10f /
	// 255f).normalise(patches.get(i * 100 + j)
	// .getDoublePixelVector());
	// FImage patch = new FImage(d, 8, 8);
	// patch.divideInplace(2 * Math.max(patch.min(), patch.max()));
	// patch.addInplace(0.5f);
	// tmp2.drawImage(patch, i * 8, j * 8);
	//
	// tmp3.drawImage(patches.get(i * 100 + j), i * 8, j * 8);
	//
	// patch = new FImage(wd[i * 100 + j], 8, 8);
	// patch.divideInplace(2 * Math.max(patch.min(), patch.max()));
	// patch.addInplace(0.5f);
	// tmp1.drawImage(patch, i * 8, j * 8);
	// }
	// }
	// DisplayUtilities.display(tmp3);
	// DisplayUtilities.display(tmp2);
	// DisplayUtilities.display(tmp1);

	final SphericalKMeans skm = new SphericalKMeans(2500, 10);
	final SphericalKMeansResult res = skm.cluster(wd);
	final FImage tmp = new FImage(50 * (8 + 1) + 1, 50 * (8 + 1) + 1);
	tmp.fill(1f);
	for (int i = 0; i < 50; i++) {
		for (int j = 0; j < 50; j++) {
			final FImage patch = ResizeProcessor
					.resample(
							new FImage(res.centroids[i * 50 + j], 8, 8),
							8, 8);
			patch.divideInplace(2 * Math.max(Math.abs(patch.min()),
					Math.abs(patch.max())));
			patch.addInplace(0.5f);
			tmp.drawImage(patch, i * (8 + 1) + 1, j * (8 + 1) + 1);
		}
	}
	DisplayUtilities.display(tmp);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
final void sum2one(FImage M) {
	M.divideInplace(M.sum());
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
protected static FImage normalise(FImage f) {
	final float mean = FloatArrayStatsUtils.mean(f.pixels);
	f.subtractInplace(mean);
	final float sumabs = FloatArrayStatsUtils.sumAbs(f.pixels);
	return f.divideInplace(sumabs);
}