Examples of org.geotools.referencing.operation.builder.GridToEnvelopeMapper

Package org.geotools.referencing.operation.builder

Examples of org.geotools.referencing.operation.builder.GridToEnvelopeMapper

org.geotools.referencing.operation.builder.GridToEnvelopeMapper
A helper class for building n-dimensional {@linkplain AffineTransform affine transform} mapping {@linkplain GridEnvelope grid ranges} to {@linkplain Envelope envelopes}. The affine transform will be computed automatically from the information specified by the {@link #setGridRange setGridRange} and {@link #setEnvelope setEnvelope}methods, which are mandatory. All other setter methods are optional hints about the affine transform to be created. This builder is convenient when the following conditions are meet:
- Pixels coordinates (usually (x,y) integer values inside the rectangle specified by the grid range) are expressed in some {@linkplain CoordinateReferenceSystem coordinate reference system} known at compiletime. This is often the case. For example the CRS attached to {@link BufferedImage}has always ( {@linkplain AxisDirection#COLUMN_POSITIVE column}, {@linkplain AxisDirection#ROW_POSITIVE row}) axis, with the origin (0,0) in the upper left corner, and row values increasing down.
- "Real world" coordinates (inside the envelope) are expressed in arbitrary horizontal coordinate reference system. Axis directions may be ( {@linkplain AxisDirection#NORTH North}, {@linkplain AxisDirection#WEST West}), or ( {@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}), etc..
In such case (and assuming that the image's CRS has the same characteristics than the {@link BufferedImage}'s CRS described above):
- {@link #setSwapXY swapXY} shall be set to {@code true} if the "real world" axisorder is ( {@linkplain AxisDirection#NORTH North}, {@linkplain AxisDirection#EAST East}) instead of ( {@linkplain AxisDirection#EAST East}, {@linkplain AxisDirection#NORTH North}). This axis swapping is necessary for mapping the ( {@linkplain AxisDirection#COLUMN_POSITIVE column}, {@linkplain AxisDirection#ROW_POSITIVE row}) axis order associated to the image CRS.
- In addition, the "real world" axis directions shall be reversed (by invoking {@linkplain #reverseAxis reverseAxis}(dimension)) if their direction is {@link AxisDirection#WEST WEST} (x axis) or {@link AxisDirection#NORTH NORTH}(y axis), in order to get them oriented toward the {@link AxisDirection#EAST EAST} or {@link AxisDirection#SOUTH SOUTH} direction respectively. The later may seemsunatural, but it reflects the fact that row values are increasing down in an {@link BufferedImage}'s CRS.
@since 2.3 @source $URL$ @version $Id$ @author Martin Desruisseaux (IRD)

            rg.setLow(new int[] { 0, 0 });
            rg.setHigh(new int[] { width, height });
            switch (hdf4_type){
            case APS:
              if (transform == null){
                 final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper();
                     geMapper.setEnvelope(envelope);
                     geMapper.setGridRange(new GridEnvelope2D(gridRange));
                     geMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
                     transform = (AffineTransform) geMapper.createTransform();
              }
              tempTransform = (AffineTransform) transform.clone();
              break;
            case TeraScan:
              if (transform == null){

View Full Code Here

          //it is already a bbox
            coverageBBox = new ReferencedEnvelope(coverageEnvelope);
        }
        
        // compute the approximated full resolution in wgs84
        final GridToEnvelopeMapper geMapper= new GridToEnvelopeMapper(new GridEnvelope2D(coverageRasterArea),coverageGeographicBBox);
        approximateCoverageWGS84FullResolution=CoverageUtilities.getResolution(geMapper.createAffineTransform());
    }

View Full Code Here

            }
            // XXX Optimize when referenced envelope has intersection method that actually retains the CRS, this is the JTS one
            requestedBBox=new ReferencedEnvelope(((ReferencedEnvelope) requestedBBox).intersection(coverageBBox),coverageCRS2D);
            //compute approximate full resolution
            // compute the approximated full resolution in wgs84
            final GridToEnvelopeMapper geMapper= new GridToEnvelopeMapper(new GridEnvelope2D(requestedRasterArea),requestedBBox);
            requestedResolution=CoverageUtilities.getResolution(geMapper.createAffineTransform());
 
//          ////
//          //
//            // STEP 3: Go back to destination space with the nevelope
//          //
//          ////            
//            // transform the intersection envelope from the destination world
//            // space to the requested raster space
//            if (destinationToSourceTransform != null&& !destinationToSourceTransform.isIdentity() )
//            {
//              final GeneralEnvelope temp =CRS.transform(destinationToSourceTransform.inverse(),requestedBBoxInSourceCRS2D) ;
//              temp.setCoordinateReferenceSystem(requestedBBoxCRS2D);
//              requestedBBox = new ReferencedEnvelope(temp);
//              
//            }
//            else
//              //we do not need to do anything
//              requestedBBox=new ReferencedEnvelope(
//                  requestedBBoxInSourceCRS2D.getMinX(),
//                  requestedBBoxInSourceCRS2D.getMaxX(),
//                  requestedBBoxInSourceCRS2D.getMinY(),
//                  requestedBBoxInSourceCRS2D.getMaxY(),
//                  coverageCRS2D);
//            
            
            return;
        } catch (TransformException te) {
            // something bad happened while trying to transform this
            // envelope. let's try with wgs84
            if(LOGGER.isLoggable(Level.FINE))
              LOGGER.log(Level.FINE,te.getLocalizedMessage(),te);
        }


        // //
        //
        // If this does not work, we go back to reproject in the wgs84
        // requested envelope
        //              
        // //
      //convert to WGS84
      final GeographicBoundingBoxImpl geographicRequestedBBox = new GeographicBoundingBoxImpl(requestedBBox);
        ReferencedEnvelope approximateWGS84requestedBBox =GridCoverageUtilities.getReferencedEnvelopeFromGeographicBoundingBox(geographicRequestedBBox);


        // checking the intersection in wgs84 with the geographicbbox for this coverage
        if (!approximateWGS84requestedBBox.intersects((BoundingBox)coverageGeographicBBox))
        {
          requestedBBox =  null;
          return;
        }
        //compute approximate full resolution
        // compute the approximated full resolution in wgs84
        final GridToEnvelopeMapper geMapper= new GridToEnvelopeMapper(new GridEnvelope2D(requestedRasterArea),approximateWGS84requestedBBox);
        approximateWGS84RequestedResolution=CoverageUtilities.getResolution(geMapper.createAffineTransform());


        // intersect with the coverage native WGS84 bbox
        // note that for the moment we got to use general envelope since there is no intersection othrewise
        // TODO fix then we'll have intersection in ReferencedEnvelope
        approximateWGS84requestedBBox=new ReferencedEnvelope(approximateWGS84requestedBBox.intersection(coverageGeographicBBox),DefaultGeographicCRS.WGS84);

View Full Code Here

                        final boolean   automatic)
            throws MismatchedDimensionException
    {
        this.gridRange = clone(gridRange);
        this.envelope  = new GeneralEnvelope(userRange);
        final GridToEnvelopeMapper mapper = new GridToEnvelopeMapper(gridRange, userRange);
        if (!automatic) {
            mapper.setReverseAxis(reverse);
            mapper.setSwapXY(swapXY);
        }
        gridToCRS = mapper.createTransform();
    }

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);
        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform),
            });
        coverageProperties.setGeographicBBox(sourceBBox);
        coverageProperties.setGeographicCRS2D(DefaultGeographicCRS.WGS84);
        SpatialRequestHelper spatialRequestHelper = new SpatialRequestHelper(coverageProperties);
        
        //
        // no target request
        //
        
        
        
        ///// TEST
        spatialRequestHelper.compute();
        assertFalse(spatialRequestHelper.isEmpty());
        assertFalse(spatialRequestHelper.isNeedsReprojection()); // no reprojection
        
        // computed raster area
        Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
        assertFalse(computedRasterArea.isEmpty());
        assertTrue(computedRasterArea.equals(coverageProperties.rasterArea));
        
        // computed bbox
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        assertTrue(computedBBox.equals(sourceBBox));
        
        // transform
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();
        double scale=1; // we scaled down the original image
        assertNotNull(computedResolution);
        assertEquals(scale*XAffineTransform.getScaleX0(sourceGridToWorldTransform),computedResolution[0],1E-6);
        assertEquals(scale*XAffineTransform.getScaleY0(sourceGridToWorldTransform),computedResolution[1],1E-6);
        


    // all this intersecting and so on MUST not impact the requested resolutions
        GridToEnvelopeMapper gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(coverageProperties.rasterArea), 
        sourceBBox);
        gridToEnvelopeMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
        double[] expectedResolution=new double[]{
            XAffineTransform.getScaleX0(gridToEnvelopeMapper.createAffineTransform()),
            XAffineTransform.getScaleY0(gridToEnvelopeMapper.createAffineTransform())};
        assertNotNull(computedResolution);
        assertEquals(expectedResolution[0],computedResolution[0],1E-6);
        assertEquals(expectedResolution[1],computedResolution[1],1E-6);
        
        // for code coverage

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);
        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform)
            });
        coverageProperties.setGeographicBBox(sourceBBox);
        coverageProperties.setGeographicCRS2D(DefaultGeographicCRS.WGS84);
        SpatialRequestHelper spatialRequestHelper = new SpatialRequestHelper(coverageProperties);
        
        //
        // now the target request
        //
        spatialRequestHelper.setAccurateResolution(false);
    ReferencedEnvelope requestedBBox = new ReferencedEnvelope(
            0,180,
            0,90, 
            sourceCRS);        
        GridEnvelope2D requestedRasterArea = new GridEnvelope2D(0,0,250,250);
    spatialRequestHelper.setRequestedGridGeometry(new GridGeometry2D(
            requestedRasterArea, 
            new GeneralEnvelope(requestedBBox)));
        
        
        ///// TEST
        spatialRequestHelper.compute();
        assertFalse(spatialRequestHelper.isEmpty());
        assertFalse(spatialRequestHelper.isNeedsReprojection()); // no reprojection
        
        // computed raster area is equal to requested raster area
        Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
        assertFalse(computedRasterArea.isEmpty());
        assertTrue(computedRasterArea.equals(requestedRasterArea));
        
        // computed bbox is equal to requestede bbox
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        assertTrue(computedBBox.equals(requestedBBox));
        
        // transform
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();
        double scale=(1000.0/2)/250; // we scaled down the original image but we also use a portion of it
        assertNotNull(computedResolution);
        assertEquals(scale*XAffineTransform.getScaleX0(sourceGridToWorldTransform),computedResolution[0],1E-6);
        assertEquals(scale*XAffineTransform.getScaleY0(sourceGridToWorldTransform),computedResolution[1],1E-6);


    // all this intersecting and so on MUST not impact the requested resolutions
        GridToEnvelopeMapper gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(requestedRasterArea), 
        requestedBBox);
        gridToEnvelopeMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
        double[] expectedResolution=new double[]{
            XAffineTransform.getScaleX0(gridToEnvelopeMapper.createAffineTransform()),
            XAffineTransform.getScaleY0(gridToEnvelopeMapper.createAffineTransform())};
        assertNotNull(computedResolution);
        assertEquals(expectedResolution[0],computedResolution[0],1E-6);
        assertEquals(expectedResolution[1],computedResolution[1],1E-6);
        
    }

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);
        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform)
            });
        coverageProperties.setGeographicBBox(sourceBBox);
        coverageProperties.setGeographicCRS2D(DefaultGeographicCRS.WGS84);
        SpatialRequestHelper spatialRequestHelper = new SpatialRequestHelper(coverageProperties);
        
        //
        // now the target request
        //
        spatialRequestHelper.setAccurateResolution(false);
    ReferencedEnvelope requestedBBox = new ReferencedEnvelope(
            0,180,
            0,90, 
            sourceCRS);        
        GridEnvelope2D requestedRasterArea = new GridEnvelope2D(0,0,250,250);
    spatialRequestHelper.setRequestedGridGeometry(new GridGeometry2D(
            requestedRasterArea, 
            new GeneralEnvelope(requestedBBox)));
        
        
        ///// TEST
        spatialRequestHelper.compute();
        assertFalse(spatialRequestHelper.isEmpty());
        assertFalse(spatialRequestHelper.isNeedsReprojection()); // no reprojection
        
        // computed bbox is equal to requestede bbox
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        ReferencedEnvelope finalReferencedEnvelope = new ReferencedEnvelope(
            0,100,
            0,90, 
            sourceCRS);
    assertTrue(computedBBox.equals(finalReferencedEnvelope));
    
        // computed raster area is equal to requested raster area
        Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
        assertFalse(computedRasterArea.isEmpty());
        GridToEnvelopeMapper gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(requestedRasterArea), 
        requestedBBox);
        gridToEnvelopeMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
    assertEquals(computedRasterArea, CRS.transform(gridToEnvelopeMapper.createTransform().inverse(), computedBBox).toRectangle2D().getBounds());
        


        
        // g2w transform
    // all this intersecting and so on MUST not impact the requested resolutions
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();
        double[] expectedResolution=new double[]{
            XAffineTransform.getScaleX0(gridToEnvelopeMapper.createAffineTransform()),
            XAffineTransform.getScaleY0(gridToEnvelopeMapper.createAffineTransform())};
        assertNotNull(computedResolution);
        assertEquals(expectedResolution[0],computedResolution[0],1E-6);
        assertEquals(expectedResolution[1],computedResolution[1],1E-6);

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);


        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform)
            });

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);
        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform)
            });
        coverageProperties.setGeographicBBox(sourceBBox);
        coverageProperties.setGeographicCRS2D(DefaultGeographicCRS.WGS84);
        SpatialRequestHelper spatialRequestHelper = new SpatialRequestHelper(coverageProperties);
        
        //
        // now the request
        //
        spatialRequestHelper.setAccurateResolution(false);
        GridEnvelope2D requestedRasterArea = new GridEnvelope2D(0,0,256,256);
        CoordinateReferenceSystem requestCRS = CRS.decode("EPSG:3857");
        GeneralEnvelope requestedBBox = CRS.transform(sourceBBox, requestCRS);   
    spatialRequestHelper.setRequestedGridGeometry(new GridGeometry2D(
            requestedRasterArea, 
            requestedBBox));
        
        
        ///// TEST
        spatialRequestHelper.compute();
        assertFalse(spatialRequestHelper.isEmpty());
        assertTrue(spatialRequestHelper.isNeedsReprojection()); // no reprojection
        
        // computed raster area
        Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
        assertFalse(computedRasterArea.isEmpty());
        assertTrue(computedRasterArea.equals(requestedRasterArea));
        
        // computed bbox is equal to the requested one
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        // the source bbox and the computed one are the same
        // there might be minor differences due to multiple back and forth roundings, but we need 
        // to make sure they are negligible
        assertTrue(new GeneralEnvelope(computedBBox).equals(sourceBBox, 1E-4, true)); 
        
        // transform
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();
        double scale=1000.0/256; // we scaled down the original image
        assertNotNull(computedResolution);
        assertEquals(scale*XAffineTransform.getScaleX0(sourceGridToWorldTransform),computedResolution[0],1E-6);
        assertEquals(scale*XAffineTransform.getScaleY0(sourceGridToWorldTransform),computedResolution[1],1E-6);
        


    // all this intersecting and so on MUST not impact the requested resolutions
        GridToEnvelopeMapper gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(requestedRasterArea), 
        sourceBBox);
        gridToEnvelopeMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
        double[] expectedResolution=new double[]{
            XAffineTransform.getScaleX0(gridToEnvelopeMapper.createAffineTransform()),
            XAffineTransform.getScaleY0(gridToEnvelopeMapper.createAffineTransform())};
        assertNotNull(computedResolution);
        assertEquals(expectedResolution[0],computedResolution[0],1E-6);
        assertEquals(expectedResolution[1],computedResolution[1],1E-6);
    }

