Package org.geotools.referencing.operation.builder

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


    //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");
    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 bbox is equal to requestede bbox
        BoundingBox computedBBox = spatialRequestHelper.getComputedBBox();
        assertFalse(computedBBox.isEmpty());
        ReferencedEnvelope finalReferencedEnvelope = new ReferencedEnvelope(
            0,100,
            0,70,
            sourceCRS);
        // 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(finalReferencedEnvelope, 1E-4, true));
   
        // 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,
        new Rectangle(0,0,142,256));
       

       
        // g2w transform
    // all this intersecting and so on MUST not impact the requested resolutions
        // transform
        AffineTransform computedG2W = spatialRequestHelper.getComputedGridToWorld();
        assertNotNull(computedG2W);
        double[] computedResolution = spatialRequestHelper.getComputedResolution();

    // all this intersecting and so on MUST not impact the requested resolutions
        gridToEnvelopeMapper = new GridToEnvelopeMapper(
        new GridEnvelope2D(computedRasterArea),
        finalReferencedEnvelope);
        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);
    spatialRequestHelper.setRequestedGridGeometry(new GridGeometry2D(
          requestedRasterArea,
          new GeneralEnvelope(sourceBBox)));
     
     
      ///// TEST
      spatialRequestHelper.compute();
      assertFalse(spatialRequestHelper.isEmpty());
      assertFalse(spatialRequestHelper.isNeedsReprojection()); // no reprojection
     
      // computed raster area
      Rectangle computedRasterArea = spatialRequestHelper.getComputedRasterArea();
      assertFalse(computedRasterArea.isEmpty());
      assertTrue(computedRasterArea.equals(requestedRasterArea));
     
      // 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=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);
     
      // for code coverage
View Full Code Here

        // Resolution requested. I am here computing the resolution required
        // by the user.
        //
        // //
        if (requestedEnvelope != null) {
            final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper();
            geMapper.setEnvelope(requestedEnvelope);
            geMapper.setGridRange(new GeneralGridEnvelope(requestedDim, 2));
            geMapper.setPixelAnchor(pixelInCell);
            final AffineTransform transform = geMapper.createAffineTransform();
            requestedRes = CoverageUtilities.getResolution(transform);
        }

        if (requestedRes == null) {
            return;
View Full Code Here

                    // cropBBox),PixelInCell.CELL_CORNER,false).toRectangle();
                    // XRectangle2D.intersect(sourceRasterArea, rasterManager.spatialDomainManager.coverageRasterArea, sourceRasterArea);
                    // if(sourceRasterArea.isEmpty())
                    // throw new DataSourceException("The request source raster area is empty");

                    final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(new GridEnvelope2D(destinationRasterArea), cropBBox);
                    final AffineTransform tempTransform = geMapper.createAffineTransform();
                    // final double scaleX=XAffineTransform.getScaleX0((AffineTransform)
                    // requestedGridToWorld)/XAffineTransform.getScaleX0(tempTransform);
                    // final double scaleY=XAffineTransform.getScaleY0((AffineTransform)
                    // requestedGridToWorld)/XAffineTransform.getScaleY0(tempTransform);
                    // //
View Full Code Here

        // //
        final GeneralEnvelope envelope = reader.getOriginalEnvelope();
        final GridEnvelope originalRange = reader.getOriginalGridRange();
        final Rectangle rasterArea = new Rectangle(0, 0, (int) Math.ceil(originalRange.getSpan(0) / 9.0), (int) Math.ceil(originalRange.getSpan(1) / 9.0));
        final GridEnvelope2D range = new GridEnvelope2D(rasterArea);
        final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(range, envelope);
        geMapper.setPixelAnchor(PixelInCell.CELL_CENTER);
        final AffineTransform gridToWorld = geMapper.createAffineTransform();
        final double requestedResolution[] = new double[]{XAffineTransform.getScaleX0(gridToWorld), XAffineTransform.getScaleY0(gridToWorld)};

        TestSet at = null;
        if (nOv == 4 && Math.abs(hRes[0][0] - 0.833333333333) <= THRESHOLD) {
            at = at1;
View Full Code Here

            this.rasterArea = (Rectangle) rasterArea.clone();
        }
        this.geographicArea = worldArea;

        // create a math transform
        final GridToEnvelopeMapper mapper = new GridToEnvelopeMapper(
                new GridEnvelope2D(rasterArea), new ReferencedEnvelope(worldArea));
        mapper.setPixelAnchor(PixelInCell.CELL_CENTER);
        this.gridToWorldTransform = (MathTransform2D) mapper.createTransform();
    }
View Full Code Here

                    if(LOGGER.isLoggable(Level.WARNING))
                            LOGGER.log(Level.WARNING,"Using forced coordinate reference system ");
                } else
                    crs = initCRS();
    this.originalEnvelope = getBounds(crs);
    final GridToEnvelopeMapper geMapper= new  GridToEnvelopeMapper(originalGridRange,originalEnvelope);
    geMapper.setPixelAnchor(PixelInCell.CELL_CENTER);
    this.raster2Model=geMapper.createTransform();

    // /////////////////////////////////////////////////////////////////////
    //
    // Compute source Resolution
    //
View Full Code Here

                overviewsController = new OverviewsController(new RasterLayout(0,0, property.getWidth(), property.getHeight()), null);
            } else {
                this.coverageEnvelope = property.getEnvelope();
                this.coverageRasterArea = new GridEnvelope2D(0, 0, property.getWidth(), property.getHeight());
                this.coverageCRS = this.coverageEnvelope.getCoordinateReferenceSystem();
                GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper((GridEnvelope)coverageRasterArea, (Envelope)this.coverageEnvelope);
                geMapper.setPixelAnchor(PixelInCell.CELL_CENTER);
                this.coverageGridToWorld2D = geMapper.createTransform();
                overviewsController = new OverviewsController(new RasterLayout(0,0, property.getWidth(), property.getHeight()), this.coverageGridToWorld2D);
                final OverviewLevel highestLevel= overviewsController.resolutionsLevels.get(0);
                coverageFullResolution = new double[2];
                coverageFullResolution[0] = highestLevel.resolutionX;
                coverageFullResolution[1] = highestLevel.resolutionY;
View Full Code Here

            // build the g2W for this tile, in principle we should get it
            // somehow from the tile itself or from the index, but at the moment
            // we do not have such info, hence we assume that it is a simple
            // scale and translate
            if (gridToWorld == null) {
                final GridToEnvelopeMapper geMapper = new GridToEnvelopeMapper(
                        new GridEnvelope2D(originalDimension), granuleBBOX);
                geMapper.setPixelAnchor(PixelInCell.CELL_CENTER);
                this.baseGridToWorld = geMapper.createAffineTransform();
            } else
                this.baseGridToWorld = (AffineTransform) gridToWorld;

            // add the base level
            this.granuleLevels.put(Integer.valueOf(0), new Level(1, 1,
View Full Code Here

   */
  public static MathTransform createTransform(
      final double[] idRangePerDimension,
      final MultiDimensionalNumericData fullBounds )
      throws IllegalStateException {
    final GridToEnvelopeMapper mapper = new GridToEnvelopeMapper();
    final boolean swapXY = mapper.getSwapXY();
    final boolean[] reverse = mapper.getReverseAxis();
    final PixelInCell gridType = PixelInCell.CELL_CORNER;
    final int dimension = 2;
    /*
     * Setup the multi-dimensional affine transform for use with OpenGIS.
     * According OpenGIS specification, transforms must map pixel center.
View Full Code Here

TOP

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

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.