java.awt.image.Kernel Java Examples

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

@Override
public final BufferedImage apply(BufferedImage img) {
	
	float[][] matrix = getMatrix();
	float[] data = getKernelData(matrix);
	if(normalize)
		normalize(data); 
	scale(data);
	if(isZero(data))
		return new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB);
	
	Kernel k = new Kernel(matrix[0].length, matrix.length, data);
	ConvolveOp op = new ConvolveOp(k, ConvolveOp.EDGE_NO_OP, null);
	
	BufferedImage img2 = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB);
	img2.getGraphics().drawImage(img, 0, 0, null);
	
	return op.filter(img2, null);
}
 

public static ConvolveOp getBlurFilter(int radius) {
    if (radius < 1) {
        throw new IllegalArgumentException("Radius must be >= 1");
    }
    
    int size = radius * 2 + 1;
    float weight = 1.0f / (size * size);
    float[] data = new float[size * size];
    
    for (int i = 0; i < data.length; i++) {
        data[i] = weight;
    }
    
    Kernel kernel = new Kernel(size, size, data);
    return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
}
 

/**
 * Convert image to buffered image.
 *
 * @param img the object of the image to be converted to buffered image.
 * @return the converted buffered image.
 */
public static BufferedImage toBufferedImage(Image img) {
    if (img instanceof BufferedImage) {
        return (BufferedImage) img;
    }

    float softenFactor = 0.05f;
    final Image temp = new ImageIcon(img).getImage();
    final BufferedImage bufferedImage = new BufferedImage(
            temp.getWidth(null),
            temp.getHeight(null),
            BufferedImage.TYPE_INT_RGB);
    final Graphics g = bufferedImage.createGraphics();
    g.setColor(Color.white);
    g.fillRect(0, 0, temp.getWidth(null), temp.getHeight(null));
    g.drawImage(temp, 0, 0, null);
    g.dispose();

    final float[] softenArray = {0, softenFactor, 0, softenFactor, 1 - (softenFactor * 4), softenFactor, 0,
            softenFactor, 0};
    final Kernel kernel = new Kernel(3, 3, softenArray);
    final ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);

    return cOp.filter(bufferedImage, null);
}
 

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

@Override
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
    int width = src.getWidth();
    int height = src.getHeight();

    pt = createProgressTracker(width + height);

    if (dst == null) {
        dst = createCompatibleDestImage(src, null);
    }

    int[] inPixels = new int[width * height];
    int[] outPixels = new int[width * height];
    getRGB(src, 0, 0, width, height, inPixels);

    Kernel kernel = GaussianFilter.makeKernel(hRadius);
    thresholdBlur(kernel, inPixels, outPixels, width, height, true, pt);
    thresholdBlur(kernel, outPixels, inPixels, height, width, true, pt);

    setRGB(dst, 0, 0, width, height, inPixels);

    finishProgressTracker();

    return dst;
}
 

private static void enableConvolveOp(RenderQueue rq,
                                     SurfaceData srcData,
                                     ConvolveOp cop)
{
    // assert rq.lock.isHeldByCurrentThread();
    boolean edgeZero =
        cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
    Kernel kernel = cop.getKernel();
    int kernelWidth = kernel.getWidth();
    int kernelHeight = kernel.getHeight();
    int kernelSize = kernelWidth * kernelHeight;
    int sizeofFloat = 4;
    int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);

    RenderBuffer buf = rq.getBuffer();
    rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
    buf.putInt(ENABLE_CONVOLVE_OP);
    buf.putLong(srcData.getNativeOps());
    buf.putInt(edgeZero ? 1 : 0);
    buf.putInt(kernelWidth);
    buf.putInt(kernelHeight);
    buf.put(kernel.getKernelData(null));
}
 

private static BufferedImageOp createTestOp() {
    final int size = 1;
    final float v = 1f / (size * size);
    final float[] k_data = new float[size * size];
    Arrays.fill(k_data, v);

    Kernel k = new Kernel(size, size, k_data);
    return new ConvolveOp(k);
}
 

/**************************** ConvolveOp support ****************************/

    public static boolean isConvolveOpValid(ConvolveOp cop) {
        Kernel kernel = cop.getKernel();
        int kw = kernel.getWidth();
        int kh = kernel.getHeight();
        // REMIND: we currently can only handle 3x3 and 5x5 kernels,
        //         but hopefully this is just a temporary restriction;
        //         see native shader comments for more details
        if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
            return false;
        }
        return true;
    }
 

