Java Kernel.getWidth方法代码示例

import java.awt.image.Kernel; //导入方法依赖的package包/类
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));
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve a block of pixels.
 * @param kernel the kernel
 * @param inPixels the input pixels
 * @param outPixels the output pixels
 * @param width the width
 * @param height the height
 * @param alpha include alpha channel
 * @param edgeAction what to do at the edges
 */
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);
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**************************** 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;
    }
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
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);
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
     * Blur and transpose a block of ARGB pixels.
     *
     * @param kernel     the blur kernel
     * @param inPixels   the input pixels
     * @param outPixels  the output pixels
     * @param width      the width of the pixel array
     * @param height     the height of the pixel array
     * @param alpha      whether to blur the alpha channel
     * @param edgeAction what to do at the edges
     */
    public static void convolveAndTranspose(Kernel kernel, final int[] inPixels, final int[] outPixels, final int width, final int height, final boolean alpha, final boolean premultiply, final boolean unpremultiply, final int edgeAction) {
        final float[] matrix = kernel.getKernelData(null);
        int cols = kernel.getWidth();
        final int cols2 = cols / 2;

        boolean oneThreaded = (ThreadPool.NUM_AVAILABLE_PROCESSORS == 1);
//        boolean oneThreaded = true;

        if(oneThreaded) {
            for (int y = 0; y < height; y++) {
                convolveAndTransposeLine(inPixels, outPixels, width, height, alpha, premultiply, unpremultiply, edgeAction, matrix, cols2, y);
            }
        } else {
            Future<?>[] resultLines = new Future[height];

            for (int y = 0; y < height; y++) {
                final int finalY = y;
                Runnable lineTask = new Runnable() {
                    @Override
                    public void run() {
                        convolveAndTransposeLine(inPixels, outPixels, width, height, alpha, premultiply, unpremultiply, edgeAction, matrix, cols2, finalY);
                    }
                };
                Future<?> future = ThreadPool.executorService.submit(lineTask);
                resultLines[y] = future;
            }

            ThreadPool.waitForFutures(resultLines);
        }
    }
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
public static void convolveAndTranspose(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
	float[] matrix = kernel.getKernelData( null );
	int cols = kernel.getWidth();
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		int index = y;
		int ioffset = y*width;
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;
			int moffset = cols2;
			for (int col = -cols2; col <= cols2; col++) {
				float f = matrix[moffset+col];

				if (f != 0) {
					int ix = x+col;
					if ( ix < 0 ) {
						if ( edgeAction == CLAMP_EDGES )
							ix = 0;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					} else if ( ix >= width) {
						if ( edgeAction == CLAMP_EDGES )
							ix = width-1;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					}
					int rgb = inPixels[ioffset+ix];
					a += f * ((rgb >> 24) & 0xff);
					r += f * ((rgb >> 16) & 0xff);
					g += f * ((rgb >> 8) & 0xff);
					b += f * (rgb & 0xff);
				}
			}
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[index] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
               index += height;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a 2D kernel
 * 
 * @param kernel the kernel to apply
 * @param inPixels the input pixels
 * @param outPixels the output pixels
 * @param width the width of the image
 * @param height the height of the image
 * @param alpha whether alpha is present
 * @param edgeAction one of the edge constants
 */
public static void convolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
	int index = 0;
	float[] matrix = kernel.getKernelData( null );
	int rows = kernel.getHeight();
	int cols = kernel.getWidth();
	int rows2 = rows/2;
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;

			for (int row = -rows2; row <= rows2; row++) {
				int iy = y+row;
				int ioffset;
				if (0 <= iy && iy < height)
					ioffset = iy*width;
				else if ( edgeAction == CLAMP_EDGES )
					ioffset = y*width;
				else if ( edgeAction == WRAP_EDGES )
					ioffset = ((iy+height) % height) * width;
				else
					continue;
				int moffset = cols*(row+rows2)+cols2;
				for (int col = -cols2; col <= cols2; col++) {
					float f = matrix[moffset+col];

					if (f != 0) {
						int ix = x+col;
						if (!(0 <= ix && ix < width)) {
							if ( edgeAction == CLAMP_EDGES )
								ix = x;
							else if ( edgeAction == WRAP_EDGES )
								ix = (x+width) % width;
							else
								continue;
						}
						int rgb = inPixels[ioffset+ix];
						a += f * ((rgb >> 24) & 0xff);
						r += f * ((rgb >> 16) & 0xff);
						g += f * ((rgb >> 8) & 0xff);
						b += f * (rgb & 0xff);
					}
				}
			}
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a kernel consisting of one row
 * 
 * @param kernel the kernel to apply
 * @param inPixels the input pixels
 * @param outPixels the output pixels
 * @param width the width of the image
 * @param height the height of the image
 * @param alpha whether alpha is present
 * @param edgeAction one of the edge constants
 */
public static void convolveH(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
	int index = 0;
	float[] matrix = kernel.getKernelData( null );
	int cols = kernel.getWidth();
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		int ioffset = y*width;
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;
			int moffset = cols2;
			for (int col = -cols2; col <= cols2; col++) {
				float f = matrix[moffset+col];

				if (f != 0) {
					int ix = x+col;
					if ( ix < 0 ) {
						if ( edgeAction == CLAMP_EDGES )
							ix = 0;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					} else if ( ix >= width) {
						if ( edgeAction == CLAMP_EDGES )
							ix = width-1;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					}
					int rgb = inPixels[ioffset+ix];
					a += f * ((rgb >> 24) & 0xff);
					r += f * ((rgb >> 16) & 0xff);
					g += f * ((rgb >> 8) & 0xff);
					b += f * (rgb & 0xff);
				}
			}
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
     * Convolve with a kernel consisting of one row
     */
    private void thresholdBlur(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha) {
//		int index = 0;
        float[] matrix = kernel.getKernelData(null);
        int cols = kernel.getWidth();
        int cols2 = cols / 2;

        for (int y = 0; y < height; y++) {
            int ioffset = y * width;
            int outIndex = y;
            for (int x = 0; x < width; x++) {
                float r = 0, g = 0, b = 0, a = 0;
                int moffset = cols2;

                int rgb1 = inPixels[ioffset + x];
                int a1 = (rgb1 >> 24) & 0xff;
                int r1 = (rgb1 >> 16) & 0xff;
                int g1 = (rgb1 >> 8) & 0xff;
                int b1 = rgb1 & 0xff;
                float af = 0, rf = 0, gf = 0, bf = 0;
                for (int col = -cols2; col <= cols2; col++) {
                    float f = matrix[moffset + col];

                    if (f != 0) {
                        int ix = x + col;
                        if (!(0 <= ix && ix < width)) {
                            ix = x;
                        }
                        int rgb2 = inPixels[ioffset + ix];
                        int a2 = (rgb2 >> 24) & 0xff;
                        int r2 = (rgb2 >> 16) & 0xff;
                        int g2 = (rgb2 >> 8) & 0xff;
                        int b2 = rgb2 & 0xff;

                        int d;
                        d = a1 - a2;
                        if (d >= -threshold && d <= threshold) {
                            a += f * a2;
                            af += f;
                        }
                        d = r1 - r2;
                        if (d >= -threshold && d <= threshold) {
                            r += f * r2;
                            rf += f;
                        }
                        d = g1 - g2;
                        if (d >= -threshold && d <= threshold) {
                            g += f * g2;
                            gf += f;
                        }
                        d = b1 - b2;
                        if (d >= -threshold && d <= threshold) {
                            b += f * b2;
                            bf += f;
                        }
                    }
                }
                a = af == 0 ? a1 : a / af;
                r = rf == 0 ? r1 : r / rf;
                g = gf == 0 ? g1 : g / gf;
                b = bf == 0 ? b1 : b / bf;
                int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
                int ir = PixelUtils.clamp((int) (r + 0.5));
                int ig = PixelUtils.clamp((int) (g + 0.5));
                int ib = PixelUtils.clamp((int) (b + 0.5));
                outPixels[outIndex] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
                outIndex += height;
            }
        }
    }
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a 2D kernel.
 *
 * @param kernel     the kernel
 * @param inPixels   the input pixels
 * @param outPixels  the output pixels
 * @param width      the width
 * @param height     the height
 * @param alpha      include alpha channel
 * @param edgeAction what to do at the edges
 */
public static void convolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
    int index = 0;
    float[] matrix = kernel.getKernelData(null);
    int rows = kernel.getHeight();
    int cols = kernel.getWidth();
    int rows2 = rows / 2;
    int cols2 = cols / 2;

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            float r = 0, g = 0, b = 0, a = 0;

            for (int row = -rows2; row <= rows2; row++) {
                int iy = y + row;
                int ioffset;
                if (0 <= iy && iy < height) {
                    ioffset = iy * width;
                } else if (edgeAction == CLAMP_EDGES) {
                    ioffset = y * width;
                } else if (edgeAction == WRAP_EDGES) {
                    ioffset = ((iy + height) % height) * width;
                } else {
                    continue;
                }
                int moffset = cols * (row + rows2) + cols2;
                for (int col = -cols2; col <= cols2; col++) {
                    float f = matrix[moffset + col];

                    if (f != 0) {
                        int ix = x + col;
                        if (!(0 <= ix && ix < width)) {
                            if (edgeAction == CLAMP_EDGES) {
                                ix = x;
                            } else if (edgeAction == WRAP_EDGES) {
                                ix = (x + width) % width;
                            } else {
                                continue;
                            }
                        }
                        int rgb = inPixels[ioffset + ix];
                        a += f * ((rgb >> 24) & 0xff);
                        r += f * ((rgb >> 16) & 0xff);
                        g += f * ((rgb >> 8) & 0xff);
                        b += f * (rgb & 0xff);
                    }
                }
            }
            int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
            int ir = PixelUtils.clamp((int) (r + 0.5));
            int ig = PixelUtils.clamp((int) (g + 0.5));
            int ib = PixelUtils.clamp((int) (b + 0.5));
            outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
        }
    }
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a kernel consisting of one row.
 *
 * @param kernel     the kernel
 * @param inPixels   the input pixels
 * @param outPixels  the output pixels
 * @param width      the width
 * @param height     the height
 * @param alpha      include alpha channel
 * @param edgeAction what to do at the edges
 */
