public GridCoverage2D getGridCoverage2D(BufferedImage image) { GridCoverage2D gridCoverage = new GridCoverageFactory() .create("isochrone", image, gg.getEnvelope2D()); return gridCoverage; }
/** * Computes the number of pixels for this {@link GridEnvelope2D}. * * @param rasterEnvelope the {@link GridEnvelope2D} to compute the number of pixels for * @return the number of pixels for the provided {@link GridEnvelope2D} */ private static long computePixelsNumber(GridEnvelope2D rasterEnvelope) { // pixels long pixelsNumber = 1; final int dimensions = rasterEnvelope.getDimension(); for (int i = 0; i < dimensions; i++) { pixelsNumber *= rasterEnvelope.getSpan(i); } return pixelsNumber; }
Tile(TileRequest req) { GridEnvelope2D gridEnv = new GridEnvelope2D(0, 0, req.width, req.height); this.gg = new GridGeometry2D(gridEnv, (org.opengis.geometry.Envelope)(req.bbox)); // TODO: check that gg intersects graph area LOG.debug("preparing tile for {}", gg.getEnvelope2D()); // Envelope2D worldEnv = gg.getEnvelope2D(); this.width = gridEnv.width; this.height = gridEnv.height; }
/** * The BandMerge operation takes indexed images and expands them, however in the context of * coverage view band merging we don't normally want that, e.g., raster mask bands are * represented as indexed but we really want to keep them in their binary, single band form. To * do so, the IndexColorModel is replaced by a ComponentColorModel * * @param coverage * @return */ private GridCoverage2D prepareForBandMerge(GridCoverage2D coverage) { RenderedImage ri = coverage.getRenderedImage(); SampleModel sampleModel = ri.getSampleModel(); if (sampleModel.getNumBands() == 1 && ri.getColorModel() instanceof IndexColorModel) { ImageWorker worker = new ImageWorker(ri); worker.removeIndexColorModel(); RenderedImage formatted = worker.getRenderedImage(); return new GridCoverageFactory() .create( coverage.getName(), formatted, coverage.getGridGeometry(), coverage.getSampleDimensions(), new GridCoverage[] {coverage}, coverage.getProperties()); } return coverage; }
throws ServiceException, IOException { PrintStream ps = new PrintStream(output); ps.println("Grid bounds: " + coverage.getEnvelope()); ps.println("Grid CRS: " + coverage.getCoordinateReferenceSystem()); ps.println("Grid range: " + coverage.getGridGeometry().getGridRange()); ps.println("Grid to world: " + coverage.getGridGeometry().getGridToCRS()); ps.println("Contents:"); RenderedImage ri = coverage.getRenderedImage(); Raster raster = ri.getData(); for (int band = 0; band < raster.getNumBands(); band++) { coverage.dispose(false);
@Override public void createIndividuals() { LOG.info("Loading population from raster file {}", sourceFilename); try { File rasterFile = new File(sourceFilename); // determine file format and CRS, then load raster AbstractGridFormat format = GridFormatFinder.findFormat(rasterFile); AbstractGridCoverage2DReader reader = format.getReader(rasterFile); GridCoverage2D coverage = reader.read(null); this.coverageCRS = coverage.getCoordinateReferenceSystem(); GridGeometry2D gridGeometry = coverage.getGridGeometry(); GridEnvelope2D gridEnvelope = gridGeometry.getGridRange2D(); gridGeometry.getGridToCRS(); // because we may want to produce an empty raster rather than loading one, alongside the coverage we // store the row/col dimensions and the referenced envelope in the original coordinate reference system. this.cols = gridEnvelope.width; this.rows = gridEnvelope.height; this.createIndividuals0(); } catch (Exception ex) { throw new IllegalStateException("Error loading population from raster file: ", ex); } LOG.info("Done loading raster from file."); }
coverage.getGridGeometry().getGridRange2D(), coverage.getRenderedImage().getSampleModel()); if (actual > limit) { throw new WcsException(
private GeoTiffWriteParams buildWriteParams(GridCoverage2D coverage) { final RenderedImage renderedImage = coverage.getRenderedImage(); int tileWidth = renderedImage.getTileWidth(); int tileHeight = renderedImage.getTileHeight(); // avoid tiles bigger than the image final GridEnvelope gr = coverage.getGridGeometry().getGridRange(); if (gr.getSpan(0) < tileWidth) { tileWidth = gr.getSpan(0); } if (gr.getSpan(1) < tileHeight) { tileHeight = gr.getSpan(1); } GeoTiffWriteParams writeParams = new GeoTiffWriteParams(); writeParams.setTilingMode(GeoToolsWriteParams.MODE_EXPLICIT); writeParams.setTiling(tileWidth, tileHeight); return writeParams; }
/** * Test GridCoverage unwrapping * * @throws IOException */ @Test public void testGridCoverageUnwrapping() throws IOException { GridCoverageFactory gcFactory = new GridCoverageFactory(); RenderedImage image = new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY); GridCoverage2D original = gcFactory.create( "original", image, new GeneralEnvelope(new Rectangle2D.Double(0, 0, 64, 64))); GridSampleDimension[] gsd = new GridSampleDimension[] {new GridSampleDimension("wrappedSampleDimension")}; GridCoverageWrapper wrapper = new GridCoverageWrapper("wrapped", original, gsd, null); assertNotSame(original.getSampleDimensions(), wrapper.getSampleDimensions()); assertNotSame(wrapper, original); assertSame(original, wrapper.unwrap(original.getClass())); } }
@Override public void createIndividuals() { try { coverageCRS = CRS.decode(crsCode, true); } catch (Exception e) { LOG.error("error decoding coordinate reference system code.", e); return; } if (boundsFromGraph) { // autowire graph service or pass in } gridEnvelope = new GridEnvelope2D(0, 0, cols, rows); refEnvelope = new ReferencedEnvelope(left, right, bottom, top, coverageCRS); gridGeometry = new GridGeometry2D(gridEnvelope, refEnvelope); super.createIndividuals0(); }
boolean visit(GridCoverage2D coverage) throws IOException { MathTransform2D mt = coverage.getGridGeometry().getGridToCRS2D(); // cannot do a comparison if (!(mt instanceof AffineTransform2D)) { return false; } AffineTransform2D at = (AffineTransform2D) mt; double scaleX = Math.abs(at.getScaleX()); double scaleY = Math.abs(at.getScaleY()); if (resolution == null) { this.resolution = new double[2]; this.resolution[0] = scaleX; this.resolution[1] = scaleY; return true; } if (compare(scaleX, scaleY, resolution)) { this.resolution[0] = scaleX; this.resolution[1] = scaleY; return true; } else { return false; } }
/** * Returns true if the coverage has not been processed in any way since it has been read * * @param coverage */ private boolean isUnprocessed(GridCoverage2D coverage) { RenderedImage ri = coverage.getRenderedImage(); if (ri instanceof RenderedOp) { RenderedOp op = (RenderedOp) ri; return op.getOperationName().startsWith("ImageRead"); } else if (ri instanceof OpImage) { return ri.getClass().getSimpleName().startsWith("ImageRead"); } else { return true; } } }
public static GridCoverage2D wrapCoverage( GridCoverage2D coverage, GridCoverage2D sourceCoverage, GridSampleDimension[] wrappedDimensions, Map properties, boolean forceWrapping) { if (coverage instanceof GridCoverageWrapper || forceWrapping) { return new GridCoverageWrapper( coverage.getName().toString(), coverage, wrappedDimensions == null ? coverage.getSampleDimensions() : wrappedDimensions, properties == null ? sourceCoverage.getProperties() : properties); } return coverage; }
/** * Cleans up a coverage and its internal rendered image * * @param coverage */ public static void disposeCoverage(GridCoverage coverage) { RenderedImage ri = coverage.getRenderedImage(); if (coverage instanceof GridCoverage2D) { ((GridCoverage2D) coverage).dispose(true); } if (ri instanceof PlanarImage) { ImageUtilities.disposePlanarImageChain((PlanarImage) ri); } }
GridCoordinates2D coord = new GridCoordinates2D(); try { DirectPosition sourcePos = gridGeometry.gridToWorld(coord); coverage.evaluate(coord, val);
final long pixelsNumber = computePixelsNumber(gc.getGridGeometry().getGridRange2D()); final RenderedImage image = gc.getRenderedImage(); final SampleModel sm = image.getSampleModel(); for (int band : indexes) {
private void assertCoverageResolution(GridCoverage2D coverage, double resX, double resY) { AffineTransform2D mt = (AffineTransform2D) coverage.getGridGeometry().getGridToCRS2D(); assertEquals(resX, mt.getScaleX(), 1); assertEquals(resY, Math.abs(mt.getScaleY()), 1); }
private int countBands(List<GridCoverage2D> coverages) { int count = 0; for (GridCoverage2D coverage : coverages) { count += coverage.getRenderedImage().getSampleModel().getNumBands(); } return count; }
private void disposeCoverage(GridCoverage coverage) { RenderedImage ri = coverage.getRenderedImage(); if (coverage instanceof GridCoverage2D) { ((GridCoverage2D) coverage).dispose(true); } if (ri instanceof PlanarImage) { ImageUtilities.disposePlanarImageChain((PlanarImage) ri); } }
private int getAlphaBandIndex(GridCoverage2D coverage) { final ColorModel cm = coverage.getRenderedImage().getColorModel(); if (!cm.hasAlpha() || cm.getNumComponents() == cm.getNumColorComponents()) { throw new IllegalArgumentException( "The source coverage does not have an alpha band, cannot extract an " + "alpha band"); } // the alpha band is always the last (see ComponentColorModel.getAlphaRaster or the // getAlpha(object) code if (cm.getNumColorComponents() == 1) { // gray-alpha return 1; } else { // rgba/argb return 3; } }