Java FImage.internalAssign方法代码示例

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final float[] tmp = new float[support.size()];
	final FImage tmpImage = new FImage(image.width, image.height);

	for (int y = 0; y < image.height; y++) {
		for (int x = 0; x < image.width; x++) {
			int count = 0;

			for (final Pixel sp : support) {
				final int xx = x + sp.x;
				final int yy = y + sp.y;

				if (xx >= 0 && xx < image.width - 1 && yy >= 0 && yy < image.height - 1) {
					tmp[count++] = image.pixels[yy][xx];
				}
			}

			tmpImage.pixels[y][x] = FloatArrayStatsUtils.median(tmp, 0, count);
		}
	}
	image.internalAssign(tmpImage);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final FImage tmpImage = new FImage(image.width, image.height);
	float min;
	float max;

	for (int y = 0; y < image.height; y++) {
		for (int x = 0; x < image.width; x++) {
			min = Float.MAX_VALUE;
			max = -Float.MAX_VALUE;
			for (final Pixel sp : support) {
				final int xx = x + sp.x;
				final int yy = y + sp.y;

				if (xx >= 0 && xx < image.width - 1 && yy >= 0 && yy < image.height - 1) {
					min = Math.min(min, image.pixels[yy][xx]);
					max = Math.max(max, image.pixels[yy][xx]);
				}
			}

			tmpImage.pixels[y][x] = max - min;
		}
	}
	image.internalAssign(tmpImage);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void convolve(FImage image) {
	final int kh = kernel.height;
	final int kw = kernel.width;
	final int hh = kh / 2;
	final int hw = kw / 2;
	final FImage clone = image.newInstance(image.width, image.height);
	for (int y = hh; y < image.height - (kh - hh); y++) {
		for (int x = hw; x < image.width - (kw - hw); x++) {
			float sum = 0;
			for (int j = 0, jj = kh - 1; j < kh; j++, jj--) {
				for (int i = 0, ii = kw - 1; i < kw; i++, ii--) {
					final int rx = x + i - hw;
					final int ry = y + j - hh;

					sum += image.pixels[ry][rx] * kernel.pixels[jj][ii];
				}
			}
			clone.pixels[y][x] = sum;
		}
	}
	image.internalAssign(clone);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	FImage newimage = image.newInstance(width, height);
	
	for (int y=0; y<height; y++)
		for (int x=0; x<width; x++)
			newimage.pixels[y][x] = image.getPixelInterp(x*scale, y*scale);
	
	image.internalAssign(newimage);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final FImage newimage = image.newInstance(width, height);

	final float[][] working = new float[4][4];

	for (int y = 0; y < height; y++)
		for (int x = 0; x < width; x++)
			newimage.pixels[y][x] = ImageInterpolation.InterpolationType.BICUBIC.interpolate(x * scale, y * scale,
					image, working);

	image.internalAssign(newimage);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final FImage tmp = image.process(new FGaussianConvolve(sigma));

	final float[][] tpix = tmp.pixels;
	final float[][] ipix = image.pixels;
	for (int y = 0; y < image.height; y++)
		for (int x = 0; x < image.width; x++)
			tpix[y][x] = ipix[y][x] < (tpix[y][x] - offset) ? 0f : 1f;

	image.internalAssign(tmp);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final FImage tmp = image.process(new AverageBoxFilter(sizeX, sizeY));

	final float[][] tpix = tmp.pixels;
	final float[][] ipix = image.pixels;
	for (int y = 0; y < image.height; y++)
		for (int x = 0; x < image.width; x++)
			tpix[y][x] = ipix[y][x] < (tpix[y][x] - offset) ? 0f : 1f;

	image.internalAssign(tmp);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	final FImage tmp = image.process(new MedianFilter(FilterSupport.createBlockSupport(sizeX, sizeY)));

	final float[][] tpix = tmp.pixels;
	final float[][] ipix = image.pixels;
	for (int y = 0; y < image.height; y++)
		for (int x = 0; x < image.width; x++)
			tpix[y][x] = ipix[y][x] < (tpix[y][x] - offset) ? 0f : 1f;

	image.internalAssign(tmp);
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	if (blockWidth >= 1 && blockHeight >= 1) {
		maxHorizontalSym(image, blockWidth);
		maxVerticalSym(image, blockWidth);
	} else {
		final FImage tmpImage = new FImage(image.width, image.height);

		for (int y = 0; y < image.height; y++) {
			for (int x = 0; x < image.width; x++) {
				float max = -Float.MAX_VALUE;

				for (final Pixel sp : support) {
					final int xx = x + sp.x;
					final int yy = y + sp.y;

					if (xx >= 0 && xx < image.width - 1 && yy >= 0 && yy < image.height - 1) {
						max = Math.max(max, image.pixels[yy][xx]);
					}
				}

				tmpImage.pixels[y][x] = max;
			}
		}
		image.internalAssign(tmpImage);
	}
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	if (blockWidth >= 1 && blockHeight >= 1) {
		minHorizontalSym(image, blockWidth);
		minVerticalSym(image, blockWidth);
	} else {
		final FImage tmpImage = new FImage(image.width, image.height);

		for (int y = 0; y < image.height; y++) {
			for (int x = 0; x < image.width; x++) {
				float min = Float.MAX_VALUE;

				for (final Pixel sp : support) {
					final int xx = x + sp.x;
					final int yy = y + sp.y;

					if (xx >= 0 && xx < image.width && yy >= 0 && yy < image.height) {
						min = Math.min(min, image.pixels[yy][xx]);
					}
				}

				tmpImage.pixels[y][x] = min;
			}
		}
		image.internalAssign(tmpImage);
	}
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
@Override
public void processImage(FImage image) {
	FImage blur1 = image.process(filter1);
	FImage blur2 = image.process(filter2);
	
	image.internalAssign(blur1.subtractInplace(blur2));
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see org.openimaj.image.processor.ImageProcessor#processImage(org.openimaj.image.Image)
 */
@Override
public void processImage(FImage image)
{
	// Find which regions might be text
	final FImage fmap = textRegionDetection(image);

	// Process the feature map
	processFeatureMap(fmap, image);

	// The output process image is the feature map
	image.internalAssign(fmap);
}
 

import org.openimaj.image.FImage; //导入方法依赖的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.image.FImage; //导入方法依赖的package包/类
protected static void internalDoubleSize(FImage image) {
	image.internalAssign(doubleSize(image));
}
 

import org.openimaj.image.FImage; //导入方法依赖的package包/类
protected static void internalHalfSize(FImage image) {
	image.internalAssign(halfSize(image));
}