public static void convolveH(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
    int index = 0;
    float[] matrix = kernel.getKernelData(null);
    int cols = kernel.getWidth();
    int cols2 = cols / 2;

    for (int y = 0; y < height; y++) {
        int ioffset = y * width;
        for (int x = 0; x < width; x++) {
            float r = 0, g = 0, b = 0, a = 0;
            int moffset = cols2;
            for (int col = -cols2; col <= cols2; col++) {
                float f = matrix[moffset + col];

                if (f != 0) {
                    int ix = x + col;
                    if (ix < 0) {
                        if (edgeAction == CLAMP_EDGES) {
                            ix = 0;
                        } else if (edgeAction == WRAP_EDGES) {
                            ix = (x + width) % width;
                        }
                    } else if (ix >= width) {
                        if (edgeAction == CLAMP_EDGES) {
                            ix = width - 1;
                        } else if (edgeAction == WRAP_EDGES) {
                            ix = (x + width) % width;
                        }
                    }
                    int rgb = inPixels[ioffset + ix];
                    a += f * ((rgb >> 24) & 0xff);
                    r += f * ((rgb >> 16) & 0xff);
                    g += f * ((rgb >> 8) & 0xff);
                    b += f * (rgb & 0xff);
                }
            }
            int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
            int ir = PixelUtils.clamp((int) (r + 0.5));
            int ig = PixelUtils.clamp((int) (g + 0.5));
            int ib = PixelUtils.clamp((int) (b + 0.5));
            outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
        }
    }
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
private void gaussBlurGrayScale(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height) {
	float[] matrix = kernel.getKernelData(null);
	int cols = kernel.getWidth();
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		int index = y;
		int ioffset = y*width;
		
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0/*, a = 0*/;
			int moffset = cols2;
			
			for (int col = -cols2; col <= cols2; col++) {
				float f = matrix[moffset+col];

				if (f != 0) {
					int ix = x + col;
					
					if (ix < 0) {
						ix = 0 ;
					} else if ( ix >= width) {
						ix = width - 1;
					}
				
					int rgb = inPixels[ioffset+ix];
					//a += f * ((rgb >> 24) & 0xff);
					r += f * ((rgb >> 16) & 0xff);
					g += f * ((rgb >> 8) & 0xff);
					b += f * (rgb & 0xff);
				}
			}
			
			//int ia = alpha ? clamped((int)(a+0.5)) : 0xff;
			int ir = clamped((int)(r+0.5));
			int ig = clamped((int)(g+0.5));
			int ib = clamped((int)(b+0.5));
			outPixels[index] = (ir << 16) | (ig << 8) | ib;
			
               index += height;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a kernel consisting of one row.
    * @param kernel the kernel
    * @param inPixels the input pixels
    * @param outPixels the output pixels
    * @param width the width
    * @param height the height
    * @param alpha include alpha channel
    * @param edgeAction what to do at the edges
 */
public static void convolveH(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
	int index = 0;
	float[] matrix = kernel.getKernelData( null );
	int cols = kernel.getWidth();
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		int ioffset = y*width;
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;
			int moffset = cols2;
			for (int col = -cols2; col <= cols2; col++) {
				float f = matrix[moffset+col];

				if (f != 0) {
					int ix = x+col;
					if ( ix < 0 ) {
						if ( edgeAction == CLAMP_EDGES )
							ix = 0;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					} else if ( ix >= width) {
						if ( edgeAction == CLAMP_EDGES )
							ix = width-1;
						else if ( edgeAction == WRAP_EDGES )
							ix = (x+width) % width;
					}
					int rgb = inPixels[ioffset+ix];
					a += f * ((rgb >> 24) & 0xff);
					r += f * ((rgb >> 16) & 0xff);
					g += f * ((rgb >> 8) & 0xff);
					b += f * (rgb & 0xff);
				}
			}
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a 2D kernel.
    * @param kernel the kernel
    * @param inPixels the input pixels
    * @param outPixels the output pixels
    * @param width the width
    * @param height the height
    * @param alpha include alpha channel
    * @param edgeAction what to do at the edges
 */
public static void convolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
	int index = 0;
	float[] matrix = kernel.getKernelData( null );
	int rows = kernel.getHeight();
	int cols = kernel.getWidth();
	int rows2 = rows/2;
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;

			for (int row = -rows2; row <= rows2; row++) {
				int iy = y+row;
				int ioffset;
				if (0 <= iy && iy < height)
					ioffset = iy*width;
				else if ( edgeAction == CLAMP_EDGES )
					ioffset = y*width;
				else if ( edgeAction == WRAP_EDGES )
					ioffset = ((iy+height) % height) * width;
				else
					continue;
				int moffset = cols*(row+rows2)+cols2;
				for (int col = -cols2; col <= cols2; col++) {
					float f = matrix[moffset+col];

					if (f != 0) {
						int ix = x+col;
						if (!(0 <= ix && ix < width)) {
							if ( edgeAction == CLAMP_EDGES )
								ix = x;
							else if ( edgeAction == WRAP_EDGES )
								ix = (x+width) % width;
							else
								continue;
						}
						int rgb = inPixels[ioffset+ix];
						a += f * ((rgb >> 24) & 0xff);
						r += f * ((rgb >> 16) & 0xff);
						g += f * ((rgb >> 8) & 0xff);
						b += f * (rgb & 0xff);
					}
				}
			}
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
		}
	}
}
 