private static BufferedImageOp getConvolveOp() {
    int kw = 3;
    int kh = 3;
    int size = kw * kh;
    float[] kdata = new float[size];
    Arrays.fill(kdata, 1.0f / size);

    Kernel k  = new Kernel(kw, kh, kdata);
    return new ConvolveOp(k);
}
 

/**
 * Make a Gaussian blur kernel.
 *
 * @param radius desired kernel radius specified in pixels around center
 * @return the Gaussian kernel of desired radius
 */
public static Kernel makeKernel (float radius)
{
    final int r = (int) Math.ceil(radius);
    final int rows = (r * 2) + 1;
    final float[] matrix = new float[rows];
    final float sigma = 1f; //HB: was radius / 3;
    final float sigmaSq2 = 2 * sigma * sigma;
    final float radiusSq = radius * radius;

    float total = 0;
    int index = 0;

    for (int row = -r; row <= r; row++) {
        float distanceSq = row * row;

        if (distanceSq > radiusSq) {
            matrix[index] = 0;
        } else {
            matrix[index] = (float) Math.exp(-distanceSq / sigmaSq2);
        }

        total += matrix[index];
        index++;
    }

    // Normalize all matrix items
    for (int i = 0; i < rows; i++) {
        matrix[i] /= total;
    }

    return new Kernel(rows, 1, matrix);
}
 

/**************************** ConvolveOp support ****************************/

    public static boolean isConvolveOpValid(ConvolveOp cop) {
        Kernel kernel = cop.getKernel();
        int kw = kernel.getWidth();
        int kh = kernel.getHeight();
        // REMIND: we currently can only handle 3x3 and 5x5 kernels,
        //         but hopefully this is just a temporary restriction;
        //         see native shader comments for more details
        if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
            return false;
        }
        return true;
    }
 

/**************************** ConvolveOp support ****************************/

    public static boolean isConvolveOpValid(ConvolveOp cop) {
        Kernel kernel = cop.getKernel();
        int kw = kernel.getWidth();
        int kh = kernel.getHeight();
        // REMIND: we currently can only handle 3x3 and 5x5 kernels,
        //         but hopefully this is just a temporary restriction;
        //         see native shader comments for more details
        if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
            return false;
        }
        return true;
    }
 

/**
 * Make a Gaussian blur kernel.
 *
 * @param radius the blur radius
 * @return the kernel
 */
public static Kernel makeKernel(float radius) {
    int r = (int) Math.ceil(radius);
    int rows = r * 2 + 1;
    float[] matrix = new float[rows];
    float sigma = radius / 3;
    float sigma22 = 2 * sigma * sigma;
    float sigmaPi2 = 2 * ImageMath.PI * sigma;
    float sqrtSigmaPi2 = (float) Math.sqrt(sigmaPi2);
    float radius2 = radius * radius;
    float total = 0;
    int index = 0;
    for (int row = -r; row <= r; row++) {
        float distance = row * row;
        if (distance > radius2) {
            matrix[index] = 0;
        } else {
            matrix[index] = (float) Math.exp(-distance / sigma22) / sqrtSigmaPi2;
        }
        total += matrix[index];
        index++;
    }
    for (int i = 0; i < rows; i++) {
        matrix[i] /= total;
    }

    return new Kernel(rows, 1, matrix);
}
 

public static void convolve(Kernel kernel, int[] inPixels, int[] outPixels,
		int width, int height, boolean alpha, int edgeAction) {
	if (kernel.getHeight() == 1)
		convolveH(kernel, inPixels, outPixels, width, height, alpha,
				edgeAction);
	else if (kernel.getWidth() == 1)
		convolveV(kernel, inPixels, outPixels, width, height, alpha,
				edgeAction);
	else
		convolveHV(kernel, inPixels, outPixels, width, height, alpha,
				edgeAction);
}
 

/**
 * Make a Gaussian blur kernel.
 */
