finalImage = rOp.getAsBufferedImage();
public BufferedImage loadImage(String filePath){ RenderedOp img = JAI.create("fileload", filePath); return img.getAsBufferedImage(); }
public static RenderedImage scale(RenderedImage image, float scaleFactor) RenderingHints hints = new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); RenderedOp resizeOp = SubsampleAverageDescriptor.create(image, Double.valueOf(scaleFactor), Double.valueOf(scaleFactor), hints); BufferedImage bufferedResizedImage = resizeOp.getAsBufferedImage(); return bufferedResizedImage; }
public BufferedImage getImage(int level) { /*if(!computed) { compute(); } return levelImages.get(level); */ return readImage(imagesLocation.get(level)).getAsBufferedImage(); }
/** * Take an RBGA image and provide an output with the alpha channel removed. * This method assumes that the bands were premultiplied. * * @param rgba input RGBA image * @return output RGB image */ public static BufferedImage rgbaToRgb (BufferedImage rgba) { logger.info("Discarding alpha band ..."); return JAI.create("bandselect", rgba, new int[]{0, 1, 2}).getAsBufferedImage(); }
/** * Xor operation on two images. * * @param image1 first image to process * @param image2 second image to process * @return the resulting image */ public static BufferedImage xor (BufferedImage image1, BufferedImage image2) { return JAI.create("Xor", image1, image2).getAsBufferedImage(); }
public static BufferedImage resize(BufferedImage sourceImage, float rescaleXfactor, float rescaleYfactor, Interpolation interp) { return ScaleDescriptor.create(sourceImage, rescaleXfactor, rescaleYfactor, 0.0f, 0.0f, interp, null).getAsBufferedImage(); }
public static BufferedImage createConstImage2(int width, int height, Integer n) { return ConstantDescriptor.create((float) width, (float) height, new Integer[]{n}, null).getAsBufferedImage(); }
public static RenderedImage createConstImage(int width, int height, Integer n) { return ConstantDescriptor.create((float) width, (float) height, new Integer[]{n}, null).getAsBufferedImage(); }
FileOutputStream fos = new FileOutputStream("C:/test/output/myFile.tif"); RenderedOp src = JAI.create("fileload", "C:/test/input/myFile.jpg"); BufferedImage buf = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_BYTE_BINARY); buf.getGraphics().drawImage(src.getAsBufferedImage(), 0, 0, null); RenderedImage ri = (RenderedImage) buf; encodeParam = new TIFFEncodeParam (); encodeParam.setCompression(TIFFEncodeParam.COMPRESSION_GROUP4); ImageEncoder enc = ImageCodec.createImageEncoder("TIFF", fos, encodeParam); enc.encode(ri);
public static BufferedImage applyContrast(BufferedImage inputImage) { final BufferedImage extrema = ExtremaDescriptor.create(inputImage, null, 1, 1, false, 1, null).getAsBufferedImage(); double[][] minMax = (double[][]) extrema.getProperty("Extrema"); double min = minMax[0][0]; double max = minMax[1][0]; double dif = max - min; return rescale(1.0 / (max - min), min / (max - min), inputImage); }
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; }
RenderedOp op = JAI.create("fileload", filename); // gets the number of channels (R / RGB / RGBA) channels = op.getColorModel().getNumColorComponents(); // gets the depth of each component (16 16 16) depth = new int[channels]; for(int i=0; i<op.getColorModel().getNumColorComponents(); i++) { depth[i] = op.getColorModel().getComponentSize(i); } // gets the BufferedImage image = op.getAsBufferedImage();
/** * Take an RGB image and combine the R,G and B bands according to standard luminance * value to provide the output gray value. * * @param rgb input image with 3 bands RGB * @return a gray image */ public static BufferedImage rgbToGray (BufferedImage rgb) { logger.info("Converting RGB to gray ..."); // We use luminance value based on standard RGB combination double[][] matrix = {{0.114d, 0.587d, 0.299d, 0.0d}}; return JAI.create("bandcombine", new ParameterBlock().addSource(rgb).add(matrix), null) .getAsBufferedImage(); }
/** * Invert an image. * * @param image the image to process * @return the inverted image */ public static BufferedImage invert (BufferedImage image) { return JAI.create("Invert", new ParameterBlock().addSource(image).add(null), null) .getAsBufferedImage(); }
RenderedOp rop = JAI.create("fileload", file.getAbsolutePath()); ParameterBlock pb = new ParameterBlock(); pb.addSource(rop); pb.add(0.5f); pb.add(0.5f); rop = JAI.create("scale", pb); // For better looking results, but slower: // rop = JAI.create("SubsampleAverage", pb); BufferedImage bufImg = rop.getAsBufferedImage();
private Rectangle produceMap(double minX, double maxX, double minY, double maxY) { this.map .getViewport() .setBounds( new ReferencedEnvelope(minX, maxX, minY, maxY, DefaultGeographicCRS.WGS84)); RenderedImageMapOutputFormat rasterMapProducer = new RenderedImageMapOutputFormat(getWMS()); RenderedImageMap imageMap = rasterMapProducer.produceMap(this.map); this.op = (RenderedOp) imageMap.getImage(); this.image = this.op.getAsBufferedImage(); imageMap.dispose(); return new Rectangle(0, 0, this.image.getWidth(), this.image.getHeight()); } }
public static BufferedImage rescale(double multiplyFactor, double addFactor, BufferedImage sourceImage) { int bands = sourceImage.getData().getNumBands(); double[] multiplyParam = new double[bands], addParam = new double[bands]; for (int i = 0; i < bands; i++) { multiplyParam[i] = multiplyFactor; addParam[i] = addFactor; } ParameterBlock pbRescale = new ParameterBlock(); pbRescale.add(multiplyParam); pbRescale.add(addParam); pbRescale.addSource(sourceImage); return JAI.create("rescale", pbRescale).getAsBufferedImage(); }
public static BufferedImage addBorder(BufferedImage inputImage, int left, int right, int top, int bottom) { ParameterBlock pb = new ParameterBlock(); pb.addSource(inputImage); pb.add(left); pb.add(right); pb.add(top); pb.add(bottom); pb.add(BorderExtender.createInstance(BorderExtender.BORDER_ZERO)); return JAI.create("border", pb).getAsBufferedImage(); }
@Test public void test2BandsBug() { // build a transparent image BufferedImage image = new BufferedImage(256, 256, BufferedImage.TYPE_BYTE_GRAY); RenderedOp img = BandMergeDescriptor.create(null, 0, false, null, image, image); image = img.getAsBufferedImage(); // create a palette out of it RenderedImage indexed = quantize(image); assertTrue(indexed.getColorModel() instanceof IndexColorModel); IndexColorModel icm = (IndexColorModel) indexed.getColorModel(); // png encoder go mad if they get a one element palette, we need at // least two assertEquals(2, icm.getMapSize()); }