import java.awt.image.Kernel; //导入方法依赖的package包/类
/**
 * Convolve with a kernel consisting of one row
 */
private void thresholdBlur(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha) {
	int index = 0;
	float[] matrix = kernel.getKernelData( null );
	int cols = kernel.getWidth();
	int cols2 = cols/2;

	for (int y = 0; y < height; y++) {
		int ioffset = y*width;
           int outIndex = y;
		for (int x = 0; x < width; x++) {
			float r = 0, g = 0, b = 0, a = 0;
			int moffset = cols2;

               int rgb1 = inPixels[ioffset+x];
               int a1 = (rgb1 >> 24) & 0xff;
               int r1 = (rgb1 >> 16) & 0xff;
               int g1 = (rgb1 >> 8) & 0xff;
               int b1 = rgb1 & 0xff;
			float af = 0, rf = 0, gf = 0, bf = 0;
               for (int col = -cols2; col <= cols2; col++) {
				float f = matrix[moffset+col];

				if (f != 0) {
					int ix = x+col;
					if (!(0 <= ix && ix < width)) {
                                                   ix = x;
                                               }
					int rgb2 = inPixels[ioffset+ix];
                       int a2 = (rgb2 >> 24) & 0xff;
                       int r2 = (rgb2 >> 16) & 0xff;
                       int g2 = (rgb2 >> 8) & 0xff;
                       int b2 = rgb2 & 0xff;

					int d;
                       d = a1-a2;
                       if ( d >= -threshold && d <= threshold ) {
                           a += f * a2;
                           af += f;
                       }
                       d = r1-r2;
                       if ( d >= -threshold && d <= threshold ) {
                           r += f * r2;
                           rf += f;
                       }
                       d = g1-g2;
                       if ( d >= -threshold && d <= threshold ) {
                           g += f * g2;
                           gf += f;
                       }
                       d = b1-b2;
                       if ( d >= -threshold && d <= threshold ) {
                           b += f * b2;
                           bf += f;
                       }
				}
			}
               a = af == 0 ? a1 : a/af;
               r = rf == 0 ? r1 : r/rf;
               g = gf == 0 ? g1 : g/gf;
               b = bf == 0 ? b1 : b/bf;
			int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
			int ir = PixelUtils.clamp((int)(r+0.5));
			int ig = PixelUtils.clamp((int)(g+0.5));
			int ib = PixelUtils.clamp((int)(b+0.5));
			outPixels[outIndex] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
               outIndex += height;
		}
	}
}