this.gridRange.getLow(0), this.gridRange.getLow(1), this.gridRange.getSpan(0), this.gridRange.getSpan(1)); final Rectangle thatRectangle = new Rectangle( gridRange.getLow(0), gridRange.getLow(1), gridRange.getSpan(0), gridRange.getSpan(1)); if (!thisRectangle.equals(thatRectangle)) { if (!canSupportHeterogeneousCoverages) { if (!CRS.equalsIgnoreMetadata(crs, this.crs)) { try { destinationToSourceTransform = CRS.findMathTransform(crs, this.crs, true); } catch (FactoryException e) { throw new DataSourceException("Unable to inspect request CRS", e);
GeneralEnvelope envelope = reader.getOriginalEnvelope(); GeneralEnvelope wgs84envelope = CoverageStoreUtils.getWGS84LonLatEnvelope(envelope); final String nativeCrsName = CRS.lookupIdentifier(crs, false); writer.write( "<envelope crs=\"" new GridGeometry2D(reader.getOriginalGridRange(), subEnvelope)); GridCoverage2D gc = (GridCoverage2D) final GridGeometry geometry = gc.getGridGeometry(); final int dimensions = geometry.getGridRange().getDimension(); String lower = ""; String upper = ""; for (int i = 0; i < dimensions; i++) { lower = lower + geometry.getGridRange().getLow(i) + " "; upper = upper + geometry.getGridRange().getHigh(i) + " "; final GridSampleDimension[] sd = gc.getSampleDimensions(); for (int i = 0; i < sd.length; i++) { writer.write("<CoverageDimension>\n");
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 int maxY = minY + (height <= 5 ? height : 5); 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());
MathTransform tx = g.getGridToCRS(); writer.addAttribute("dimension", String.valueOf(g.getGridRange().getDimension())); for (int r = 0; r < g.getGridRange().getDimension(); r++) { low.append(g.getGridRange().getLow(r)).append(" "); high.append(g.getGridRange().getHigh(r) + 1).append(" ");
@Test public void reprojectTo3857XML() throws Exception { final File xml = new File("./src/test/resources/crs/requestGetCoverageOutputCRS.xml"); final String request = FileUtils.readFileToString(xml); MockHttpServletResponse response = postAsServletResponse("wcs", request); assertEquals("image/tiff", response.getContentType()); byte[] tiffContents = getBinary(response); File file = File.createTempFile("bm_gtiff", "bm_gtiff.tiff", new File("./target")); FileUtils.writeByteArrayToFile(file, tiffContents); GeoTiffReader readerTarget = new GeoTiffReader(file); GridCoverage2D targetCoverage = null; try { targetCoverage = readerTarget.read(null); final CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:3857", true); Assert.assertTrue( CRS.equalsIgnoreMetadata( targetCoverage.getCoordinateReferenceSystem(), targetCRS)); final GridEnvelope gridRange = targetCoverage.getGridGeometry().getGridRange(); expectedEnvelope, scale, (GeneralEnvelope) targetCoverage.getEnvelope(), scale); assertEquals(gridRange.getSpan(0), 360); assertEquals(gridRange.getSpan(1), 360); readerTarget.dispose(); } catch (Exception e) {
@Test public void testScaleToExtentXML() throws Exception { final File xml = new File("./src/test/resources/requestGetCoverageScaleToExtent.xml"); final String request = FileUtils.readFileToString(xml); MockHttpServletResponse response = postAsServletResponse("wcs", request); assertEquals("image/tiff", response.getContentType()); byte[] tiffContents = getBinary(response); File file = File.createTempFile("bm_gtiff", "bm_gtiff.tiff", new File("./target")); FileUtils.writeByteArrayToFile(file, tiffContents); // check the tiff structure is the one requested final GeoTiffReader reader = new GeoTiffReader(file); assertTrue( CRS.equalsIgnoreMetadata( reader.getCoordinateReferenceSystem(), CRS.decode("EPSG:4326", true))); assertEquals(200, reader.getOriginalGridRange().getSpan(0)); assertEquals(300, reader.getOriginalGridRange().getSpan(1)); final GridCoverage2D coverage = reader.read(null); assertNotNull(coverage); assertEnvelopeEquals(sourceCoverage, coverage); reader.dispose(); scheduleForCleaning(coverage); }
final CoordinateReferenceSystem sourceCRS = sourceCoverage.getCoordinateReferenceSystem(); if (targetCRS == null) { if (targetGG != null && targetGG.isDefined(GridGeometry2D.CRS_BITMASK)) { targetCRS = targetGG.getCoordinateReferenceSystem(); } else { if (targetGG.isDefined(GridGeometry2D.ENVELOPE_BITMASK)) { final Envelope envelope = targetGG.getEnvelope(); final GridGeometry2D sourceGG = sourceCoverage.getGridGeometry(); final MathTransform gridToCRS; switch (envelope.getDimension()) { return targetCoverage; final GridGeometry2D sourceGG = sourceCoverage.getGridGeometry(); final CoordinateReferenceSystem compatibleSourceCRS = compatibleSourceCRS( if (CRS.equalsIgnoreMetadata(sourceCRS, targetCRS)) { final GridEnvelope targetGR = targetGG.getGridRange(); final int[] lower = targetGR.getLow().getCoordinateValues(); final int[] upper = targetGR.getHigh().getCoordinateValues(); for (int i = 0; i < upper.length; i++) { upper[i]++; // Make them exclusive.
CoordinateReferenceSystem crsA = coverageA.getCoordinateReferenceSystem(); CoordinateReferenceSystem crsB = coverageB.getCoordinateReferenceSystem(); if (!CRS.equalsIgnoreMetadata(crsA, crsB)) { MathTransform mathTransform = null; try { mathTransform = CRS.findMathTransform(crsA, crsB); } catch (FactoryException e) { throw new ProcessException( Envelope envA = coverageA.getEnvelope(); Envelope envB = coverageB.getEnvelope(); if (!envA.equals(envB)) { GridEnvelope gridRangeA = coverageA.getGridGeometry().getGridRange(); GridEnvelope gridRangeB = coverageA.getGridGeometry().getGridRange(); if (gridRangeA.getSpan(0) != gridRangeB.getSpan(0) || gridRangeA.getSpan(1) != gridRangeB.getSpan(1)) { throw new ProcessException(MISMATCHING_GRID_MESSAGE);
if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName())) { final GridGeometry2D gg = (GridGeometry2D) ((ParameterValue) param).getValue(); requestedEnvelope = gg.getEnvelope(); width = gg.getGridRange().getHigh(0) + 1; height = gg.getGridRange().getHigh(1) + 1; } else if (name.equals(AbstractGridFormat.BACKGROUND_COLOR.getName())) { backgroundColor = (Color) ((ParameterValue) param).getValue(); && grid.getGridGeometry().getGridRange2D().getWidth() == width && grid.getGridGeometry().getGridRange2D().getHeight() == height && grid.getEnvelope().equals(requestedEnvelope)) return grid;
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, " dim = gg.getGridRange2D(); continue; MathTransform gridToWorld = getOriginalGridToWorld(PixelInCell.CELL_CENTER); MathTransform worldToGrid = gridToWorld.inverse(); adjustedGRange = CRS.transform(worldToGrid, reqEnvelope); } catch (Exception e) { throw new RuntimeException(e); if (dim.getSpan(0) <= 0 || dim.getSpan(1) <= 0) { throw new IllegalArgumentException( "The requested coverage dimension can't be null: " + dim);
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; }
final GeneralGridEnvelope expectedGridEnvelope = new GeneralGridEnvelope(CRS.transform(cornerWorldToGrid.inverse(), newEnvelope),PixelInCell.CELL_CORNER,false); final StringBuilder envelopeBuilder= new StringBuilder(); envelopeBuilder.append(newEnvelope.getMinimum(0)).append(","); final GridCoverage2D result=(GridCoverage2D) coverages[0]; assertTrue(coverages.length==1); final AffineTransform2D tx = (AffineTransform2D) result.getGridGeometry().getGridToCRS(); assertEquals("resx",expectedTx.getScaleX(),tx.getScaleX(),1E-6); assertEquals("resx",Math.abs(expectedTx.getScaleY()),Math.abs(tx.getScaleY()),1E-6); final GridEnvelope gridEnvelope = result.getGridGeometry().getGridRange(); assertEquals("w",180,gridEnvelope.getSpan(0)); assertEquals("h",180,gridEnvelope.getSpan(1)); assertEquals("grid envelope",expectedGridEnvelope, gridEnvelope); ((GridCoverage2D)coverages[0]).dispose(true);
/** * Casts the specified grid range into an envelope. This is used before to transform the * envelope using {@link CRSUtilities#transform(MathTransform, Envelope)}. */ private static Envelope toEnvelope(final GridEnvelope gridRange) { final int dimension = gridRange.getDimension(); final double[] lower = new double[dimension]; final double[] upper = new double[dimension]; for (int i = 0; i < dimension; i++) { lower[i] = gridRange.getLow(i); upper[i] = gridRange.getHigh(i) + 1; } return new GeneralEnvelope(lower, upper); }
private static GridEnvelope getTiledImageGridRange( Dimension tileSize, GridEnvelope matchingTiles) { int tiledImageMinX = (matchingTiles.getLow(0) * tileSize.width); int tiledImageMinY = (matchingTiles.getLow(1) * tileSize.height); int tiledWidth = (matchingTiles.getSpan(0) * tileSize.width); int tiledHeight = (matchingTiles.getSpan(1) * tileSize.height); GridEnvelope2D tiledImageGridRange; tiledImageGridRange = new GridEnvelope2D(tiledImageMinX, tiledImageMinY, tiledWidth, tiledHeight); return tiledImageGridRange; }
private GeneralEnvelope getResultEnvelope( final List<RasterQueryInfo> queryInfos, final GridEnvelope mosaicGeometry) { // use the same queryInfo used by setMosaicLocations final RasterQueryInfo baseQueryInfo = RasterUtils.findLowestResolution(queryInfos); GeneralEnvelope finalEnvelope = null; int rasterIndex = baseQueryInfo.getRasterIndex(); int pyramidLevel = baseQueryInfo.getPyramidLevel(); MathTransform rasterToModel = rasterInfo.getRasterToModel(rasterIndex, pyramidLevel); CoordinateReferenceSystem coverageCrs = rasterInfo.getCoverageCrs(); GeneralEnvelope mosaicGeometryEnv = new GeneralEnvelope(coverageCrs); mosaicGeometryEnv.setEnvelope( mosaicGeometry.getLow(0), mosaicGeometry.getLow(1), 1 + mosaicGeometry.getHigh(0), 1 + mosaicGeometry.getHigh(1)); try { finalEnvelope = CRS.transform(rasterToModel, mosaicGeometryEnv); finalEnvelope.setCoordinateReferenceSystem(coverageCrs); } catch (TransformException e) { throw new RuntimeException(e); } return finalEnvelope; }
final GridEnvelope range = grid.getGridRange(); final int dimension = range.getDimension(); for (int i = 0; i < dimension; i++) { final int min, length; label = "\"Y\""; } else { min = range.getLow(i); length = Math.min(Math.max(range.getHigh(i) + 1, 0), 1); label = Integer.valueOf(i); if (range.getLow(i) != min || range.getSpan(i) != length) { return Errors.format(ErrorKeys.BAD_GRID_RANGE_$3, label, min, min + length);
/** * Returns a "canonical" representation of the grid geometry, that is, one whose grid range * originates in 0,0, but maps to the same real world coordinates. This setup helps in image * processing, as JAI is not meant to be used for images whose ordinates are in the range of the * millions and starts to exhibit numerical issues when used there. * * @return * @since 13.3 */ public GridGeometry2D toCanonical() { // see where we are int lowX = gridRange.getLow(0); int lowY = gridRange.getLow(1); if (lowX == 0 && lowY == 0) { // already canonical return this; } GridEnvelope2D canonicalRange = new GridEnvelope2D(0, 0, gridRange.getSpan(0), gridRange.getSpan(1)); AffineTransform2D translation = new AffineTransform2D(1, 0, 0, 1, lowX, lowY); MathTransform canonicalTransform = ConcatenatedTransform.create(translation, gridToCRS2D); return new GridGeometry2D( canonicalRange, canonicalTransform, getCoordinateReferenceSystem()); } }
/** * Retrieves the {@link GeneralGridEnvelope} that represents the raster grid dimensions of the * highest resolution level in this dataset. * * @return the {@link GeneralGridEnvelope} that represents the raster grid dimensions of the * highest resolution level in this dataset. */ @Override public GridEnvelope getOriginalGridRange(String coverageName) { if (!checkName(coverageName)) { throw new IllegalArgumentException( "The specified coverageName " + coverageName + "is not supported"); } assert originalGridRange.getDimension() == 2; return new GridEnvelope2D( originalGridRange.getLow(0), originalGridRange.getLow(1), originalGridRange.getSpan(0), originalGridRange.getSpan(1)); }
transformed = org.geotools.referencing.CRS.transform(cornerToCRS.inverse(), envelope); } catch (TransformException exception) { throw new IllegalArgumentException( tempEnvelope = CRS.transform(getGridToCRS(), toEnvelope(gridRange)); } catch (Throwable e) { throw new RuntimeException(e); final double xScale = transformed.getSpan(0) / gridRange.getSpan(0); final double yScale = transformed.getSpan(1) / gridRange.getSpan(1); final double xTrans = transformed.getMinimum(0) - xScale * gridRange.getLow(0); final double yTrans = transformed.getMinimum(1) - yScale * gridRange.getLow(1); final AffineTransform newTr = new AffineTransform(xScale, 0, 0, yScale, xTrans, yTrans); XAffineTransform.getScaleY0(transform)); final GeneralEnvelope tempEnvelope = CRS.transform(tr, toEnvelope(gridRange)); tempEnvelope.setCoordinateReferenceSystem( envelope.getCoordinateReferenceSystem());