try { ParameterValue<GridGeometry2D> gg = AbstractGridFormat.READ_GRIDGEOMETRY2D.createValue(); gg.setValue( new GridGeometry2D( new GridEnvelope2D(0, 0, 10, 10), new ReferencedEnvelope(0, 1000, 0, 1000, UTM32N))); GridCoverage2DReader reader = (GridCoverage2DReader) info.getGridCoverageReader(null, null); getCatalog().remove(info); if (coverage != null) { coverage.dispose(true);
final GridEnvelope2D testRange = new GridEnvelope2D(minX, minY, maxX, maxY); CRS.transform(gridToWorldCorner, new GeneralEnvelope(testRange.getBounds())); testEnvelope.setCoordinateReferenceSystem(reader.getCoordinateReferenceSystem()); String maxAllowedTiles = ImageMosaicFormat.MAX_ALLOWED_TILES.getName().toString(); if (parameters.keySet().contains(maxAllowedTiles)) { parameters.put(maxAllowedTiles, 1); String useJaiImageRead = ImageMosaicFormat.USE_JAI_IMAGEREAD.getName().toString(); if (parameters.keySet().contains(useJaiImageRead)) { parameters.put(useJaiImageRead, false); AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString(), new GridGeometry2D(testRange, testEnvelope)); if (gc != null) { parameters.remove(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString()); sampleDimensions = gc.getSampleDimensions(); gc.dispose(true); if (gc.getRenderedImage() instanceof PlanarImage) { ImageUtilities.disposePlanarImageChain((PlanarImage) gc.getRenderedImage());
GridEnvelope2D range = requestedGridGeometry.getGridRange2D(); GridEnvelope2D expandedRange = new GridEnvelope2D( (int) range.getMinX() - HETEROGENEOUS_RASTER_GUTTER, (int) range.getMinY() - HETEROGENEOUS_RASTER_GUTTER, (int) range.getWidth() + HETEROGENEOUS_RASTER_GUTTER * 2, (int) range.getHeight() + HETEROGENEOUS_RASTER_GUTTER * 2); GridGeometry2D expandedGG = new GridGeometry2D( value.setValue(expandedGG); for (int i = 0; i < parameters.length; i++) { final ParameterValue param = (ParameterValue) parameters[i]; if (AbstractGridFormat.BANDS.getName().equals(param.getDescriptor().getName())) { width = (float) range.getWidth(); height = (float) range.getHeight(); } else { GridCoverage2D reference = inputCoverages.values().stream().filter(c -> c != null).findFirst().get(); RenderedImage ri = reference.getRenderedImage(); width = ri.getWidth(); height = ri.getHeight(); + coverageName + ", result has envelope " + coverage.getEnvelope2D());
final int hrWidth = Integer.parseInt(attributes.getNamedItem("nColumns").getNodeValue()); final int hrHeight = Integer.parseInt(attributes.getNamedItem("nRows").getNodeValue()); originalGridRange = new GridEnvelope2D(new Rectangle(0, 0, hrWidth, hrHeight)); final boolean pixelIsArea = AsciiGridsImageMetadata.RasterSpaceType.valueOf( new GeneralEnvelope( new double[] {xll, yll}, new double[] {xll + (hrWidth * cellsizeX), yll + (hrHeight * cellsizeY)}); originalEnvelope.setCoordinateReferenceSystem(crs);
@Test public void testZoomlevel3() throws IOException { MBTilesReader reader = new MBTilesReader(getClass().getResource("world_lakes.mbtiles"), null); GeneralParameterValue[] parameters = new GeneralParameterValue[1]; GridGeometry2D gg = new GridGeometry2D( new GridEnvelope2D(new Rectangle(500, 500)), new ReferencedEnvelope(0, 90.0, -85.0, 0, MBTilesReader.WGS_84)); parameters[0] = new Parameter<GridGeometry2D>(AbstractGridFormat.READ_GRIDGEOMETRY2D, gg); GridCoverage2D gc = reader.read(parameters); RenderedImage img = gc.getRenderedImage(); assertEquals(0, gc.getEnvelope().getMinimum(0), 0.01); assertEquals(-20037508.34, gc.getEnvelope().getMinimum(1), 0.01); assertEquals(15028131.25, gc.getEnvelope().getMaximum(0), 0.01); assertEquals(0, gc.getEnvelope().getMaximum(1), 0.01); assertEquals(768, img.getWidth()); assertEquals(1024, img.getHeight()); }
@Override public GridEnvelope getOriginalGridRange(String coverageName) { if (!checkName(coverageName)) { throw new IllegalArgumentException( "The specified coverageName " + coverageName + "is not supported"); } List<TileMatrix> matrices = tiles.get(coverageName).getTileMatricies(); TileMatrix matrix = matrices.get(matrices.size() - 1); return new GridEnvelope2D( new Rectangle( matrix.getMatrixWidth() * matrix.getTileWidth(), matrix.getMatrixHeight() * matrix.getTileHeight())); }
GridCoverageUtilities.getReferencedEnvelopeFromGeographicBoundingBox( new GeographicBoundingBoxImpl(coverageEnvelope)); coverageRequestedRasterArea = new Rectangle(); coverageCRS2D = CRS.getHorizontalCRS(coverageCRS); assert coverageCRS2D.getCoordinateSystem().getDimension() == 2; if (coverageCRS.getCoordinateSystem().getDimension() != 2) { final MathTransform transform = CRS.findMathTransform(coverageCRS, (CoordinateReferenceSystem) coverageCRS2D); final GeneralEnvelope bbox = CRS.transform(transform, coverageEnvelope); bbox.setCoordinateReferenceSystem(coverageCRS2D); coverageBBox = new ReferencedEnvelope(bbox); } else { coverageBBox = new ReferencedEnvelope(coverageEnvelope); new GridEnvelope2D(coverageRasterArea), coverageGeographicBBox); approximateCoverageWGS84FullResolution = CoverageUtilities.getResolution(geMapper.createAffineTransform());
public MBTilesReader(Object source, Hints hints) throws IOException { sourceFile = MBTilesFormat.getFileFromSource(source); MBTilesFile file = new MBTilesFile(sourceFile); metadata = file.loadMetaData(); try { bounds = ReferencedEnvelope.create(metadata.getBounds(), WGS_84) .transform(SPHERICAL_MERCATOR, true); } catch (Exception e) { bounds = null; } originalEnvelope = new GeneralEnvelope(bounds == null ? WORLD_ENVELOPE : bounds); long maxZoom; try { maxZoom = file.maxZoom(); } catch (SQLException e) { throw new IOException(e); } long size = Math.round(Math.pow(ZOOM_LEVEL_BASE, maxZoom)) * DEFAULT_TILE_SIZE; highestRes = new double[] {WORLD_ENVELOPE.getSpan(0) / size, WORLD_ENVELOPE.getSpan(1) / size}; originalGridRange = new GridEnvelope2D(new Rectangle((int) size, (int) size)); coverageFactory = CoverageFactoryFinder.getGridCoverageFactory(this.hints); crs = SPHERICAL_MERCATOR; }
(GridCoverage2DReader) GRID_PROPERTY_NAME.evaluate(gridWrapper); if (CRS.equalsIgnoreMetadata( reader.getCoordinateReferenceSystem(), gridGeometry.getCoordinateReferenceSystem())) { && readGG.getGridToCRS2D() instanceof AffineTransform2D) { AffineTransform2D atOriginal = (AffineTransform2D) g2w; AffineTransform2D atMap = (AffineTransform2D) readGG.getGridToCRS2D(); if (XAffineTransform.getScale(atMap) < XAffineTransform.getScale(atOriginal)) { new Rectangle( minx - TRANSFORM_READ_BUFFER_PIXELS, miny - TRANSFORM_READ_BUFFER_PIXELS, (maxx - minx) + TRANSFORM_READ_BUFFER_PIXELS * 2, (maxy - miny) + TRANSFORM_READ_BUFFER_PIXELS * 2); GridEnvelope2D gridEnvelope = new GridEnvelope2D(rect); if (coverage.getEnvelope2D().intersects(renderingEnvelope)) { param.parameter("Source").setValue(coverage); param.parameter("Envelope").setValue(renderingEnvelope); coverage = (GridCoverage2D) PROCESSOR.doOperation(param); } else { param.parameter("Source").setValue(coverage);
private void setGridGeometry( final ReferencedEnvelope envelope, final GranuleCatalog catalog, String typeName) { Utilities.ensureNonNull("index", catalog); // // save the bbox and prepare other info // final BoundingBox bounds = catalog.getBounds(typeName); // we might have an imposed bbox this.crs = bounds.getCoordinateReferenceSystem(); if (envelope == null) this.originalEnvelope = new GeneralEnvelope(bounds); else { this.originalEnvelope = new GeneralEnvelope(envelope); this.originalEnvelope.setCoordinateReferenceSystem(crs); } // original gridrange (estimated). I am using the floor here in order to make sure // we always stays inside the real area that we have for the granule originalGridRange = new GridEnvelope2D( new Rectangle( (int) (originalEnvelope.getSpan(0) / highestRes[0]), (int) (originalEnvelope.getSpan(1) / highestRes[1]))); raster2Model = new AffineTransform2D( highestRes[0], 0, 0, -highestRes[1], originalEnvelope.getLowerCorner().getOrdinate(0) + 0.5 * highestRes[0], originalEnvelope.getUpperCorner().getOrdinate(1) - 0.5 * highestRes[1]); }
final RenderedImage sourceImage = sourceCoverage.getRenderedImage(); final GridGeometry2D sourceGridGeometry = ((GridGeometry2D) sourceCoverage.getGridGeometry()); final GridEnvelope2D sourceGridRange = sourceGridGeometry.getGridRange2D(); org.locationtech.jts.geom.Envelope intersection = cropROIEnvelope.intersection( ReferencedEnvelope.reference(cropEnvelope)); new ReferencedEnvelope( Rectangle.intersect(finalRasterArea, sourceGridRange, finalRasterArea); if (finalRasterArea.isEmpty()) { throw new EmptyIntersectionException( "Crop envelope intersects in model space, but not in raster space"); if (finalRasterArea.equals(sourceGridRange) && isSimpleTransform && cropROI == null) return sourceCoverage; Map sourceProperties = sourceCoverage.getProperties(); Map properties = null; if (sourceProperties != null && !sourceProperties.isEmpty()) { new GridGeometry2D( new GridEnvelope2D(croppedImage.getBounds()), sourceGridGeometry.getGridToCRS2D(PixelOrientation.CENTER),
this.crs = CRS.parseWKT(wkt); final Integer epsgCode = CRS.lookupEpsgCode(this.crs, true); this.crs = CRS.decode("EPSG:" + epsgCode); new GridEnvelope2D( new Rectangle(0, 0, metadata.getWidth(), metadata.getHeight())); CRS.transform( ProjectiveTransform.create(tempTransform), new GeneralEnvelope( ((GridEnvelope2D) this.originalGridRange))); } catch (IllegalStateException e) {
public GridEnvelope getOriginalGridRange() { if (homogeneousCoverages) { return delegate.getOriginalGridRange(referenceName); } // Due to mixed combinations, let's take the envelope and divide the span // by the resolution GeneralEnvelope envelope = getOriginalEnvelope(); double[] res; try { res = getResolutionLevels()[0]; return new GridEnvelope2D( new Rectangle( (int) (envelope.getSpan(0) / res[0]), (int) (envelope.getSpan(1) / res[1]))); } catch (IOException e) { throw new IllegalArgumentException(e); } }
throws Exception { CoordinateReferenceSystem granuleCRS = templateDescriptor.getGranuleEnvelope().getCoordinateReferenceSystem(); if (CRS.equalsIgnoreMetadata(spatialDomainManager.coverageCRS2D, granuleCRS)) { return this; new GridEnvelope2D( new Rectangle( (int) (targetBounds.getSpan(0) / highestRes[0]), (int) (targetBounds.getSpan(1) / highestRes[1]))); AffineTransform2D raster2Model = new AffineTransform2D( 0, -highestRes[1], targetBounds.getLowerCorner().getOrdinate(0) + 0.5 * highestRes[0], targetBounds.getUpperCorner().getOrdinate(1) - 0.5 * highestRes[1]); reprojected.spatialDomainManager = new SpatialDomainManager( new GeneralEnvelope(targetBounds), originalGridRange, granuleCRS,
final CoordinateReferenceSystem sourceCRS = sourceCoverage.getCoordinateReferenceSystem(); if (targetCRS == null) { if (targetGG != null && targetGG.isDefined(GridGeometry2D.CRS_BITMASK)) { return targetCoverage; if (CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) { targetEnvelope.setCoordinateReferenceSystem(targetCRS); targetGR = force2D ? new GridEnvelope2D(sourceGG.getGridRange2D()) if (targetBB.equals(sourceBB)) { sourceCoverage, sourceImage, targetGG, null, null, hints, sourceProps); if ((automaticGR || targetBB.equals(sourceBB)) && allSteps instanceof AffineTransform) { if (automaticGG) { assert targetCoverage.getGridGeometry().getGridRange2D().equals(targetImage.getBounds()) : targetGG; if (CoverageProcessor.LOGGER.isLoggable(LOGGING_LEVEL)) {
for (int i = 0; i < parameters.length; i++) { final ParameterValue param = (ParameterValue) parameters[i]; final ReferenceIdentifier name = param.getDescriptor().getName(); if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName())) { final GridGeometry2D gg = (GridGeometry2D) param.getValue(); try { requestedEnvelope = ReferencedEnvelope.create( gg.getEnvelope(), gg.getCoordinateReferenceSystem()) .transform(SPHERICAL_MERCATOR, true); } catch (Exception e) { requestedEnvelope = null; dim = gg.getGridRange2D().getBounds(); continue; requestedEnvelope.getSpan(0) / WORLD_ENVELOPE.getSpan( 0); // proportion of total width that is being requested double propWidth = dim.getWidth()
final Rectangle actualDim = new Rectangle(0, 0, hrWidth, hrHeight); this.nativeGridRange = new GridEnvelope2D(actualDim); if (this.crs == null) { parsePRJFile(); originalEnvelope.setCoordinateReferenceSystem(crs); originalGridRange = getCoverageGridRange();
continue; final String name = param.getDescriptor().getName().getCode(); if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString())) { final GridGeometry2D gg = (GridGeometry2D) param.getValue(); requestedEnvelope = new GeneralEnvelope((Envelope) gg.getEnvelope2D()); dim = gg.getGridRange2D().getBounds(); continue; if (name.equals(AbstractGridFormat.OVERVIEW_POLICY.getName().toString())) { overviewPolicy = (OverviewPolicy) param.getValue(); continue;
throws TransformException, FactoryException, IOException { GridGeometry2D readingGridGeometry; MathTransform2D crsToGrid2D = gg.getCRSToGrid2D(); MathTransform2D gridToCRS2D = gg.getGridToCRS2D(); if (sameCRS) { Envelope gridEnvelope = JTS.transform(polygon, crsToGrid2D).getEnvelopeInternal(); GridEnvelope2D gridRange = new GridEnvelope2D( (int) gridEnvelope.getMinX(), (int) gridEnvelope.getMinY(), (int) Math.round(gridEnvelope.getWidth()), (int) Math.round(gridEnvelope.getHeight())); readingGridGeometry = new GridGeometry2D(gridRange, gridToCRS2D, readerCRS); } else { ReferencedEnvelope readEnvelope = new ReferencedEnvelope(polygon.getEnvelopeInternal(), readerCRS); reducedEnvelope.transform( requestedGridGeometry.getCoordinateReferenceSystem(), true); ReferencedEnvelope gridEnvelope = ReferencedEnvelope.reference( CRS.transform(crsToGrid2D, reducedEnvelopeInRequestedCRS)); GridEnvelope2D readingGridRange = new GridEnvelope2D( (int) gridEnvelope.getMinX(), (int) gridEnvelope.getMinY(), readEnvelope.getHeight() / Math.abs(readResolution[1])));
ReferencedEnvelope targetEnvelope = ReferencedEnvelope.reference(renderingEnvelope); ReferencedEnvelope coveragesEnvelope = null; for (GridCoverage2D coverage : coverages) { ReferencedEnvelope re = ReferencedEnvelope.reference(coverage.getEnvelope2D()); if (coveragesEnvelope == null) { coveragesEnvelope = re; } else { coveragesEnvelope.expandToInclude(re); new ReferencedEnvelope( targetEnvelope.intersection(coveragesEnvelope), renderingEnvelope.getCoordinateReferenceSystem()); if (targetEnvelope.isEmpty() || targetEnvelope.isNull()) { return null; MathTransform2D mt = coverages.get(0).getGridGeometry().getCRSToGrid2D(); Rectangle rasterSpaceEnvelope; rasterSpaceEnvelope = CRS.transform(mt, targetEnvelope).toRectangle2D().getBounds(); GridEnvelope2D gridRange = new GridEnvelope2D(rasterSpaceEnvelope); GridGeometry2D gridGeometry = new GridGeometry2D(gridRange, targetEnvelope); param.parameter("sources").setValue(coverages); param.parameter("geometry").setValue(gridGeometry); param.parameter(Mosaic.OUTNODATA_NAME).setValue(background);