final ParameterValueGroup readParams = format.getReadParameters(); final Map parameters = CoverageUtils.getParametersKVP(readParams); final int minX = originalRange.getLow(0); final int minY = originalRange.getLow(1); final int width = originalRange.getSpan(0); final int height = originalRange.getSpan(1); final int maxX = minX + (width <= 5 ? width : 5); final GridEnvelope2D testRange = new GridEnvelope2D(minX, minY, maxX, maxY); CRS.transform(gridToWorldCorner, new GeneralEnvelope(testRange.getBounds())); testEnvelope.setCoordinateReferenceSystem(reader.getCoordinateReferenceSystem()); new GridGeometry2D(testRange, testEnvelope)); sampleDimensions = gc.getSampleDimensions(); gc.dispose(true); if (gc.getRenderedImage() instanceof PlanarImage) { ImageUtilities.disposePlanarImageChain((PlanarImage) gc.getRenderedImage());
/** Converts a {@link GeneralEnvelope} into a {@link ReferencedEnvelope} */ ReferencedEnvelope reference(GeneralEnvelope ge) { return new ReferencedEnvelope( ge.getMinimum(0), ge.getMaximum(0), ge.getMinimum(1), ge.getMaximum(1), ge.getCoordinateReferenceSystem()); }
writer.write( "<pos>" + wgs84envelope.getMinimum(0) + " " + wgs84envelope.getMinimum(1) + "</pos>\n"); writer.write( "<pos>" + wgs84envelope.getMaximum(0) + " " + wgs84envelope.getMaximum(1) + "</pos>\n"); writer.write("</envelope>\n"); double[] minCP = envelope.getLowerCorner().getCoordinate(); double[] maxCP = new double[] { minCP[0] + (envelope.getSpan(0) / 20.0), minCP[1] + (envelope.getSpan(1) / 20.0) }; final GeneralEnvelope subEnvelope = new GeneralEnvelope(minCP, maxCP); subEnvelope.setCoordinateReferenceSystem(reader.getCoordinateReferenceSystem()); new GridGeometry2D(reader.getOriginalGridRange(), subEnvelope)); GridCoverage2D gc = (GridCoverage2D)
final CoordinateReferenceSystem sourceCRS = envelope.getCoordinateReferenceSystem(); if (CRS.equalsIgnoreMetadata(sourceCRS, DefaultGeographicCRS.WGS84)) { return new GeneralEnvelope(envelope); if (!CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) { targetEnvelope = CRS.transform(envelope, targetCRS); } else { targetEnvelope = new GeneralEnvelope(envelope); targetEnvelope.setCoordinateReferenceSystem(targetCRS);
GridGeometry2D gg = coverage.getGridGeometry(); GeneralEnvelope padRange = CRS.transform(gg.getCRSToGrid2D(PixelOrientation.UPPER_LEFT), bounds); GridEnvelope2D targetRange = new GridEnvelope2D( (int) Math.round(padRange.getMinimum(0)), (int) Math.round(padRange.getMinimum(1)), (int) Math.round(padRange.getSpan(0)), (int) Math.round(padRange.getSpan(1))); GridEnvelope2D sourceRange = gg.getGridRange2D(); if (sourceRange.x == targetRange.x && sourceRange.y == targetRange.y new GridGeometry2D( targetRange, gg.getGridToCRS(), gg.getCoordinateReferenceSystem2D());
envelope = new GeneralEnvelope(coverageBounds); } else { envelope = new GeneralEnvelope(env); final CoordinateReferenceSystem sourceCRS = envelope.getCoordinateReferenceSystem(); CoordinateReferenceSystem destCRS; try { if (!CRS.equalsIgnoreMetadata(sourceCRS, destCRS)) { try { envelope = CRS.transform(envelope, destCRS); } catch (TransformException e) { throw (IOException) envelope.intersect(coverageBounds); if (envelope.isEmpty()) { return null; envelope.setCoordinateReferenceSystem(destCRS);
final GridEnvelope gridRange = targetCoverage.getGridGeometry().getGridRange(); new GeneralEnvelope( new double[] {targetCoverage.getEnvelope().getMinimum(0), -43.5}, new double[] {targetCoverage.getEnvelope().getMaximum(0), -43.0}); expectedEnvelope.setCoordinateReferenceSystem(CRS.decode("EPSG:4326", true)); expectedEnvelope, scale, (GeneralEnvelope) targetCoverage.getEnvelope(), scale); assertTrue( CRS.equalsIgnoreMetadata( targetCoverage.getCoordinateReferenceSystem(), expectedEnvelope.getCoordinateReferenceSystem())); assertEquals(gridRange.getSpan(0), 360); assertEquals(gridRange.getSpan(1), 120);
final CoordinateReferenceSystem sourceCRS = sourceCoverage.getCoordinateReferenceSystem(); if (targetCRS == null) { if (targetGG != null && targetGG.isDefined(GridGeometry2D.CRS_BITMASK)) { targetCRS = targetGG.getCoordinateReferenceSystem(); } else { if (targetGG != null && targetGG.isDefined(GridGeometry2D.CRS_BITMASK)) { final GridGeometry2D sourceGG = sourceCoverage.getGridGeometry(); final MathTransform gridToCRS; switch (envelope.getDimension()) { return targetCoverage; if (CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) { step2 = IdentityTransform.create(step1.getTargetDimensions()); step3 = step1.inverse(); targetEnvelope.setCoordinateReferenceSystem(targetCRS); if (!(new GeneralEnvelope(source).contains(target, true))) { if (interpolation != null && !(interpolation instanceof InterpolationNearest)) {
private void inspectCoordinateReferenceSystems() throws DataSourceException { requestCRS = CRS.getHorizontalCRS(requestedBBox.getCoordinateReferenceSystem()); if (!CRS.equalsIgnoreMetadata(requestCRS, rasterManager.spatialDomainManager.coverageCRS2D)) try { destinationToSourceTransform = CRS.findMathTransform( requestCRS, rasterManager.spatialDomainManager.coverageCRS2D, true); } catch (FactoryException e) { if (destinationToSourceTransform != null && destinationToSourceTransform.isIdentity()) PixelInCell.CELL_CORNER); requestedBBox = new ReferencedEnvelope( CRS.transform( tempTransform, new GeneralEnvelope(requestedRasterArea)));
CoordinateReferenceSystem crs = CRS.decode(srs); wli.setSRS(srs); wli.setNativeCRS(crs); if (envelope != null) { ReferencedEnvelope re = new ReferencedEnvelope( envelope.getMinimum(0), envelope.getMaximum(0), envelope.getMinimum(1), envelope.getMaximum(1), wli.getNativeCRS()); wli.setNativeBoundingBox(re); if (llbbox != null) { ReferencedEnvelope re = new ReferencedEnvelope( llbbox.getMinX(), llbbox.getMaxX(), try { wli.setLatLonBoundingBox( wli.getNativeBoundingBox().transform(DefaultGeographicCRS.WGS84, true)); } catch (Exception e) { LOGGER.log(Level.INFO, "Could not transform native bbox into a lat/lon one", e);
(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)) { org.geotools.referencing.CRS.transform( atOriginal.inverse(), worldEnvelope); int minx = (int) Math.floor(transformed.getMinimum(0)); int miny = (int) Math.floor(transformed.getMinimum(1)); int maxx = (int) Math.ceil(transformed.getMaximum(0)); int maxy = (int) Math.ceil(transformed.getMaximum(1)); Rectangle rect = new Rectangle( (maxx - minx) + TRANSFORM_READ_BUFFER_PIXELS * 2, (maxy - miny) + TRANSFORM_READ_BUFFER_PIXELS * 2); GridEnvelope2D gridEnvelope = new GridEnvelope2D(rect); if (coverage.getEnvelope2D().intersects(renderingEnvelope)) {
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);
cropEnvelope = (GeneralEnvelope) envelope; } else if (envelope instanceof Envelope) { cropEnvelope = new GeneralEnvelope((Envelope) envelope); Envelope e2d = JTS.getEnvelope2D( cropRoi.getEnvelopeInternal(), source.getCoordinateReferenceSystem()); cropEnvelope = new GeneralEnvelope(e2d); final Envelope2D sourceEnvelope = source.getEnvelope2D(); destinationCRS = source.getCoordinateReferenceSystem2D(); ge.setCoordinateReferenceSystem(destinationCRS); destinationEnvelope = ge; new GeneralEnvelope((Envelope) destinationEnvelope); intersectionEnvelope.setCoordinateReferenceSystem(source.getCoordinateReferenceSystem()); intersectionEnvelope.intersect(sourceEnvelope); if (intersectionEnvelope.isEmpty()) { throw new EmptyIntersectionException("Crop envelope does not intersect in model space"); .getGridToCRS(PixelInCell.CELL_CORNER); || !intersectionEnvelope.equals(sourceEnvelope, tolerance / 2.0, false)) { cropEnvelope = intersectionEnvelope.clone(); return buildResult( internalROI,
"test", new float[200][100], new ReferencedEnvelope( -180, 180, -90, 90, DefaultGeographicCRS.WGS84)); GridCoverage2DReader reader = new GeneralEnvelope((BoundingBox) coverage.getEnvelope2D()); this.originalGridRange = coverage.getGridGeometry().getGridRange(); CoordinateReferenceSystem crs = CRS.decode("EPSG:3031", true); ReferencedEnvelope mapExtent = new ReferencedEnvelope(-20000000, 20000000, -20000000, 20000000, crs);
@Test public void testCoverageTrimmingBordersOverlap() throws Exception { final File xml = new File( "./src/test/resources/trimming/requestGetCoverageTrimmingBordersOverlap.xml"); testCoverageResult( xml, targetCoverage -> { final GeneralEnvelope expectedEnvelope = new GeneralEnvelope(new double[] {7, 40}, new double[] {11, 43}); expectedEnvelope.setCoordinateReferenceSystem(CRS.decode("EPSG:4326", true)); double pixelSize = 0.057934032977228; // check the whole extent has been returned assertTrue( expectedEnvelope.equals( targetCoverage.getEnvelope(), pixelSize, false)); }); }
if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString())) { final GridGeometry2D gg = (GridGeometry2D) param.getValue(); reqEnvelope = new GeneralEnvelope((Envelope) gg.getEnvelope2D()); coverageEnvelope.getCoordinateReferenceSystem(); CoordinateReferenceSystem requestCrs = reqEnvelope.getCoordinateReferenceSystem(); if (!CRS.equalsIgnoreMetadata(nativeCrs, requestCrs)) { LOGGER.fine( "Request CRS and native CRS differ, " ReferencedEnvelope nativeCrsEnv; nativeCrsEnv = toNativeCrs(reqEnvelope, nativeCrs); reqEnvelope = new GeneralEnvelope(nativeCrsEnv); dim = gg.getGridRange2D(); continue; int xmin = (int) Math.floor(adjustedGRange.getMinimum(0)); int ymin = (int) Math.floor(adjustedGRange.getMinimum(1)); int xmax = (int) Math.ceil(adjustedGRange.getMaximum(0)); int ymax = (int) Math.ceil(adjustedGRange.getMaximum(1)); dim = new GridEnvelope2D(xmin, ymin, xmax - xmin, ymax - ymin); if (!reqEnvelope.intersects(getOriginalEnvelope(), true)) { throw new IllegalArgumentException( "The requested extend does not overlap the coverage extent: "
ImageUtilities.getReferencedEnvelopeFromGeographicBoundingBox( new GeographicBoundingBoxImpl(coverageEnvelope)); coverageGeographicCRS2D = coverageGeographicBBox.getCoordinateReferenceSystem(); 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);
static GeneralEnvelope toGeneralEnvelope(ReferencedEnvelope e) { GeneralEnvelope ge = new GeneralEnvelope( new double[] {e.getMinX(), e.getMinY()}, new double[] {e.getMaxX(), e.getMaxY()}); ge.setCoordinateReferenceSystem(e.getCoordinateReferenceSystem()); return ge; }
new AffineTransform( (AffineTransform) ((GridGeometry2D) dataCoverage.getGridGeometry()) .getGridToCRS2D(PixelOrientation.UPPER_LEFT)); final MathTransform w2gTransform; try { new ReferencedEnvelope(dataCoverage.getEnvelope2D()); ReferencedEnvelope geometryEnvelope = new ReferencedEnvelope( geometry.getEnvelopeInternal(), dataCoverage.getCoordinateReferenceSystem()); if (!coverageEnvelope.intersects((Envelope) geometryEnvelope)) { param.parameter("Envelope").setValue(new GeneralEnvelope(geometryEnvelope)); cropped = (GridCoverage2D) PROCESSOR.doOperation(param);
if ((paramValues.get(index) != null) && (((String) paramValues.get(index)).length() > 0)) { value = CRS.parseWKT((String) paramValues.get(index)); value = CRS.decode("EPSG:4326"); new GeneralEnvelope( new double[] {coords[0], coords[1]}, new double[] {coords[2], coords[3]});