public static Kernel makeKernel(float radius) {
	int r = (int) Math.ceil(radius);
	int rows = r * 2 + 1;
	float[] matrix = new float[rows];
	float sigma = radius / 3;
	float sigma22 = 2 * sigma * sigma;
	float sigmaPi2 = 2 * ImageMath.PI * sigma;
	float sqrtSigmaPi2 = (float) Math.sqrt(sigmaPi2);
	float radius2 = radius * radius;
	float total = 0;
	int index = 0;
	for (int row = -r; row <= r; row++) {
		float distance = row * row;
		if (distance > radius2)
			matrix[index] = 0;
		else
			matrix[index] = (float) Math.exp(-(distance) / sigma22)
					/ sqrtSigmaPi2;
		total += matrix[index];
		index++;
	}
	for (int i = 0; i < rows; i++)
		matrix[i] /= total;

	return new Kernel(rows, 1, matrix);
}
 

private static BufferedImageOp createTestOp() {
    final int size = 1;
    final float v = 1f / (size * size);
    final float[] k_data = new float[size * size];
    Arrays.fill(k_data, v);

    Kernel k = new Kernel(size, size, k_data);
    return new ConvolveOp(k);
}
 

public OpCompatibleImageTest() {
    final Kernel kernel = new Kernel(3, 3,
            new float[] {
        1f/9f, 1f/9f, 1f/9f,
        1f/9f, 1f/9f, 1f/9f,
        1f/9f, 1f/9f, 1f/9f});
    op = new ConvolveOp(kernel);
}
 

/**************************** ConvolveOp support ****************************/

    public static boolean isConvolveOpValid(ConvolveOp cop) {
        Kernel kernel = cop.getKernel();
        int kw = kernel.getWidth();
        int kh = kernel.getHeight();
        // REMIND: we currently can only handle 3x3 and 5x5 kernels,
        //         but hopefully this is just a temporary restriction;
        //         see native shader comments for more details
        if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
            return false;
        }
        return true;
    }
 

/**
 * Creates a convolve widget with a specified ColvolveOp.
 * @param scene the scene
 * @param convolveOp the convolve operation
 */
public ConvolveWidget (Scene scene, ConvolveOp convolveOp) {
    super (scene);
    this.convolveOp = convolveOp;
    Kernel kernel = convolveOp.getKernel ();
    setBorder (BorderFactory.createEmptyBorder (kernel.getWidth (), kernel.getHeight ()));
}
 

/**
    * @param size
    * @return
    */
   private static ConvolveOp getBlurOp(int size) {
float[] data = new float[size * size];
float value = 1 / (float) (size * size);
for (int i = 0; i < data.length; i++) {
    data[i] = value;
}
return new ConvolveOp(new Kernel(size, size, data));
   }
 

private static BufferedImageOp createTestOp() {
    final int size = 1;
    final float v = 1f / (size * size);
    final float[] k_data = new float[size * size];
    Arrays.fill(k_data, v);

    Kernel k = new Kernel(size, size, k_data);
    return new ConvolveOp(k);
}
 

private static BufferedImageOp getConvolveOp() {
    int kw = 3;
    int kh = 3;
    int size = kw * kh;
    float[] kdata = new float[size];
    Arrays.fill(kdata, 1.0f / size);

    Kernel k  = new Kernel(kw, kh, kdata);
    return new ConvolveOp(k);
}
 

public OpCompatibleImageTest() {
    final Kernel kernel = new Kernel(3, 3,
            new float[] {
        1f/9f, 1f/9f, 1f/9f,
        1f/9f, 1f/9f, 1f/9f,
        1f/9f, 1f/9f, 1f/9f});
    op = new ConvolveOp(kernel);
}
 

private static BufferedImageOp createTestOp() {
    final int size = 1;
    final float v = 1f / (size * size);
    final float[] k_data = new float[size * size];
    Arrays.fill(k_data, v);

    Kernel k = new Kernel(size, size, k_data);
    return new ConvolveOp(k);
}
 

public static ConvolveOp getBlurFilter(int horizontalRadius,
        int verticalRadius) {
    int width = horizontalRadius * 2 + 1;
    int height = verticalRadius * 2 + 1;

    float weight = 1.0f / (width * height);
    float[] data = new float[width * height];
    
    for (int i = 0; i < data.length; i++) {
        data[i] = weight;
    }
    
    Kernel kernel = new Kernel(width, height, data);
    return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
}
 

/**
 * @param bimage
 */
private static BufferedImage blurImage(final BufferedImage bimage) {
    float[] fs = new float[] { 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f,
            1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f };
    final Kernel kernel = new Kernel(3, 3, fs);
    final BufferedImageOp op = new ConvolveOp(kernel);
    return op.filter(bimage, null);
}