Package org.geotools.coverage.grid

Examples of org.geotools.coverage.grid.GridEnvelope2D


        cropEnvelope.setCoordinateReferenceSystem(reader.getCrs());

        final ParameterValue gg = (ParameterValue) ((AbstractGridFormat) reader.getFormat()).READ_GRIDGEOMETRY2D
            .createValue();
        gg.setValue(new GridGeometry2D(
                new GridEnvelope2D(
                    new Rectangle(0, 0, (int) (range.width / 2.0 / cropFactor),
                        (int) (range.height / 2.0 / cropFactor))), cropEnvelope));
        gc = (GridCoverage2D) reader.read(new GeneralParameterValue[] { gg });
        forceDataLoading(gc);
    }
View Full Code Here


            oldEnvelope.getUpperCorner().getOrdinate(1) });
    cropEnvelope.setCoordinateReferenceSystem(reader.getCrs());

    final ParameterValue gg = (ParameterValue) ((AbstractGridFormat) reader
        .getFormat()).READ_GRIDGEOMETRY2D.createValue();
    gg.setValue(new GridGeometry2D(new GridEnvelope2D(new Rectangle(0, 0,
        (int) (range.width / 2.0 / cropFactor),
        (int) (range.height / 2.0 / cropFactor))), cropEnvelope));
    gc = (GridCoverage2D) reader.read(new GeneralParameterValue[] { gg });
    forceDataLoading(gc);
  }
View Full Code Here

    public GridCoverageReaderHelper(GridCoverage2DReader reader, Rectangle mapRasterArea,
            ReferencedEnvelope mapExtent, Interpolation interpolation) throws FactoryException, IOException {
        this.reader = reader;
        this.mapExtent = mapExtent;
        this.requestedGridGeometry = new GridGeometry2D(new GridEnvelope2D(mapRasterArea),
                mapExtent);
        this.worldToScreen = requestedGridGeometry.getCRSToGrid2D();

        // determine if we need a reading gutter, or not, we do if we are reprojecting, or if
        // there is an interpolation to be applied, in that case we need to expand the area
        // we are going to read
        sameCRS = CRS.equalsIgnoreMetadata(mapExtent.getCoordinateReferenceSystem(),
                reader.getCoordinateReferenceSystem());
        paddingRequired = (!sameCRS || !(interpolation instanceof InterpolationNearest)) && !isReprojectingReader(reader);
        if (paddingRequired) {
            // expand the map raster area
            GridEnvelope2D requestedGridEnvelope = new GridEnvelope2D(mapRasterArea);
            applyReadGutter(requestedGridEnvelope);

            // now create the final envelope accordingly
            try {
                this.requestedGridGeometry = new GridGeometry2D(requestedGridEnvelope,
View Full Code Here

                gridRange.width + DEFAULT_PADDING * 2, gridRange.height + DEFAULT_PADDING * 2);
    }

    private GridGeometry2D applyReadGutter(GridGeometry2D gg) {
        MathTransform gridToCRS = gg.getGridToCRS();
        GridEnvelope2D range = new GridEnvelope2D(gg.getGridRange2D());
        applyReadGutter(range);
        CoordinateReferenceSystem crs = gg.getEnvelope2D().getCoordinateReferenceSystem();
        GridGeometry2D result = new GridGeometry2D(range, PixelInCell.CELL_CORNER, gridToCRS, crs,
                null);

View Full Code Here

        if (handler == null) {
            GridCoverage2D readCoverage = readCoverage(readParams);
            return Arrays.asList(readCoverage);
        }

        GridGeometry2D gg = new GridGeometry2D(new GridEnvelope2D(mapRasterArea), mapExtent);

        CoordinateReferenceSystem readerCRS = reader.getCoordinateReferenceSystem();

        // get the areas that we are likely to have to read, and have the projection
        // handler also cut them
View Full Code Here

        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);
            // while we want to read as much data as possible, and cut it only later
            // to avoid warping edge effects later, the resolution needs to be
            // computed against an area that's sane for the projection at hand
            ReferencedEnvelope reducedEnvelope = reduceEnvelope(readEnvelope, handler);
            if (reducedEnvelope == null) {
                return null;
            }
            ReferencedEnvelope reducedEnvelopeInRequestedCRS = reducedEnvelope.transform(
                    requestedGridGeometry.getCoordinateReferenceSystem(), true);
            ReferencedEnvelope gridEnvelope = ReferencedEnvelope.reference(CRS.transform(
                    crsToGrid2D, reducedEnvelopeInRequestedCRS));
            GridEnvelope2D readingGridRange = new GridEnvelope2D((int) gridEnvelope.getMinX(),
                    (int) gridEnvelope.getMinY(), (int) gridEnvelope.getWidth(),
                    (int) gridEnvelope.getHeight());
            GridGeometry2D localGridGeometry = new GridGeometry2D(readingGridRange, gridToCRS2D,
                    mapExtent.getCoordinateReferenceSystem());

            double[][] resolutionLevels = reader.getResolutionLevels();
            ReadResolutionCalculator calculator = new ReadResolutionCalculator(localGridGeometry,
                    readerCRS, resolutionLevels != null ? resolutionLevels[0] : null);
            calculator.setAccurateResolution(true);
            double[] readResolution = calculator.computeRequestedResolution(reducedEnvelope);
            int width = (int) Math.max(1,
                    Math.round(readEnvelope.getWidth() / Math.abs(readResolution[0])));
            int height = (int) Math.max(1,
                    Math.round(readEnvelope.getHeight() / Math.abs(readResolution[1])));
            GridEnvelope2D gridRange = new GridEnvelope2D(0, 0, width, height);
            readingGridGeometry = new GridGeometry2D(gridRange, readEnvelope);
        }
        return readingGridGeometry;
    }
