public static HashMap<String, Double> getRegionParamsFromGridCoverage( GridCoverage2D gridCoverage) { HashMap<String, Double> envelopeParams = new HashMap<String, Double>(); Envelope envelope = gridCoverage.getEnvelope(); DirectPosition lowerCorner = envelope.getLowerCorner(); double[] westSouth = lowerCorner.getCoordinate(); DirectPosition upperCorner = envelope.getUpperCorner(); double[] eastNorth = upperCorner.getCoordinate(); GridGeometry2D gridGeometry = gridCoverage.getGridGeometry(); GridEnvelope2D gridRange = gridGeometry.getGridRange2D(); int height = gridRange.height; int width = gridRange.width; AffineTransform gridToCRS = (AffineTransform) gridGeometry.getGridToCRS(); double xRes = XAffineTransform.getScaleX0(gridToCRS); double yRes = XAffineTransform.getScaleY0(gridToCRS); envelopeParams.put(NORTH, eastNorth[1]); envelopeParams.put(SOUTH, westSouth[1]); envelopeParams.put(WEST, westSouth[0]); envelopeParams.put(EAST, eastNorth[0]); envelopeParams.put(XRES, xRes); envelopeParams.put(YRES, yRes); envelopeParams.put(ROWS, (double) height); envelopeParams.put(COLS, (double) width); return envelopeParams; }
private void worldToGrid(Coordinate c, int i) throws InvalidGridGeometryException, TransformException { DirectPosition2D world = new DirectPosition2D(c.x, c.y); GridCoordinates2D grid = gridGeometry.worldToGrid(world); px[i] = grid.x; py[i] = grid.y; }
private void storeResult( double[] interpolatedValues, HashMap<Integer, Coordinate> interpolatedCoordinatesMap) throws MismatchedDimensionException, Exception { WritableRandomIter outIter = RandomIterFactory.createWritable(outWR, null); Set<Integer> pointsToInterpolateIdSett = interpolatedCoordinatesMap.keySet(); Iterator<Integer> idIterator = pointsToInterpolateIdSett.iterator(); int c = 0; MathTransform transf = inInterpolationGrid.getCRSToGrid2D(); final DirectPosition gridPoint = new DirectPosition2D(); while (idIterator.hasNext()) { int id = idIterator.next(); Coordinate coordinate = (Coordinate) interpolatedCoordinatesMap.get(id); DirectPosition point = new DirectPosition2D( inInterpolationGrid.getCoordinateReferenceSystem(), coordinate.x, coordinate.y); transf.transform(point, gridPoint); double[] gridCoord = gridPoint.getCoordinate(); int x = (int) gridCoord[0]; int y = (int) gridCoord[1]; outIter.setSample(x, y, 0, checkResultValue(interpolatedValues[c])); c++; } RegionMap regionMap = CoverageUtilities.gridGeometry2RegionParamsMap(inInterpolationGrid); outGrid = CoverageUtilities.buildCoverage( "gridded", outWR, regionMap, inInterpolationGrid.getCoordinateReferenceSystem()); }
/** * Applies the band select operation to a grid coverage. * * @param cropEnvelope the target envelope; always not null * @param cropROI the target ROI shape; nullable * @param roiTolerance; as read from op's params * @param sourceCoverage is the source {@link GridCoverage2D} that we want to crop. * @param hints A set of rendering hints, or {@code null} if none. * @param sourceGridToWorldTransform is the 2d grid-to-world transform for the source coverage. * @return The result as a grid coverage. */ private static GridCoverage2D buildResult( final GeneralEnvelope cropEnvelope, final Geometry cropROI, final double roiTolerance, final boolean forceMosaic, final Hints hints, final GridCoverage2D sourceCoverage, final AffineTransform sourceGridToWorldTransform) { // // Getting the source coverage and its child geolocation objects // final RenderedImage sourceImage = sourceCoverage.getRenderedImage(); final GridGeometry2D sourceGridGeometry = ((GridGeometry2D) sourceCoverage.getGridGeometry()); final GridEnvelope2D sourceGridRange = sourceGridGeometry.getGridRange2D(); // // Now we try to understand if we have a simple scale and translate or a // more elaborated grid-to-world transformation n which case a simple // crop could not be enough, but we may need a more elaborated chain of // operation in order to do a good job. As an instance if we // have a rotation which is not multiple of PI/2 we have to use // the mosaic with a ROI // final boolean isSimpleTransform = CoverageUtilities.isSimpleGridToWorldTransform(sourceGridToWorldTransform, EPS); // Do we need to explode the Palette to RGB(A)? // int actionTaken = 0; // // // // Layout // // // final RenderingHints targetHints = new RenderingHints(null); if (hints != null) targetHints.add(hints); final ImageLayout layout = initLayout(sourceImage, targetHints); targetHints.put(JAI.KEY_IMAGE_LAYOUT, layout); // // prepare the processor to use for this operation // final JAI processor = OperationJAI.getJAI(targetHints); final boolean useProvidedProcessor = !processor.equals(JAI.getDefaultInstance()); try { if (cropROI != null) { // replace the cropEnvelope with the envelope of the intersection // of the ROI and the cropEnvelope. // Remember that envelope(intersection(roi,cropEnvelope)) != intersection(cropEnvelope, // envelope(roi)) final Polygon modelSpaceROI = FeatureUtilities.getPolygon(cropEnvelope, GFACTORY); Geometry intersection = IntersectUtils.intersection(cropROI, modelSpaceROI); Envelope2D e2d = JTS.getEnvelope2D( intersection.getEnvelopeInternal(), cropEnvelope.getCoordinateReferenceSystem()); GeneralEnvelope ge = new GeneralEnvelope((org.opengis.geometry.Envelope) e2d); cropEnvelope.setEnvelope(ge); } // // // // Build the new range by keeping into // account translation of grid geometry constructor for respecting // OGC PIXEL-IS-CENTER ImageDatum assumption. // // // final AffineTransform sourceWorldToGridTransform = sourceGridToWorldTransform.createInverse(); // // // // finalRasterArea will hold the smallest rectangular integer raster area that contains the // floating point raster // area which we obtain when applying the world-to-grid transform to the cropEnvelope. Note // that we need to intersect // such an area with the area covered by the source coverage in order to be sure we do not try // to crop outside the // bounds of the source raster. // // // final Rectangle2D finalRasterAreaDouble = XAffineTransform.transform( sourceWorldToGridTransform, cropEnvelope.toRectangle2D(), null); final Rectangle finalRasterArea = finalRasterAreaDouble.getBounds(); // intersection with the original range in order to not try to crop outside the image bounds Rectangle.intersect(finalRasterArea, sourceGridRange, finalRasterArea); if (finalRasterArea.isEmpty()) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP)); // // // // It is worth to point out that doing a crop the G2W transform // should not change while the envelope might change as // a consequence of the rounding of the underlying image datum // which uses integer factors or in case the G2W is very // complex. Note that we will always strive to // conserve the original grid-to-world transform. // // // // we do not have to crop in this case (should not really happen at // this time) if (finalRasterArea.equals(sourceGridRange) && isSimpleTransform && cropROI == null) return sourceCoverage; // // // // if I get here I have something to crop // using the world-to-grid transform for going from envelope to the // new grid range. // // // final double minX = finalRasterArea.getMinX(); final double minY = finalRasterArea.getMinY(); final double width = finalRasterArea.getWidth(); final double height = finalRasterArea.getHeight(); // // // // Check if we need to use mosaic or crop // // // final PlanarImage croppedImage; final ParameterBlock pbj = new ParameterBlock(); pbj.addSource(sourceImage); java.awt.Polygon rasterSpaceROI = null; String operatioName = null; if (!isSimpleTransform || cropROI != null) { // ///////////////////////////////////////////////////////////////////// // // We don't have a simple scale and translate transform, JAI // crop MAY NOT suffice. Let's decide whether or not we'll use // the Mosaic. // // ///////////////////////////////////////////////////////////////////// Polygon modelSpaceROI = FeatureUtilities.getPolygon(cropEnvelope, GFACTORY); // // // // Now convert this polygon back into a shape for the source // raster space. // // // final List<Point2D> points = new ArrayList<Point2D>(5); rasterSpaceROI = FeatureUtilities.convertPolygonToPointArray( modelSpaceROI, ProjectiveTransform.create(sourceWorldToGridTransform), points); if (rasterSpaceROI == null || rasterSpaceROI.getBounds().isEmpty()) if (finalRasterArea.isEmpty()) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP)); final boolean doMosaic = forceMosaic ? true : decideJAIOperation(roiTolerance, rasterSpaceROI.getBounds2D(), points); if (doMosaic || cropROI != null) { // prepare the params for the mosaic final ROI[] roiarr; try { if (cropROI != null) { final LiteShape2 cropRoiLS2 = new LiteShape2( cropROI, ProjectiveTransform.create(sourceWorldToGridTransform), null, false); ROI cropRS = new ROIShape(cropRoiLS2); Rectangle2D rt = cropRoiLS2.getBounds2D(); if (!hasIntegerBounds(rt)) { // Approximate Geometry Geometry geo = (Geometry) cropRoiLS2.getGeometry().clone(); transformGeometry(geo); cropRS = new ROIShape(new LiteShape2(geo, null, null, false)); } roiarr = new ROI[] {cropRS}; } else { final ROIShape roi = new ROIShape(rasterSpaceROI); roiarr = new ROI[] {roi}; } } catch (FactoryException ex) { throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), ex); } pbj.add(MosaicDescriptor.MOSAIC_TYPE_OVERLAY); pbj.add(null); pbj.add(roiarr); pbj.add(null); pbj.add(CoverageUtilities.getBackgroundValues(sourceCoverage)); // prepare the final layout final Rectangle bounds = rasterSpaceROI.getBounds2D().getBounds(); Rectangle.intersect(bounds, sourceGridRange, bounds); if (bounds.isEmpty()) throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP)); // we do not have to crop in this case (should not really happen at // this time) if (!doMosaic && bounds.getBounds().equals(sourceGridRange) && isSimpleTransform) return sourceCoverage; // nice trick, we use the layout to do the actual crop final Rectangle boundsInt = bounds.getBounds(); layout.setMinX(boundsInt.x); layout.setWidth(boundsInt.width); layout.setMinY(boundsInt.y); layout.setHeight(boundsInt.height); operatioName = "Mosaic"; } } // do we still have to set the operation name? If so that means we have to go for crop. if (operatioName == null) { // executing the crop pbj.add((float) minX); pbj.add((float) minY); pbj.add((float) width); pbj.add((float) height); operatioName = "GTCrop"; } // // // // Apply operation // // // if (!useProvidedProcessor) { croppedImage = JAI.create(operatioName, pbj, targetHints); } else { croppedImage = processor.createNS(operatioName, pbj, targetHints); } // conserve the input grid to world transformation Map sourceProperties = sourceCoverage.getProperties(); Map properties = null; if (sourceProperties != null && !sourceProperties.isEmpty()) { properties = new HashMap(sourceProperties); } if (rasterSpaceROI != null) { if (properties != null) { properties.put("GC_ROI", rasterSpaceROI); } else { properties = Collections.singletonMap("GC_ROI", rasterSpaceROI); } } return new GridCoverageFactory(hints) .create( sourceCoverage.getName(), croppedImage, new GridGeometry2D( new GridEnvelope2D(croppedImage.getBounds()), sourceGridGeometry.getGridToCRS2D(PixelOrientation.CENTER), sourceCoverage.getCoordinateReferenceSystem()), (GridSampleDimension[]) (actionTaken == 1 ? null : sourceCoverage.getSampleDimensions().clone()), new GridCoverage[] {sourceCoverage}, properties); } catch (TransformException e) { throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), e); } catch (NoninvertibleTransformException e) { throw new CannotCropException(Errors.format(ErrorKeys.CANT_CROP), e); } }
/** * This method reads in the TIFF image, constructs an appropriate CRS, determines the math * transform from raster to the CRS model, and constructs a GridCoverage. * * @param params currently ignored, potentially may be used for hints. * @return grid coverage represented by the image * @throws IOException on any IO related troubles */ public GridCoverage2D read(GeneralParameterValue[] params) throws IOException { GeneralEnvelope requestedEnvelope = null; Rectangle dim = null; Color inputTransparentColor = null; OverviewPolicy overviewPolicy = null; int[] suggestedTileSize = null; if (params != null) { // // Checking params // if (params != null) { for (int i = 0; i < params.length; i++) { final ParameterValue param = (ParameterValue) params[i]; final ReferenceIdentifier name = param.getDescriptor().getName(); if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName())) { final GridGeometry2D gg = (GridGeometry2D) param.getValue(); requestedEnvelope = new GeneralEnvelope((Envelope) gg.getEnvelope2D()); dim = gg.getGridRange2D().getBounds(); continue; } if (name.equals(AbstractGridFormat.OVERVIEW_POLICY.getName())) { overviewPolicy = (OverviewPolicy) param.getValue(); continue; } if (name.equals(AbstractGridFormat.INPUT_TRANSPARENT_COLOR.getName())) { inputTransparentColor = (Color) param.getValue(); continue; } if (name.equals(AbstractGridFormat.SUGGESTED_TILE_SIZE.getName())) { String suggestedTileSize_ = (String) param.getValue(); if (suggestedTileSize_ != null && suggestedTileSize_.length() > 0) { suggestedTileSize_ = suggestedTileSize_.trim(); int commaPosition = suggestedTileSize_.indexOf(","); if (commaPosition < 0) { int tileDim = Integer.parseInt(suggestedTileSize_); suggestedTileSize = new int[] {tileDim, tileDim}; } else { int tileW = Integer.parseInt(suggestedTileSize_.substring(0, commaPosition)); int tileH = Integer.parseInt(suggestedTileSize_.substring(commaPosition + 1)); suggestedTileSize = new int[] {tileW, tileH}; } } continue; } } } } // // set params // Integer imageChoice = new Integer(0); final ImageReadParam readP = new ImageReadParam(); try { imageChoice = setReadParams(overviewPolicy, readP, requestedEnvelope, dim); } catch (TransformException e) { new DataSourceException(e); } // // IMAGE READ OPERATION // Hints newHints = null; if (suggestedTileSize != null) { newHints = hints.clone(); final ImageLayout layout = new ImageLayout(); layout.setTileGridXOffset(0); layout.setTileGridYOffset(0); layout.setTileHeight(suggestedTileSize[1]); layout.setTileWidth(suggestedTileSize[0]); newHints.add(new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout)); } final ParameterBlock pbjRead = new ParameterBlock(); if (extOvrImgChoice >= 0 && imageChoice >= extOvrImgChoice) { pbjRead.add( ovrInStreamSPI.createInputStreamInstance( ovrSource, ImageIO.getUseCache(), ImageIO.getCacheDirectory())); pbjRead.add(imageChoice - extOvrImgChoice); } else { pbjRead.add( inStreamSPI != null ? inStreamSPI.createInputStreamInstance( source, ImageIO.getUseCache(), ImageIO.getCacheDirectory()) : ImageIO.createImageInputStream(source)); pbjRead.add(imageChoice); } pbjRead.add(Boolean.FALSE); pbjRead.add(Boolean.FALSE); pbjRead.add(Boolean.FALSE); pbjRead.add(null); pbjRead.add(null); pbjRead.add(readP); pbjRead.add(READER_SPI.createReaderInstance()); RenderedOp coverageRaster = JAI.create("ImageRead", pbjRead, newHints != null ? (RenderingHints) newHints : null); // // MASKING INPUT COLOR as indicated // if (inputTransparentColor != null) { coverageRaster = new ImageWorker(coverageRaster) .setRenderingHints(newHints) .makeColorTransparent(inputTransparentColor) .getRenderedOperation(); } AffineTransform rasterToModel = getRescaledRasterToModel(coverageRaster); try { return createCoverage(coverageRaster, ProjectiveTransform.create(rasterToModel)); } catch (Exception e) { // dispose and close file ImageUtilities.disposePlanarImageChain(coverageRaster); // rethrow if (e instanceof DataSourceException) { throw (DataSourceException) e; } throw new DataSourceException(e); } }
private void initialize() { AttributeDescriptor attributeDescriptor = featureCollection.getSchema().getDescriptor(attributeName); if (attributeDescriptor == null) { throw new RuntimeException(attributeName + " not found"); } Class<?> attClass = attributeDescriptor.getType().getBinding(); if (!Number.class.isAssignableFrom(attClass)) { throw new RuntimeException(attributeName + " is not numeric type"); } try { checkTransform(); gridGeometry = new GridGeometry2D( new GridEnvelope2D(0, 0, coverageWidth, coverageHeight), coverageEnvelope); // NOTE: assumes transformation results in equal length scales across both axes! if (mimimumLengthPixels > 0) { Point2D s0 = new Point(0, 0); Point2D d0 = gridGeometry.getGridToCRS2D().transform(s0, null); Point2D s1 = new Point(mimimumLengthPixels, 0); Point2D d1 = gridGeometry.getGridToCRS2D().transform(s1, null); minimumLengthMeters = d1.distance(d0); } else { minimumLengthMeters = -1; } } catch (TransformException ex) { throw new RuntimeException("Unable to transform", ex); } createImage(); String featureCollectionId = featureCollection.getSchema().getName().getURI(); baselineFeaturesMap = new LinkedHashMap<Integer, LinkedList<SimpleFeature>>(); AttributeRange attributeRange = null; LOGGER.log( Level.INFO, "Calculating attribute value range for {}:{}", new Object[] {featureCollectionId, attributeName}); SimpleFeatureIterator iterator = null; try { iterator = featureCollection.features(); double minimum = Double.MAX_VALUE; double maximum = -Double.MAX_VALUE; while (iterator.hasNext()) { SimpleFeature feature = iterator.next(); double value = ((Number) feature.getAttribute(attributeName)).doubleValue(); if (Math.abs(value) < 1e10) { if (value > maximum) { maximum = value; } if (value < minimum) { minimum = value; } } Object baselineIdObject = feature.getAttribute(Constants.BASELINE_ID_ATTR); // this is needed for older files w/o baseline ID, null is a valid map key Integer baselineId = baselineIdObject instanceof Number ? ((Number) baselineIdObject).intValue() : null; LinkedList<SimpleFeature> baselineFeatures = baselineFeaturesMap.get(baselineId); if (baselineFeatures == null) { baselineFeatures = new LinkedList<SimpleFeature>(); baselineFeaturesMap.put(baselineId, baselineFeatures); } baselineFeatures.add(feature); } if (minimum < maximum) { attributeRange = new AttributeRange(minimum, maximum); LOGGER.log( Level.INFO, "Attribute value range for {}:{} {}", new Object[] {featureCollectionId, attributeName, attributeRange}); } } finally { if (iterator != null) { iterator.close(); } } if (attributeRange != null) { attributeRange = (attributeRange.min < 0) ? attributeRange.zeroInflect(invert) : invert ? new AttributeRange(attributeRange.max, 0) : new AttributeRange(0, attributeRange.max); colorMap = new JetColorMap(attributeRange); } }
public void setRequestedGridGeometry(GridGeometry2D gridGeometry) { Utilities.ensureNonNull("girdGeometry", gridGeometry); requestedBBox = new ReferencedEnvelope((Envelope) gridGeometry.getEnvelope2D()); requestedRasterArea = gridGeometry.getGridRange2D().getBounds(); requestedGridToWorld = (AffineTransform) gridGeometry.getGridToCRS2D(); }
/** * Encodes the DomainSet as per the GML spec of the provided {@link GridCoverage2D} * * <p>e.g.: * * <pre>{@code * <gml:domainSet> * <gml:Grid gml:id="gr0001_C0001" dimension="2"> * <gml:limits> * <gml:GridEnvelope> * <gml:low>1 1</gml:low> * <gml:high>5 3</gml:high> * </gml:GridEnvelope> * </gml:limits> * <gml:axisLabels>Lat Long</gml:axisLabels> * </gml:Grid> * </gml:domainSet> * }</pre> * * @param gc2d the {@link GridCoverage2D} for which to encode the DomainSet. * @param srsName * @param axesSwap */ public void handleDomainSet( GridGeometry2D gg2D, int gridDimension, String gcName, String srsName, boolean axesSwap) { // setup vars final String gridId = "grid00__" + gcName; // Grid Envelope final GridEnvelope gridEnvelope = gg2D.getGridRange(); final StringBuilder lowSb = new StringBuilder(); for (int i : gridEnvelope.getLow().getCoordinateValues()) { lowSb.append(i).append(' '); } final StringBuilder highSb = new StringBuilder(); for (int i : gridEnvelope.getHigh().getCoordinateValues()) { highSb.append(i).append(' '); } // build the fragment final AttributesImpl gridAttrs = new AttributesImpl(); gridAttrs.addAttribute("", "gml:id", "gml:id", "", gridId); gridAttrs.addAttribute("", "dimension", "dimension", "", String.valueOf(gridDimension)); start("gml:domainSet"); start("gml:RectifiedGrid", gridAttrs); start("gml:limits"); // GridEnvelope start("gml:GridEnvelope"); element("gml:low", lowSb.toString().trim()); element("gml:high", highSb.toString().trim()); end("gml:GridEnvelope"); end("gml:limits"); // Axis Label element("gml:axisLabels", "i j"); final MathTransform2D transform = gg2D.getGridToCRS2D(PixelOrientation.CENTER); if (!(transform instanceof AffineTransform2D)) { throw new IllegalStateException("Invalid grid to worl provided:" + transform.toString()); } final AffineTransform2D g2W = (AffineTransform2D) transform; // Origin // we use ULC as per our G2W transformation final AttributesImpl pointAttr = new AttributesImpl(); pointAttr.addAttribute("", "gml:id", "gml:id", "", "p00_" + gcName); pointAttr.addAttribute("", "srsName", "srsName", "", srsName); start("gml:origin"); start("gml:Point", pointAttr); element( "gml:pos", axesSwap ? g2W.getTranslateY() + " " + g2W.getTranslateX() : g2W.getTranslateX() + " " + g2W.getTranslateY()); end("gml:Point"); end("gml:origin"); // Offsets final AttributesImpl offsetAttr = new AttributesImpl(); offsetAttr.addAttribute("", "srsName", "srsName", "", srsName); // notice the orientation of the transformation I create. The origin of the coordinates // in this grid is not at UPPER LEFT like in our grid to world but at LOWER LEFT !!! element( "gml:offsetVector", Double.valueOf(axesSwap ? g2W.getShearX() : g2W.getScaleX()) + " " + Double.valueOf(axesSwap ? g2W.getScaleX() : g2W.getShearX()), offsetAttr); element( "gml:offsetVector", Double.valueOf(axesSwap ? g2W.getScaleY() : g2W.getShearY()) + " " + Double.valueOf(axesSwap ? g2W.getShearY() : g2W.getScaleY()), offsetAttr); end("gml:RectifiedGrid"); end("gml:domainSet"); }
private ArcSDEGridCoverage2DReaderJAI.ReadParameters parseReadParams( final GeneralParameterValue[] params) throws IllegalArgumentException { if (params == null) { throw new IllegalArgumentException("No GeneralParameterValue given to read operation"); } GeneralEnvelope reqEnvelope = null; GridEnvelope dim = null; OverviewPolicy overviewPolicy = null; // ///////////////////////////////////////////////////////////////////// // // Checking params // // ///////////////////////////////////////////////////////////////////// for (int i = 0; i < params.length; i++) { final ParameterValue<?> param = (ParameterValue<?>) params[i]; final String name = param.getDescriptor().getName().getCode(); if (name.equals(AbstractGridFormat.READ_GRIDGEOMETRY2D.getName().toString())) { final GridGeometry2D gg = (GridGeometry2D) param.getValue(); reqEnvelope = new GeneralEnvelope((Envelope) gg.getEnvelope2D()); final GeneralEnvelope coverageEnvelope = getOriginalEnvelope(); CoordinateReferenceSystem nativeCrs = coverageEnvelope.getCoordinateReferenceSystem(); CoordinateReferenceSystem requestCrs = reqEnvelope.getCoordinateReferenceSystem(); if (!CRS.equalsIgnoreMetadata(nativeCrs, requestCrs)) { LOGGER.fine( "Request CRS and native CRS differ, " + "reprojecting request envelope to native CRS"); ReferencedEnvelope nativeCrsEnv; nativeCrsEnv = toNativeCrs(reqEnvelope, nativeCrs); reqEnvelope = new GeneralEnvelope(nativeCrsEnv); } dim = gg.getGridRange2D(); continue; } if (name.equals(AbstractGridFormat.OVERVIEW_POLICY.getName().toString())) { overviewPolicy = (OverviewPolicy) param.getValue(); continue; } } if (reqEnvelope == null && dim == null) { reqEnvelope = getOriginalEnvelope(); dim = getOriginalGridRange(); } if (reqEnvelope == null) { reqEnvelope = getOriginalEnvelope(); } if (dim == null) { final GeneralEnvelope adjustedGRange; try { MathTransform gridToWorld = getOriginalGridToWorld(PixelInCell.CELL_CENTER); MathTransform worldToGrid = gridToWorld.inverse(); adjustedGRange = CRS.transform(worldToGrid, reqEnvelope); } catch (Exception e) { throw new RuntimeException(e); } 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: " + getOriginalEnvelope()); } if (dim.getSpan(0) <= 0 || dim.getSpan(1) <= 0) { throw new IllegalArgumentException("The requested coverage dimension can't be null: " + dim); } if (overviewPolicy == null) { overviewPolicy = OverviewPolicy.NEAREST; LOGGER.finer("No overview policy requested, defaulting to " + overviewPolicy); } LOGGER.fine("Overview policy is " + overviewPolicy); ArcSDEGridCoverage2DReaderJAI.ReadParameters parsedParams = new ArcSDEGridCoverage2DReaderJAI.ReadParameters(); parsedParams.requestedEnvelope = reqEnvelope; parsedParams.dim = dim; parsedParams.overviewPolicy = overviewPolicy; return parsedParams; }