protected BufferedImage rescaleImageViaPlanarImage(BufferedImage image) { PlanarImage planarImage = new TiledImage(image, image.getWidth(), image.getHeight());
private static void fillImageAsInt(TiledImage img, Number[] array, int width, int height) { int k = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { img.setSample(x, y, 0, array[k++].intValue()); } } }
int numXTiles = image.getNumXTiles(); int numYTiles = image.getNumYTiles(); DataBuffer.TYPE_INT, image.getWidth(), image.getHeight(), 1); 0, 0, image.getWidth(), image.getHeight(), 0, 0, Raster srcTile = image.getTile(xt, yt); WritableRaster destTile = destImage.getWritableTile(xt, yt); destImage.releaseWritableTile(xt, yt);
/** * Create the tiled image and the associated graphics object that we will be used to draw the * vector features into a raster. * * <p>Note, the graphics objects will be an instance of TiledImageGraphics which is a sub-class * of Graphics2D. */ private void createImage(Dimension gridDim) { ColorModel cm = ColorModel.getRGBdefault(); SampleModel sm = cm.createCompatibleSampleModel(gridDim.width, gridDim.height); image = new TiledImage(0, 0, gridDim.width, gridDim.height, 0, 0, sm, cm); graphics = image.createGraphics(); graphics.setPaintMode(); graphics.setComposite(AlphaComposite.Src); }
new TiledImage( gridBounds.x, gridBounds.y, colorModel); final Point2D.Double point2D = new Point2D.Double(); final int numBands = tiled.getNumBands(); final double[] samples = new double[numBands]; final double[] padNaNs = new double[numBands];
private static TiledImage createImage(int dataType, int value) { SampleModel sm = new ComponentSampleModel(dataType, DEFAULT_WIDTH, DEFAULT_HEIGHT, 1, DEFAULT_WIDTH, new int[] { 0 }); TiledImage image = new TiledImage(sm, DEFAULT_TILE_WIDTH, DEFAULT_TILE_HEIGHT); int minX = 10; int maxX = 20; int minY = 10; int maxY = 20; for (int x = minX; x < maxX; x++) { for (int y = minY; y < maxY; y++) { image.setSample(x, y, 0, value); } } return image; }
TiledImage tImg = new TiledImage(minx, miny, width, height, 0, 0, sm, cm); for (int tileY = tImg.getMinTileY(); tileY <= tImg.getMaxTileY(); tileY++) { for (int tileX = tImg.getMinTileX(); tileX <= tImg.getMaxTileX(); tileX++) { WritableRaster raster = tImg.getWritableTile(tileX, tileY); WritableRaster child = raster.createWritableTranslatedChild(0, 0); child.setDataElements(0, 0, tile0); tImg.releaseWritableTile(tileX, tileY);
/** * Creates a tiled image from the supplied raster. Note that this method allocates a new raster for the tiled image * returned. The data of the given raster is then copied into the new one. */ public static TiledImage createTiledImage(Raster raster) { // create a float sample model SampleModel sampleModel = raster.getSampleModel(); // create a compatible ColorModel ColorModel colorModel = PlanarImage.createColorModel(sampleModel); // create a TiledImage using the float SampleModel TiledImage tiledImage = new TiledImage(0, 0, raster.getWidth(), raster.getHeight(), 0, 0, sampleModel, colorModel); // set the TiledImage data to that of the Raster tiledImage.setData(raster); JAIDebug.trace("createRenderedImage.tiledImage", tiledImage); return tiledImage; }
writeImage = new TiledImage(constant, (int) (DEFAULT_WIDTH / 16), (int) (DEFAULT_HEIGHT / 16)); Raster firstRaster = writeImage.getTile(writeImage.getMinTileX(), writeImage.getMinTileY()); writeImage.setSample(i, j, 0, sI); break; case DataBuffer.TYPE_SHORT: case DataBuffer.TYPE_INT: sI = (int) ((Math.random() - 0.5) * interval); writeImage.setSample(i, j, 0, sI); break; case DataBuffer.TYPE_FLOAT: float sF = (float) ((Math.random() - 0.5) * interval); writeImage.setSample(i, j, 0, sF); break; case DataBuffer.TYPE_DOUBLE: double s = (Math.random() - 0.5) * interval; writeImage.setSample(i, j, 0, s); break;
/******************************************************************************* * * ******************************************************************************/ public static WritableRaster getRaster (final PlanarImage source) { assert source.getNumXTiles() == 1 : "getNumXTiles is " + source.getNumXTiles(); assert source.getNumYTiles() == 1 : "getNumYTiles is " + source.getNumYTiles(); TiledImage tiledImage = new TiledImage(source, true); return tiledImage.getWritableTile(0, 0); // FIXME: in realta' per le TiledImage non esiste: ci sono tanti raster, uno // per ogni tile, e quindi richiederne uno solo implica un bel po' di lavoro // Verificare invece se si puo' eliminare questo metodo // Si potrebbe eliminare se il demosaicing venisse implementato come un'operazione JAI. }
private void setPopulation(String patternName) { PatternInfo info = getPattern(patternName); String[] lines = info.data.split("\n"); final int h = lines.length; int maxLen = 0; for (String line : lines) { if (line.length() > maxLen) { maxLen = line.length(); } } final int w = maxLen; final int ox = curWorld.getMinX() + (curWorld.getWidth() - w) / 2; final int oy = curWorld.getMinY() + (curWorld.getHeight() - h) / 2; for (int y = oy, iy = 0; iy < h; y++, iy++) { String line = lines[iy]; int len = line.length(); for (int x = ox, ix = 0; ix < len; x++, ix++) { if (line.charAt(ix) != '.') { curWorld.setSample(x, y, 0, 1); } } } }
@Override public GridCoverage2D read(GeneralParameterValue[] parameters) throws IOException { GridCoverage2D originalCoverage = super.read(parameters); RenderedImage source = new ImageWorker(originalCoverage.getRenderedImage()) .format(DataBuffer.TYPE_USHORT) .getRenderedImage(); TiledImage shortImage = new TiledImage( source.getMinX(), source.getMinY(), source.getWidth(), source.getHeight(), source.getTileGridXOffset(), source.getTileGridYOffset(), source.getSampleModel(), null); shortImage.set(source); // force color model to be null, this also occurs in real cases GridCoverage2D coverage = CoverageFactoryFinder.getGridCoverageFactory(null) .create( originalCoverage.getName(), shortImage, originalCoverage.getEnvelope2D()); return coverage; } };
/******************************************************************************* * * @inheritDoc * ******************************************************************************/ protected PlanarImage execute (AssignColorProfileOp operation, final EditableImage image, PlanarImage planarImage) { ICC_Profile iccProfile = operation.getICCProfile(); TiledImage tiledImage = new TiledImage(planarImage, true); int[] bandSelect = new int[planarImage.getSampleModel().getNumBands()]; for (int i = 0; i < bandSelect.length; i++) { bandSelect[i] = i; } return tiledImage.getSubImage(bandSelect, JAIUtils.getColorModel(planarImage, iccProfile)); } }
/** * Test if iterator transverse expected value in define area. * Area contains all image area. */ @Test public void rectEqualImageWriteWithinReadImageTest() { final Rectangle rect = new Rectangle(10, 10, 5, 2); minx = 0; miny = 0; width = 100; height = 50; tilesWidth = 10; tilesHeight = 5; numBand = 3; setRenderedImgTest(minx, miny, width, height, tilesWidth, tilesHeight, numBand, null); final SampleModel sampleMW = new PixelInterleavedSampleModel(getDataBufferType(), tilesWidth, tilesHeight, numBand, tilesWidth*numBand, new int[]{0, 1, 2}); final WritableRenderedImage rendWriteImage = new TiledImage(rect.x, rect.y, rect.width, rect.height, renderedImage.getTileGridXOffset(), renderedImage.getTileGridYOffset(), sampleMW, null); setPixelIterator(renderedImage, rendWriteImage, rect); while (pixIterator.next()) pixIterator.setSample(1); setPixelIterator(rendWriteImage); while (pixIterator.next()) assertTrue(pixIterator.getSampleDouble() == 1); }
@Test public void testPlanarImageTranslatedChild() throws Exception { SampleModel sm = new ComponentSampleModel(DataBuffer.TYPE_BYTE, 128, 128, 1, 128, new int[] {0}); TiledImage source = new TiledImage(0, 0, 512, 512, 0, 0, sm, PlanarImage.createColorModel(sm)); Raster[] tiles = source.getTiles(); assertEquals(16, tiles.length); // Without fix for GEOS-8137, this split call will cause a // java.lang.ClassCastException: java.awt.image.Raster cannot be cast to // java.awt.image.WritableRaster MetatileMapOutputFormat.split(key, source); } }
for (int i = 0; i < image.getHeight(); i++) { for (int j = 0; j < image.getWidth(); j++) { for (int b = 0; b < image.getNumBands(); b++) { int value = b == image.getNumBands() - 1 ? 1 : 0; image.setSample(j, i, b, value);
ColorModel cm = TiledImage.createColorModel(sm); if(cm == null) { TiledImage used = new TiledImage(0, 0, width, height, 0, 0, sm, cm);
@Test public void srcValueWithROI() throws Exception { String src = "dest = src;"; TiledImage srcImg = createSequenceImage(); RenderedImage triangleImage = createTriangleImage(); srcImg.setProperty("ROI", new ROI(triangleImage)); Evaluator evaluator = new Evaluator() { public double eval(double val) { return x > y ? val : Double.NaN; } }; imageParams = new HashMap<>(); imageParams.put("dest", Jiffle.ImageRole.DEST); imageParams.put("src", Jiffle.ImageRole.SOURCE); // test the direct runtime Jiffle jiffle = new Jiffle(src, imageParams); directRuntimeInstance = jiffle.getRuntimeInstance(); directRuntimeInstance.setSourceImage("src", srcImg); TiledImage destImg = ImageUtilities.createConstantImage( srcImg.getMinX(), srcImg.getMinY(), srcImg.getWidth(), srcImg.getHeight(), 0.0); directRuntimeInstance.setDestinationImage("dest", destImg); directRuntimeInstance.evaluateAll(null); assertImage(srcImg, destImg, evaluator); }
public void globalTest() { InterpolationBilinear jaiInterpol = new InterpolationBilinear(64); raster = renderedImage.getTile(renderedImage.getMinTileX(), renderedImage.getMinTileY()); int minpx = raster.getMinX(); int minpy = raster.getMinY();
graphic = ((BufferedImage) preparedImage).createGraphics(); } else if (preparedImage instanceof TiledImage) { graphic = ((TiledImage) preparedImage).createGraphics(); } else if (preparedImage instanceof VolatileImage) { graphic = ((VolatileImage) preparedImage).createGraphics();