View Full Code Here

                                 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(minx, miny, (maxx - minx), (maxy - miny));
                                 GridEnvelope2D gridEnvelope = new GridEnvelope2D(rect);
                                 readGG = new GridGeometry2D(gridEnvelope, atOriginal, worldEnvelope.getCoordinateReferenceSystem());
                             }
                         }
                    }
                    coverage = readCoverage(reader, params, readGG);
View Full Code Here

        final Dimension dim = new Dimension();
        dim.setSize(reader.getOriginalGridRange().getSpan(0) / 2.0, reader.getOriginalGridRange()
                .getSpan(1) / 2.0);
        Rectangle rasterArea = ((GridEnvelope2D) reader.getOriginalGridRange());
        rasterArea.setSize(dim);
        GridEnvelope2D range = new GridEnvelope2D(rasterArea);
        gg.setValue(new GridGeometry2D(range, envelope));

        GridCoverage2D coverage = reader.read(new GeneralParameterValue[] { gg });
        RenderedImage image = coverage.getRenderedImage();
        assertEquals(image.getWidth(), 180);
        assertEquals(image.getHeight(), 90);
       
        dim.setSize(reader.getOriginalGridRange().getSpan(0) / 4.0, reader.getOriginalGridRange()
                .getSpan(1) / 4.0);
        rasterArea = ((GridEnvelope2D) reader.getOriginalGridRange());
        rasterArea.setSize(dim);
        range = new GridEnvelope2D(rasterArea);
        gg.setValue(new GridGeometry2D(range, envelope));

        coverage = reader.read(new GeneralParameterValue[] { gg });
        image = coverage.getRenderedImage();
        assertEquals(image.getWidth(), 90);
View Full Code Here

                    // the effect is a degradation of quality, but we take that into account
                    // emprically
                    //
                    requestedResolution = null;

                    final GridToEnvelopeMapper geMapper= new GridToEnvelopeMapper(new GridEnvelope2D(destinationRasterArea),cropBBox);
                    final AffineTransform tempTransform = geMapper.createAffineTransform();
                   
                    requestedRasterScaleFactors = new double[2];
                    requestedResolution = new double[] {
                            XAffineTransform.getScaleX0(tempTransform),
View Full Code Here

    final GeneralEnvelope envelope = reader.getOriginalEnvelope();
    final Dimension dim= new Dimension();
    dim.setSize(reader.getOriginalGridRange().getSpan(0)/2.0, reader.getOriginalGridRange().getSpan(1)/2.0);
    final Rectangle rasterArea=(( GridEnvelope2D)reader.getOriginalGridRange());
    rasterArea.setSize(dim);
    final GridEnvelope2D range= new GridEnvelope2D(rasterArea);
    gg.setValue(new GridGeometry2D(range,envelope));
   
    // use imageio with defined tiles
    final ParameterValue<Boolean> useJai = AbstractGridFormat.USE_JAI_IMAGEREAD.createValue();
    useJai.setValue(false);
View Full Code Here

TOP

Related Classes of org.geotools.coverage.grid.GridEnvelope2D

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.