/** * Returns the current kernel. * * @see KernelEditor#getKernel */ public KernelJAI getKernel() { final int height = elements.length; final int width = height!=0 ? elements[0].length : 0; final float[] data = new float[width*height]; int c=0; for (int j=0; j<height; j++) { for (int i=0; i<width; i++) { data[c++] = elements[j][i]; } } return new KernelJAI(width, height, data); }
/** * initialise les filtres */ private void initFilters(){ kernelList = new ArrayList<KernelJAI>(); for(int i=0;i<filter_size.length;i++){ for(int j=0;j<filter_ori.length;j++){ // GaborFilter f = new GaborFilter(filter_size[i],filter_ori[j],sigmas[i],lambdas[i]); kernelList.add(new KernelJAI(filter_size[i], filter_size[i], GaborFilterFactory.getGaborFilter(filter_size[i], filter_ori[j], sigmas[i], lambdas[i]))); } } }
/** * initialise les filtres */ private void initFilters(){ kernelList = new ArrayList<KernelJAI>(); for(int i=0;i<filter_size.length;i++){ for(int j=0;j<filter_ori.length;j++){ // GaborFilter f = new GaborFilter(filter_size[i],filter_ori[j],sigmas[i],lambdas[i]); kernelList.add(new KernelJAI(filter_size[i], filter_size[i], GaborFilterFactory.getGaborFilter(filter_size[i], filter_ori[j], sigmas[i], lambdas[i]))); } } }
/** * Adds a 3x3 kernel to the list of available kernels. */ private void addKernel(final String name, final float[] data) { double sum = 0; for (int i=0; i<data.length; i++) { sum += data[i]; } if (sum != 0) { for (int i=0; i<data.length; i++) { data[i] /= sum; } } addKernel(null, name, new KernelJAI(3,3,data)); }
/******************************************************************************* * * @inheritDoc * ******************************************************************************/ protected PlanarImage execute (ConvolveOp operation, final EditableImage image, PlanarImage planarImage) { RenderingHints hints = null; // FIXME Kernel kernel = operation.getKernel(); return ConvolveDescriptor.create(planarImage, new KernelJAI(kernel), hints); } }
@Override protected PlanarImage execute (ConvolveOp operation, final EditableImage image, PlanarImage planarImage) { RenderingHints hints = null; // FIXME Kernel kernel = operation.getKernel(); return ConvolveDescriptor.create(planarImage, new KernelJAI(kernel), hints); } }
public static RenderedImage doubleConvolve(RenderedImage input, float[] factor) { int kernelSize = factor.length; int rad = (kernelSize - 1) / 2; RenderedImage borderedImage = addBorder(input, rad, rad, rad, rad); KernelJAI kernel = new KernelJAI(kernelSize, 1, factor); RenderedImage convolvedImg = JAI.create("convolve", borderedImage, kernel);//.getAsBufferedImage(); kernel = new KernelJAI(1, kernelSize, factor); RenderedImage secondConvolvedImg = JAI.create("convolve", convolvedImg, kernel);//.getAsBufferedImage(); int mrad = (-1) * rad; RenderedImage finalImage = addBorder(secondConvolvedImg, mrad, mrad, mrad, mrad); return finalImage; }
/** * Creates a rectangular kernel where all elements have the same value. * The key element will be at {@code (width/2, height/2)}. * * @param width rectangle width * @param height rectangle height * @param value element value * * @return a new {@code KernelJAI} object * * @throws IllegalArgumentException if either {@code width} or {@code height} * are less than 1 */ public static KernelJAI createConstantRectangle(int width, int height, float value) { if (width < 1 || height < 1) { throw new IllegalArgumentException("width and height must both be >= 1"); } float [] weights = (new KernelFactoryHelper()).makeRect(width, height, value); return new KernelJAI(width, height, weights); }
public static KernelJAI createConstantCircle(int radius, float value) { if (radius <= 0) { throw new IllegalArgumentException( "Invalid radius (" + radius + "); must be > 0"); } KernelFactoryHelper helper = new KernelFactoryHelper(); float[] weights = helper.makeCircle(radius); int w = 2*radius + 1; helper.rowFill(weights, w, w, value); return new KernelJAI(w, w, weights); }
/** * Creates a rectangular kernel where all elements have the same value. * The key element will be at {@code (width/2, height/2)}. * * @param width rectangle width * @param height rectangle height * @param value element value * * @return a new {@code KernelJAI} object * * @throws IllegalArgumentException if either {@code width} or {@code height} * are less than 1 */ public static KernelJAI createConstantRectangle(int width, int height, float value) { if (width < 1 || height < 1) { throw new IllegalArgumentException("width and height must both be >= 1"); } float [] weights = (new KernelFactoryHelper()).makeRect(width, height, value); return new KernelJAI(width, height, weights); }
/** * Creates a new KernelJAI object with a rectangular configuraton. * An IllegalArgumentException will be thrown if width or height are less than 1. * <p> * This is equivalent to calling... * <p> * {@code createRectangle(width, height, Kernel.ValueType.BINARY, width/2, height/2, 1.0f) } * * @param width rectangle width * @param height rectangle height * * @return a new instance of KernelJAI */ public static KernelJAI createRectangle(int width, int height) { float [] weights = (new KernelFactoryHelper()).makeRect(width, height); return new KernelJAI(width, height, weights); }
/** * Creates a new KernelJAI object with a rectangular configuraton. * An IllegalArgumentException will be thrown if width or height are less than 1. * <p> * This is equivalent to calling... * <p> * {@code createRectangle(width, height, Kernel.ValueType.BINARY, width/2, height/2, 1.0f) } * * @param width rectangle width * @param height rectangle height * * @return a new instance of KernelJAI */ public static KernelJAI createRectangle(int width, int height) { float [] weights = (new KernelFactoryHelper()).makeRect(width, height); return new KernelJAI(width, height, weights); }
public static RenderedImage blur(RenderedImage image, int radius) { int klen = Math.max(radius, 2); int ksize = klen * klen; float f = 1f / ksize; float[] kern = new float[ksize]; for (int i = 0; i < ksize; i++) kern[i] = f; KernelJAI blur = new KernelJAI(klen, klen, kern); ParameterBlockJAI param = getParameterBlockJAIForImage(image, "Convolve"); param.setParameter("kernel", blur); // hint with border extender RenderingHints hint = new RenderingHints(JAI.KEY_BORDER_EXTENDER, BorderExtender .createInstance(BorderExtender.BORDER_COPY)); return JAI.create("Convolve", param, hint); } }
public static BufferedImage doubleConvolve(BufferedImage input, float[] factor) { int kernelSize = factor.length; int rad = (kernelSize - 1) / 2; BufferedImage borderedImage = addBorder(input, rad, rad, rad, rad); KernelJAI kernel = new KernelJAI(kernelSize, 1, factor); BufferedImage convolvedImg = JAI.create("convolve", borderedImage, kernel).getAsBufferedImage(); kernel = new KernelJAI(1, kernelSize, factor); BufferedImage secondConvolvedImg = JAI.create("convolve", convolvedImg, kernel).getAsBufferedImage(); int mrad = (-1) * rad; BufferedImage finalImage = addBorder(secondConvolvedImg, mrad, mrad, mrad, mrad); return finalImage; }
/** * Create a circular kernel where all elements within the circle * have a constant value while those outside have value 0.0. * Kernel width is {@code 2*radius + 1}. * The key element is at position {@code x=radius, y=radius}. * * @param radius radius of the circle * @param value constant value * * @return a new {@code KernelJAI} object */ public static KernelJAI createConstantCircle(int radius, float value) { if (radius <= 0) { throw new IllegalArgumentException( "Invalid radius (" + radius + "); must be > 0"); } KernelFactoryHelper helper = new KernelFactoryHelper(); float[] weights = helper.makeCircle(radius); int w = 2*radius + 1; helper.rowFill(weights, w, w, value); return new KernelJAI(w, w, weights); }
/** * Create a new KernelJAI object with a circular configuration. * Kernel elements within the circle will have value 1.0f; those * outside will have value 0.0f. * <p> * This is equivalent to, but faster than, calling... * <p> * {@code createCircle(radius, Kernel.ValueType.BINARY, 1.0f) } * * @param radius radius of the circle * @return a new instance of KernelJAI */ public static KernelJAI createCircle(int radius) { if (radius <= 0) { throw new IllegalArgumentException( "Invalid radius (" + radius + "); must be > 0"); } KernelFactoryHelper kh = new KernelFactoryHelper(); float[] weights = kh.makeCircle(radius); int w = 2*radius + 1; kh.rowFill(weights, w, w); return new KernelJAI(w, w, weights); }
/** * Create a new KernelJAI object with a circular configuration. * Kernel elements within the circle will have value 1.0f; those * outside will have value 0.0f. * <p> * This is equivalent to, but faster than, calling... * <p> * {@code createCircle(radius, Kernel.ValueType.BINARY, 1.0f) } * * @param radius radius of the circle * @return a new instance of KernelJAI */ public static KernelJAI createCircle(int radius) { if (radius <= 0) { throw new IllegalArgumentException( "Invalid radius (" + radius + "); must be > 0"); } KernelFactoryHelper kh = new KernelFactoryHelper(); float[] weights = kh.makeCircle(radius); int w = 2*radius + 1; kh.rowFill(weights, w, w); return new KernelJAI(w, w, weights); }
private KernelJAI createJaiKernel() { final double[] data = this.kernel.getKernelData(null); final float[] scaledData = new float[data.length]; final double factor = this.kernel.getFactor(); for (int i = 0; i < data.length; i++) { scaledData[i] = (float) (data[i] * factor); } return new KernelJAI(this.kernel.getWidth(), this.kernel.getHeight(), this.kernel.getXOrigin(), this.kernel.getYOrigin(), scaledData); } }
/** * Divides a kernel by some number. * * @param kernel The kernel to divide. * @param denominator The factor to divide by. * @return The resulting kernel. */ private static KernelJAI divide(KernelJAI kernel, final double denominator) { if (denominator != 1) { final float[] data = kernel.getKernelData(); final int length = data.length; for (int i=0; i<length; i++) { data[i] /= denominator; } kernel = new KernelJAI(kernel.getWidth(), kernel.getHeight(), kernel.getXOrigin(), kernel.getYOrigin(), data); } return kernel; }
/** * Divides a kernel by some number. * * @param kernel The kernel to divide. * @param denominator The factor to divide by. * @return The resulting kernel. */ private static KernelJAI divide(KernelJAI kernel, final double denominator) { if (denominator != 1) { final float[] data = kernel.getKernelData(); final int length = data.length; for (int i=0; i<length; i++) { data[i] /= denominator; } kernel = new KernelJAI(kernel.getWidth(), kernel.getHeight(), kernel.getXOrigin(), kernel.getYOrigin(), data); } return kernel; }