protected boolean writeImage(String dstPath, String type, RenderedOp image) { boolean success = false; // JAI doesn't natively support GIF encoding, but Java ImageIO does. if (type.toLowerCase().equals("gif")) { File dst = new File(dstPath); // if the file doesn't exist, create it and make sure we can write to it. if (!dst.exists()) { try { dst.createNewFile(); } catch (IOException ioe) { this.core.app.logError( ErrorReporter.errorMsg(this.getClass(), "resizeImg") + "Failed to create tmp img at \"" + dstPath + "\".", ioe); } } if (!dst.canWrite()) { dst.setWritable(true); } try { ImageIO.write(image, type.toUpperCase(), dst); } catch (IOException ioe) { this.core.app.logError( ErrorReporter.errorMsg(this.getClass(), "resizeImg") + "Failed to write image data to \"" + dstPath + "\".", ioe); } // clean up file handle dst = null; } else { if (type.toLowerCase().equals("jpg")) { type = "jpeg"; } JAI.create("filestore", image, dstPath, type); } if (image != null && new File(dstPath).exists()) { success = true; } // JAI Cleanup image.dispose(); image = null; type = null; return success; }
// This method is similar to the testBandMerge method but it tests the ExtendedBandMergeOpImage // class private void testExtendedBandMerge(RenderedImage[] sources, boolean noDataUsed, boolean roiUsed) { // Optional No Data Range used Range[] noData; // Source image data type int dataType = sources[0].getSampleModel().getDataType(); // If no Data are present, the No Data Range associated is used if (noDataUsed) { switch (dataType) { case DataBuffer.TYPE_BYTE: noData = noDataByte; break; case DataBuffer.TYPE_USHORT: noData = noDataUShort; break; case DataBuffer.TYPE_SHORT: noData = noDataShort; break; case DataBuffer.TYPE_INT: noData = noDataInt; break; case DataBuffer.TYPE_FLOAT: noData = noDataFloat; break; case DataBuffer.TYPE_DOUBLE: noData = noDataDouble; break; default: throw new IllegalArgumentException("Wrong data type"); } } else { noData = null; } // ROI to use ROI roi = null; if (roiUsed) { roi = roiData; } // New array ofr the transformed source images RenderedOp[] translated = new RenderedOp[sources.length]; List<AffineTransform> transform = new ArrayList<AffineTransform>(); for (int i = 0; i < sources.length; i++) { // Translation coefficients int xTrans = (int) (Math.random() * 10); int yTrans = (int) (Math.random() * 10); // Translation operation AffineTransform tr = AffineTransform.getTranslateInstance(xTrans, yTrans); // Addition to the transformations list transform.add(tr); // Translation of the image translated[i] = TranslateDescriptor.create(sources[i], (float) xTrans, (float) yTrans, null, null); } // Definition of the final image dimensions ImageLayout layout = new ImageLayout(); layout.setMinX(sources[0].getMinX()); layout.setMinY(sources[0].getMinY()); layout.setWidth(sources[0].getWidth()); layout.setHeight(sources[0].getHeight()); RenderingHints hints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout); // BandMerge operation RenderedOp merged = BandMergeDescriptor.create(noData, destNoData, hints, transform, roi, translated); Assert.assertNotNull(merged.getTiles()); // Check if the bands number is the same assertEquals(BAND_NUMBER, merged.getNumBands()); // Upper-Left tile indexes int minTileX = merged.getMinTileX(); int minTileY = merged.getMinTileY(); // Raster object Raster upperLeftTile = merged.getTile(minTileX, minTileY); // Tile bounds int minX = upperLeftTile.getMinX(); int minY = upperLeftTile.getMinY(); int maxX = upperLeftTile.getWidth() + minX; int maxY = upperLeftTile.getHeight() + minY; // Source corners final int dstMinX = merged.getMinX(); final int dstMinY = merged.getMinY(); final int dstMaxX = merged.getMaxX(); final int dstMaxY = merged.getMaxY(); Point2D ptDst = new Point2D.Double(0, 0); Point2D ptSrc = new Point2D.Double(0, 0); // Cycle on all the tile Bands for (int b = 0; b < BAND_NUMBER; b++) { RandomIter iter = RandomIterFactory.create(translated[b], null); // Source corners final int srcMinX = translated[b].getMinX(); final int srcMinY = translated[b].getMinY(); final int srcMaxX = translated[b].getMaxX(); final int srcMaxY = translated[b].getMaxY(); // Cycle on the y-axis for (int x = minX; x < maxX; x++) { // Cycle on the x-axis for (int y = minY; y < maxY; y++) { // Calculated value double value = upperLeftTile.getSampleDouble(x, y, b); // If the tile pixels are outside the image bounds, then no data is set. if (x < dstMinX || x >= dstMaxX || y < dstMinY || y >= dstMaxY) { value = destNoData; } // Set the x,y destination pixel location ptDst.setLocation(x, y); // Map destination pixel to source pixel transform.get(b).transform(ptDst, ptSrc); // Source pixel indexes int srcX = round(ptSrc.getX()); int srcY = round(ptSrc.getY()); double valueOld = destNoData; // Check if the pixel is inside the source bounds if (!(srcX < srcMinX || srcX >= srcMaxX || srcY < srcMinY || srcY >= srcMaxY)) { // Old band value valueOld = iter.getSampleDouble(srcX, srcY, 0); } // ROI CHECK boolean contained = true; if (roiUsed) { if (!roi.contains(x, y)) { contained = false; // Comparison if the final value is not inside a ROI assertEquals(value, destNoData, TOLERANCE); } } if (contained) { // If no Data are present, no data check is performed if (noDataUsed) { switch (dataType) { case DataBuffer.TYPE_BYTE: byte sampleB = ImageUtil.clampRoundByte(value); byte sampleBOld = ImageUtil.clampRoundByte(valueOld); if (noData[0].contains(sampleBOld)) { assertEquals(sampleB, destNoData, TOLERANCE); } else { assertEquals(sampleB, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_USHORT: short sampleUS = ImageUtil.clampRoundUShort(value); short sampleUSOld = ImageUtil.clampRoundUShort(valueOld); if (noData[0].contains(sampleUSOld)) { assertEquals(sampleUS, destNoData, TOLERANCE); } else { assertEquals(sampleUS, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_SHORT: short sampleS = ImageUtil.clampRoundShort(value); short sampleSOld = ImageUtil.clampRoundShort(valueOld); if (noData[0].contains(sampleSOld)) { assertEquals(sampleS, destNoData, TOLERANCE); } else { assertEquals(sampleS, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_INT: int sampleI = ImageUtil.clampRoundInt(value); int sampleIOld = ImageUtil.clampRoundInt(valueOld); if (noData[0].contains(sampleIOld)) { assertEquals(sampleI, destNoData, TOLERANCE); } else { assertEquals(sampleI, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_FLOAT: float sampleF = ImageUtil.clampFloat(value); float sampleFOld = ImageUtil.clampFloat(valueOld); if (noData[0].contains(sampleFOld)) { assertEquals(sampleF, destNoData, TOLERANCE); } else { assertEquals(sampleF, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_DOUBLE: if (noData[0].contains(valueOld)) { assertEquals(value, destNoData, TOLERANCE); } else { assertEquals(value, valueOld, TOLERANCE); } break; default: throw new IllegalArgumentException("Wrong data type"); } } else { // Else a simple value comparison is done assertEquals(value, valueOld, TOLERANCE); } } } } } // Disposal of the output image merged.dispose(); }
private void testBandMerge(RenderedImage[] sources, boolean noDataUsed, boolean roiUsed) { // Optional No Data Range used Range[] noData; // Source image data type int dataType = sources[0].getSampleModel().getDataType(); // If no Data are present, the No Data Range associated is used if (noDataUsed) { switch (dataType) { case DataBuffer.TYPE_BYTE: noData = noDataByte; break; case DataBuffer.TYPE_USHORT: noData = noDataUShort; break; case DataBuffer.TYPE_SHORT: noData = noDataShort; break; case DataBuffer.TYPE_INT: noData = noDataInt; break; case DataBuffer.TYPE_FLOAT: noData = noDataFloat; break; case DataBuffer.TYPE_DOUBLE: noData = noDataDouble; break; default: throw new IllegalArgumentException("Wrong data type"); } } else { noData = null; } // ROI to use ROI roi = null; if (roiUsed) { roi = roiData; } // BandMerge operation RenderedOp merged = BandMergeDescriptor.create(noData, destNoData, null, null, roi, sources); // Check if the bands number is the same assertEquals(BAND_NUMBER, merged.getNumBands()); // Upper-Left tile indexes int minTileX = merged.getMinTileX(); int minTileY = merged.getMinTileY(); // Raster object Raster upperLeftTile = merged.getTile(minTileX, minTileY); // Tile bounds int minX = upperLeftTile.getMinX(); int minY = upperLeftTile.getMinY(); int maxX = upperLeftTile.getWidth() + minX; int maxY = upperLeftTile.getHeight() + minY; // Cycle on all the tile Bands for (int b = 0; b < BAND_NUMBER; b++) { // Selection of the source raster associated with the band Raster bandRaster = sources[b].getTile(minTileX, minTileY); // Cycle on the y-axis for (int x = minX; x < maxX; x++) { // Cycle on the x-axis for (int y = minY; y < maxY; y++) { // Calculated value double value = upperLeftTile.getSampleDouble(x, y, b); // Old band value double valueOld = bandRaster.getSampleDouble(x, y, 0); // ROI CHECK boolean contained = true; if (roiUsed) { if (!roi.contains(x, y)) { contained = false; // Comparison if the final value is not inside a ROI assertEquals(value, destNoData, TOLERANCE); } } if (contained) { // If no Data are present, no data check is performed if (noDataUsed) { switch (dataType) { case DataBuffer.TYPE_BYTE: byte sampleB = ImageUtil.clampRoundByte(value); byte sampleBOld = ImageUtil.clampRoundByte(valueOld); if (noData[0].contains(sampleBOld)) { assertEquals(sampleB, destNoData, TOLERANCE); } else { assertEquals(sampleB, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_USHORT: short sampleUS = ImageUtil.clampRoundUShort(value); short sampleUSOld = ImageUtil.clampRoundUShort(valueOld); if (noData[0].contains(sampleUSOld)) { assertEquals(sampleUS, destNoData, TOLERANCE); } else { assertEquals(sampleUS, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_SHORT: short sampleS = ImageUtil.clampRoundShort(value); short sampleSOld = ImageUtil.clampRoundShort(valueOld); if (noData[0].contains(sampleSOld)) { assertEquals(sampleS, destNoData, TOLERANCE); } else { assertEquals(sampleS, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_INT: int sampleI = ImageUtil.clampRoundInt(value); int sampleIOld = ImageUtil.clampRoundInt(valueOld); if (noData[0].contains(sampleIOld)) { assertEquals(sampleI, destNoData, TOLERANCE); } else { assertEquals(sampleI, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_FLOAT: float sampleF = ImageUtil.clampFloat(value); float sampleFOld = ImageUtil.clampFloat(valueOld); if (noData[0].contains(sampleFOld)) { assertEquals(sampleF, destNoData, TOLERANCE); } else { assertEquals(sampleF, valueOld, TOLERANCE); } break; case DataBuffer.TYPE_DOUBLE: if (noData[0].contains(valueOld)) { assertEquals(value, destNoData, TOLERANCE); } else { assertEquals(value, valueOld, TOLERANCE); } break; default: throw new IllegalArgumentException("Wrong data type"); } } else { // Else a simple value comparison is done assertEquals(value, valueOld, TOLERANCE); } } } } } // Disposal of the output image merged.dispose(); }
/** * Quick method for populating the {@link CUDABean} instance provided. * * @param bean * @param reference * @param coverage * @param geo * @param transform * @throws IOException * @throws MismatchedDimensionException * @throws TransformException */ private void populateBean( CUDABean bean, boolean reference, GridCoverage2D coverage, Geometry geo, MathTransform transform, int buffer) throws IOException, MismatchedDimensionException, TransformException { RenderedImage image = coverage.getRenderedImage(); // 0) Check if a buffer must be applied Geometry originalGeo = (Geometry) geo.clone(); if (buffer > 0) { try { if (!"EPSG:4326" .equals(CRS.lookupIdentifier(coverage.getCoordinateReferenceSystem(), false))) { geo = geo.buffer(buffer); } else { geo = geo.buffer(buffer / 111.128); } } catch (FactoryException e) { geo = geo.buffer(buffer); } } // 1) Crop the two coverages with the selected Geometry GridCoverage2D crop = CROP.execute(coverage, geo, null); transform = ProjectiveTransform.create( (AffineTransform) crop.getGridGeometry().getGridToCRS(PixelInCell.CELL_CORNER)) .inverse(); // 2) Extract the BufferedImage from each image image = crop.getRenderedImage(); Rectangle rectIMG = new Rectangle(image.getMinX(), image.getMinY(), image.getWidth(), image.getHeight()); ImageWorker w = new ImageWorker(image); BufferedImage buf = w.getBufferedImage(); if (image instanceof RenderedOp) { ((RenderedOp) image).dispose(); } // 3) Generate an array of data from each image Raster data = buf.getData(); final DataBufferByte db = (DataBufferByte) data.getDataBuffer(); byte[] byteData = db.getData(); if (reference) { // 4) Transform the Geometry to Raster space Geometry rs = JTS.transform(geo, transform); Geometry rsFilter = JTS.transform(geo.difference(originalGeo), transform); ROI roiGeo = new ROIGeometry(rs); ROI roiFilter = new ROIGeometry(rsFilter); // 5) Extract an array of data from the transformed ROI byte[] roiData = getROIData((buffer > 0 ? roiFilter : roiGeo), rectIMG); bean.setRoi(roiData); bean.setRoiObj(roiGeo); // 6) Setting the Coverage data array bean.setReferenceImage(byteData); // 7) Setting the Image dimensions bean.setHeight(rectIMG.height); bean.setWidth(rectIMG.width); bean.setMinX(rectIMG.x); bean.setMinY(rectIMG.y); } else { // 6) Setting the Coverage data array bean.setCurrentImage(byteData); } // 7) Store the Reference Covergae containing the geospatial info bean.setReferenceCoverage(coverage); }
private void testType(RenderedImage src, boolean nodataUsed, boolean roiUsed) { // Optional No Data Range used Range noData; // Source image data type int dataType = src.getSampleModel().getDataType(); // If no Data are present, the No Data Range associated is used if (nodataUsed) { switch (dataType) { case DataBuffer.TYPE_BYTE: noData = noDataByte; break; case DataBuffer.TYPE_USHORT: noData = noDataUShort; break; case DataBuffer.TYPE_SHORT: noData = noDataShort; break; case DataBuffer.TYPE_INT: noData = noDataInt; break; case DataBuffer.TYPE_FLOAT: noData = noDataFloat; break; case DataBuffer.TYPE_DOUBLE: noData = noDataDouble; break; default: throw new IllegalArgumentException("Wrong data type"); } } else { noData = null; } ROI roi; if (roiUsed) { roi = roiObject; } else { roi = null; } // BandCombined result RenderedOp combined = BandCombineDescriptor.create(src, matrix, roi, noData, destinationNoData, null); int tileWidth = combined.getTileWidth(); int tileHeight = combined.getTileHeight(); int minTileX = combined.getMinTileX(); int minTileY = combined.getMinTileY(); int numXTiles = combined.getNumXTiles(); int numYTiles = combined.getNumYTiles(); int maxTileX = minTileX + numXTiles; int maxTileY = minTileY + numYTiles; // Ensure same size assertEquals(combined.getWidth(), src.getWidth()); assertEquals(combined.getHeight(), src.getHeight()); assertEquals(combined.getMinX(), src.getMinX()); assertEquals(combined.getMinY(), src.getMinY()); assertEquals(minTileX, src.getMinTileX()); assertEquals(minTileY, src.getMinTileY()); assertEquals(numXTiles, src.getNumXTiles()); assertEquals(numYTiles, src.getNumYTiles()); assertEquals(tileWidth, src.getTileWidth()); assertEquals(tileHeight, src.getTileHeight()); int srcBands = src.getSampleModel().getNumBands(); int dstBands = combined.getNumBands(); // Ensure a correct band size assertEquals(dstBands, matrix.length); // Check on all the pixels if they have been calculate correctly for (int tileX = minTileX; tileX < maxTileX; tileX++) { for (int tileY = minTileY; tileY < maxTileY; tileY++) { Raster tile = combined.getTile(tileX, tileY); Raster srcTile = src.getTile(tileX, tileY); int minX = tile.getMinX(); int minY = tile.getMinY(); int maxX = minX + tileWidth - 1; int maxY = minY + tileHeight - 1; for (int x = minX; x <= maxX; x++) { for (int y = minY; y <= maxY; y++) { boolean isValidRoi = !roiUsed || (roiUsed && roiObject.contains(x, y)); if (isValidRoi) { for (int b = 0; b < dstBands; b++) { // Getting the result double result = tile.getSampleDouble(x, y, b); // Calculating the expected result from sources boolean valid = false; double calculated = 0; for (int i = 0; i < srcBands; i++) { double sample = srcTile.getSampleDouble(x, y, i); boolean isValidData = !nodataUsed || (nodataUsed && !noDataDouble.contains(sample)); valid |= isValidData; if (isValidData) { switch (dataType) { case DataBuffer.TYPE_BYTE: calculated += ((int) sample & 0xFF) * matrix[b][i]; break; case DataBuffer.TYPE_USHORT: calculated += ((int) sample & 0xFFFF) * matrix[b][i]; break; case DataBuffer.TYPE_SHORT: case DataBuffer.TYPE_INT: case DataBuffer.TYPE_FLOAT: case DataBuffer.TYPE_DOUBLE: calculated += sample * matrix[b][i]; break; default: break; } } } if (valid) { calculated += matrix[b][srcBands]; switch (dataType) { case DataBuffer.TYPE_BYTE: calculated = ImageUtil.clampRoundByte(calculated); result = ImageUtil.clampRoundByte(result); break; case DataBuffer.TYPE_USHORT: calculated = ImageUtil.clampRoundUShort(calculated); result = ImageUtil.clampRoundUShort(result); break; case DataBuffer.TYPE_SHORT: calculated = ImageUtil.clampRoundShort(calculated); result = ImageUtil.clampRoundShort(result); break; case DataBuffer.TYPE_INT: calculated = ImageUtil.clampRoundInt(calculated); result = ImageUtil.clampRoundInt(result); break; case DataBuffer.TYPE_FLOAT: calculated = (float) calculated; calculated = (float) result; break; case DataBuffer.TYPE_DOUBLE: break; default: break; } assertEquals(result, calculated, TOLERANCE); } else { assertEquals(result, destNoData, TOLERANCE); } } } else { for (int b = 0; b < dstBands; b++) { assertEquals(tile.getSampleDouble(x, y, b), destNoData, TOLERANCE); } } } } } } // Disposal of the output image combined.dispose(); }