View Full Code Here

    //raster area
        Rectangle sourceRasterArea = new Rectangle(0,0,1000,1000);
    coverageProperties.setRasterArea(sourceRasterArea);


    // creating the g2d
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
            new GridEnvelope2D(sourceRasterArea), 
            sourceBBox);
        AffineTransform sourceGridToWorldTransform = geMapper.createAffineTransform();
    coverageProperties.setGridToWorld2D((MathTransform2D) sourceGridToWorldTransform);
        coverageProperties.setFullResolution(new double[]{
            XAffineTransform.getScaleX0(sourceGridToWorldTransform),
            XAffineTransform.getScaleY0(sourceGridToWorldTransform)
            });
        coverageProperties.setGeographicBBox(sourceBBox);
        coverageProperties.setGeographicCRS2D(DefaultGeographicCRS.WGS84);
        SpatialRequestHelper spatialRequestHelper = new SpatialRequestHelper(coverageProperties);
        
        //
        // now the target request
        //
        spatialRequestHelper.setAccurateResolution(false);
        GridEnvelope2D requestedRasterArea = new GridEnvelope2D(0,0,256,256);
        CoordinateReferenceSystem requestCRS = CRS.decode("EPSG:3857");
    ReferencedEnvelope requestedBBox_ = new ReferencedEnvelope(
            0,180,
            0,70, 
            sourceCRS);   
        GeneralEnvelope requestedBBox = CRS.transform(requestedBBox_, requestCRS);   
    spatialRequestHelper.setRequestedGridGeometry(new GridGeometry2D(
            requestedRasterArea, 
            requestedBBox));
    
        
        
        ///// TEST
        spatialRequestHelper.compute();
        assertFalse(spatialRequestHelper.isEmpty());
        assertTrue(spatialRequestHelper.isNeedsReprojection()); // no reprojection
        
        // computed raster area is equal to requested raster area
        Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
        assertFalse(computedRasterArea.isEmpty());
        assertTrue(computedRasterArea.equals(requestedRasterArea));
        
        // computed bbox is equal to requestede bbox
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        // the source bbox and the computed one are the same
        // there might be minor differences due to multiple back and forth roundings, but we need 
        // to make sure they are negligible
        assertTrue(new GeneralEnvelope(computedBBox).equals(requestedBBox_, 1E-4, true)); 
        
        // transform
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();
        double scaleX=(1000.0/2)/256; // we scaled down the original image but we also use a portion of it
        double scaleY=(1000.0/2)/256; // we scaled down the original image but we also use a portion of it
        assertNotNull(computedResolution);
        assertEquals(scaleX*XAffineTransform.getScaleX0(sourceGridToWorldTransform),computedResolution[0],1E-6);
        assertEquals(scaleY*XAffineTransform.getScaleY0(sourceGridToWorldTransform),computedResolution[1],1E-6);


    // all this intersecting and so on MUST not impact the requested resolutions
        GridToEnvelopeMapper gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(requestedRasterArea), 
        requestedBBox_);
        gridToEnvelopeMapper.setPixelAnchor(PixelInCell.CELL_CORNER);
        double[] expectedResolution=new double[]{
            XAffineTransform.getScaleX0(gridToEnvelopeMapper.createAffineTransform()),
            XAffineTransform.getScaleY0(gridToEnvelopeMapper.createAffineTransform())};
        assertNotNull(computedResolution);
        assertEquals(expectedResolution[0],computedResolution[0],1E-6);
        assertEquals(expectedResolution[1],computedResolution[1],1E-6);
        
        // accurate resolution

View Full Code Here

0 1 2 3 4

TOP

Related Classes of org.geotools.referencing.operation.builder.GridToEnvelopeMapper

mil.nga.giat.geowave.raster.RasterUtils

org.geoserver.wcs2_0.GetCoverage

org.geoserver.wms.map.RenderedImageMapOutputFormat

org.geotools.arcsde.raster.info.RasterDatasetInfo

org.geotools.coverage.grid.GeneralGridGeometry

org.geotools.coverage.grid.io.AbstractGridCoverage2DReader

org.geotools.coverage.grid.io.ReadResolutionCalculator

org.geotools.coverage.io.CoverageReadRequest

org.geotools.coverage.io.SpatialRequestHelper

org.geotools.coverage.io.SpatialRequestHelperTest

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.