Blurs the source pixels into the destination pixels in Image. - Java 2D Graphics

Java examples for 2D Graphics:BufferedImage Pixel

  1. HOME
  2. Java
  3. 2D Graphics
  4. BufferedImage Pixel

Description

Blurs the source pixels into the destination pixels in Image.

Demo Code

/*//from  ww  w.  j  a  v  a2 s .c o m
 * @(#)EffectUtils.java   1.2 07/12/12
 *
 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
//package com.java2s;

public class Main {
    /**
     * <p>
     * Blurs the source pixels into the destination pixels. The force of the
     * blur is specified by the radius which must be greater than 0.
     * </p>
     * <p>
     * The source and destination pixels arrays are expected to be in the
     * INT_ARGB format.
     * </p>
     * <p>
     * After this method is executed, dstPixels contains a transposed and
     * filtered copy of srcPixels.
     * </p>
     * 
     * @param srcPixels
     *            the source pixels
     * @param dstPixels
     *            the destination pixels
     * @param width
     *            the width of the source picture
     * @param height
     *            the height of the source picture
     * @param kernel
     *            the kernel of the blur effect
     * @param radius
     *            the radius of the blur effect
     */
    private static void blur(int[] srcPixels, int[] dstPixels, int width,
            int height, float[] kernel, int radius) {
        float a;
        float r;
        float g;
        float b;

        int ca;
        int cr;
        int cg;
        int cb;

        for (int y = 0; y < height; y++) {
            int index = y;
            int offset = y * width;

            for (int x = 0; x < width; x++) {
                a = r = g = b = 0.0f;

                for (int i = -radius; i <= radius; i++) {
                    int subOffset = x + i;
                    if (subOffset < 0 || subOffset >= width) {
                        subOffset = (x + width) % width;
                    }

                    int pixel = srcPixels[offset + subOffset];
                    float blurFactor = kernel[radius + i];

                    a += blurFactor * ((pixel >> 24) & 0xFF);
                    r += blurFactor * ((pixel >> 16) & 0xFF);
                    g += blurFactor * ((pixel >> 8) & 0xFF);
                    b += blurFactor * ((pixel) & 0xFF);
                }

                ca = (int) (a + 0.5f);
                cr = (int) (r + 0.5f);
                cg = (int) (g + 0.5f);
                cb = (int) (b + 0.5f);

                dstPixels[index] = ((ca > 255 ? 255 : ca) << 24)
                        | ((cr > 255 ? 255 : cr) << 16)
                        | ((cg > 255 ? 255 : cg) << 8)
                        | (cb > 255 ? 255 : cb);
                index += height;
            }
        }
    }

    /**
     * <p>
     * Blurs the source pixels into the destination pixels. The force of the
     * blur is specified by the radius which must be greater than 0.
     * </p>
     * <p>
     * The source and destination pixels arrays are expected to be in the
     * BYTE_GREY format.
     * </p>
     * <p>
     * After this method is executed, dstPixels contains a transposed and
     * filtered copy of srcPixels.
     * </p>
     * 
     * @param srcPixels
     *            the source pixels
     * @param dstPixels
     *            the destination pixels
     * @param width
     *            the width of the source picture
     * @param height
     *            the height of the source picture
     * @param kernel
     *            the kernel of the blur effect
     * @param radius
     *            the radius of the blur effect
     */
    static void blur(byte[] srcPixels, byte[] dstPixels, int width,
            int height, float[] kernel, int radius) {
        float p;
        int cp;
        for (int y = 0; y < height; y++) {
            int index = y;
            int offset = y * width;
            for (int x = 0; x < width; x++) {
                p = 0.0f;
                for (int i = -radius; i <= radius; i++) {
                    int subOffset = x + i;
                    // if (subOffset < 0) subOffset = 0;
                    // if (subOffset >= width) subOffset = width-1;
                    if (subOffset < 0 || subOffset >= width) {
                        subOffset = (x + width) % width;
                    }
                    int pixel = srcPixels[offset + subOffset] & 0xFF;
                    float blurFactor = kernel[radius + i];
                    p += blurFactor * pixel;
                }
                cp = (int) (p + 0.5f);
                dstPixels[index] = (byte) (cp > 255 ? 255 : cp);
                index += height;
            }
        }
    }
}

Related Tutorials