Examples of AffineTransform2D


Examples of org.geotools.referencing.operation.transform.AffineTransform2D

            tY);
    final MathTransform finalTransform;
    try
        scaleTranslate.invert();
        scaleTranslate.preConcatenate(CoverageUtilities.CENTER_TO_CORNER);
        final AffineTransform2D tr= new AffineTransform2D(scaleTranslate);
        finalTransform= ConcatenatedTransform.create(tr,sourceCoverage.getGridGeometry().getGridToCRS2D());
    } catch (Exception e) {
                    throw new RuntimeException(e);
                }
   
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

                final double scaleX     = 1 - ((double) sourceBB.width  / (double) actualBB.width);
                final double scaleY     = 1 - ((double) sourceBB.height / (double) actualBB.height);
                final double translateX = sourceBB.x - actualBB.x;
                final double translateY = sourceBB.y - actualBB.y;
                final double factor = (double) step / (double) EMPIRICAL_ADJUSTMENT_STEPS;
                final AffineTransform2D adjustment = new AffineTransform2D(
                        1 - scaleX*factor, 0, 0, 1 - scaleY*factor, translateX*factor, translateY*factor);
                transform = (MathTransform2D) mtFactory.createConcatenatedTransform(allSteps2D, adjustment);
            }
            /*
             * Creates the warp object, trying to optimize to WarpAffine if possible. The transform
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

                CoordinateReferenceSystem layerCRS =
                        layer.getFeatureSource().getSchema().getCoordinateReferenceSystem();

                if (contentCRS != null && layerCRS != null) {
                    if (CRS.equalsIgnoreMetadata(contentCRS, layerCRS)) {
                        transform = new AffineTransform2D(new AffineTransform());
                       
                    } else {
                        try {
                            transform = CRS.findMathTransform(contentCRS, layerCRS, true);
                        } catch (Exception ex) {
                            LOGGER.warning("Can't transform map content CRS to layer CRS");
                            transformFailed = true;
                        }
                    }
                }

            } else {
                // one or both of content and layer CRS is null
                transform = new AffineTransform2D(new AffineTransform());
            }
        }

        return transform;
    }
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

    assertEquals("m01 not equal", baseMatrix[2], 0.0d, DELTA);
    assertEquals("m11 not equal", baseMatrix[3], 3.9788d, DELTASCALE);
    assertEquals("m02 not equal", baseMatrix[4], 0.0d, DELTA);
    assertEquals("m12 not equal", baseMatrix[5], 0.0d, DELTA);
   
    final AffineTransform2D g2wtTransform = granuleOverviewLevelDescriptor.getGridToWorldTransform();
    final double[] g2wMatrix = new double[6];
    g2wtTransform.getMatrix(g2wMatrix);
    assertEquals("m00 not equal", g2wMatrix[0], 0.08276290425318347d, DELTASCALE);
    assertEquals("m10 not equal", g2wMatrix[1], 0.0d, DELTA);
    assertEquals("m01 not equal", g2wMatrix[2], 0.0d, DELTA);
    assertEquals("m11 not equal", g2wMatrix[3], -0.04297444746040424d, DELTASCALE);
    assertEquals("m02 not equal", g2wMatrix[4], 12.139578206197234d, DELTA);
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

    final RasterLayerRequest request = new RasterLayerRequest(new GeneralParameterValue[] {useJai ,tileSize},manager);
   
    final ImageReadParam readParameters = new ImageReadParam();
    readParameters.setSourceRegion(new Rectangle(0,0,50,50));
   
    final AffineTransform2D gridToWorldTransform = granuleOverviewLevelDescriptor.getGridToWorldTransform();
    ImageLayout layout = new ImageLayout2().setTileGridXOffset(0).setTileGridYOffset(0).setTileHeight(10).setTileWidth(10);
    RenderingHints rHints = new RenderingHints(JAI.KEY_IMAGE_LAYOUT, layout);
    Hints hints = new Hints(rHints);
    final RenderedImage raster = granuleDescriptor.loadRaster(readParameters, 0, TEST_BBOX, gridToWorldTransform.inverse(),
            request, hints).getRaster();
    assertEquals(raster.getWidth(), 50);
    assertEquals(raster.getHeight(), 50);
   
    AffineTransform translate = new AffineTransform(gridToWorldTransform);
    translate.preConcatenate(AffineTransform.getTranslateInstance(2, 2));
   
    final RenderedImage translatedRaster = granuleDescriptor.loadRaster(readParameters, 0, TEST_BBOX, new AffineTransform2D(translate).inverse(), request, hints).getRaster();
    assertEquals(translatedRaster.getWidth(), 50);
    assertEquals(translatedRaster.getHeight(), 50);
  }
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

            method.invoke(response);

            Field finalGridToWorldCorner = c.getDeclaredField("finalGridToWorldCorner");
            finalGridToWorldCorner.setAccessible(true);
            MathTransform2D transform = (MathTransform2D) finalGridToWorldCorner.get(response);
            AffineTransform2D affineTransform = (AffineTransform2D) transform;
            assertEquals(18, XAffineTransform.getScaleX0(affineTransform), DELTA);
            assertEquals(18, XAffineTransform.getScaleY0(affineTransform), DELTA);
        } finally {
            if (reader != null) {
                try {
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

        public Level(final double scaleX, final double scaleY, final int width,
                final int height) {
            this.scaleX = scaleX;
            this.scaleY = scaleY;
            this.levelToBaseTransform = new AffineTransform2D(
                    XAffineTransform.getScaleInstance(scaleX, scaleY, 0, 0));

            final AffineTransform gridToWorldTransform_ = new AffineTransform(levelToBaseTransform);
            gridToWorldTransform_.preConcatenate(CoverageUtilities.CENTER_TO_CORNER);
            gridToWorldTransform_.preConcatenate(baseGridToWorld);
            this.gridToWorldTransform = new AffineTransform2D(gridToWorldTransform_);
            this.width = width;
            this.height = height;
            this.rasterDimensions = new Rectangle(0, 0, width, height);
        }
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

            // keep into account overviews and subsampling
            final OverviewLevel level = request.imageManager.overviewsController.resolutionsLevels
                    .get(imageChoice);
            final OverviewLevel baseLevel = request.imageManager.overviewsController.resolutionsLevels.get(0);
            final AffineTransform2D adjustments = new AffineTransform2D(
                    (level.resolutionX / baseLevel.resolutionX)
                            * baseReadParameters.getSourceXSubsampling(), 0, 0,
                    (level.resolutionY / baseLevel.resolutionY)
                            * baseReadParameters.getSourceYSubsampling(), 0, 0);
            g2w.concatenate(adjustments);
            finalGridToWorldCorner = new AffineTransform2D(g2w);
            finalWorldToGridCorner = finalGridToWorldCorner.inverse();
            rasterBounds = new GeneralGridEnvelope(CRS.transform(
                    finalWorldToGridCorner, bbox), PixelInCell.CELL_CORNER,
                    false).toRectangle();

View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

         * @throws Exception
         */
        private void handleGrid(CoverageInfo ci) throws Exception {
          final GridGeometry originalGrid = ci.getGrid();
          final GridEnvelope gridRange=originalGrid.getGridRange();
          final AffineTransform2D gridToCRS = (AffineTransform2D) originalGrid.getGridToCRS();
            final int gridDimension = (gridToCRS != null ? gridToCRS.getSourceDimensions() : 0);

            AttributesImpl attributes = new AttributesImpl();
            attributes.addAttribute("", "dimension", "dimension", "", String.valueOf(gridDimension));

            // RectifiedGrid
            start("gml:RectifiedGrid", attributes);
           
            // Grid Envelope
            String lowers = "";
            String uppers = "";
            for (int r = 0; r < gridDimension; r++) {
                if (gridToCRS.getSourceDimensions() > r) {
                    lowers += (gridRange.getLow(r) + " ");
                    uppers += (gridRange.getHigh(r) + " ");
                } else {
                    lowers += (0 + " ");
                    uppers += (0 + " ");
                }
            }
            start("gml:limits");
                start("gml:GridEnvelope");
                    element("gml:low", lowers.trim());
                    element("gml:high", uppers.trim());
                end("gml:GridEnvelope");
            end("gml:limits");

            // Grid Axes
            for (int dn = 0; dn < ci.getCRS().getCoordinateSystem().getDimension(); dn++) {
                String axisName = ci.getCRS().getCoordinateSystem().getAxis(dn).getAbbreviation();
                axisName = axisName.toLowerCase().startsWith("lon") ? "x" : axisName;
                axisName = axisName.toLowerCase().startsWith("lat") ? "y" : axisName;
                element("gml:axisName", axisName);
            }
  

           
            // Grid Origins
            final StringBuilder origins = new StringBuilder();
            origins.append(gridToCRS.getTranslateX()).append(" ").append(gridToCRS.getTranslateY());
            start("gml:origin");
                element("gml:pos", origins.toString());
            end("gml:origin");
           
            // Grid Offsets
            final StringBuilder offsetX = new StringBuilder();
            offsetX.append(gridToCRS.getScaleX()).append(" ").append(gridToCRS.getShearX());
            element("gml:offsetVector", offsetX.toString());
            final StringBuilder offsetY = new StringBuilder();
            offsetY.append(gridToCRS.getShearY()).append(" ").append(gridToCRS.getScaleY());
            element("gml:offsetVector", offsetY.toString());

            end("gml:RectifiedGrid");
        }
View Full Code Here

Examples of org.geotools.referencing.operation.transform.AffineTransform2D

                                gridCRS.getGridType().equals(GridType.GT2dGridIn2dCrs.getXmlConstant()))
                            offsets = new Double[] { 1.0, 1.0 };
                        else
                            offsets = new Double[] { 1.0, 0.0, 0.0, 0.0, 1.0, 0.0 };
                    } else {
                        AffineTransform2D affine = (AffineTransform2D) gridToCRS;
                        if (gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant()) ||
                                gridCRS.getGridType().equals(GridType.GT2dGridIn2dCrs.getXmlConstant()))
                            offsets = new Double[] { affine.getScaleX(), affine.getScaleY() };
                        else
                            offsets = new Double[] { affine.getScaleX(), affine.getShearX(), affine.getShearY(), affine.getScaleY() };
                    }
                }

                // building the actual transform for the resulting grid geometry
                AffineTransform tx;
                if (gridCRS.getGridType().equals(GridType.GT2dSimpleGrid.getXmlConstant())) {
                    tx = new AffineTransform(
                            offsets[0], 0,
                            0, offsets[1],
                            origin[0], origin[1]
                    );
                } else if(gridCRS.getGridType().equals(GridType.GT2dGridIn2dCrs.getXmlConstant())) {
                    tx = new AffineTransform(
                            offsets[0], offsets[1],
                            offsets[2], offsets[3],
                            origin[0], origin[1]
                    );
                } else {
                    tx = new AffineTransform(
                            offsets[0], offsets[4],
                            offsets[1], offsets[3],
                            origin[0], origin[1]
                    );
                   
                    if (origin.length != 3 || offsets.length != 6)
                        throw new WcsException("", InvalidParameterValue, "GridCRS");
             
                    //
                    //  ELEVATIONS
                    //
                   
                    // TODO: draft code ... it needs more study!
                    elevationLevels = (int) Math.round(requestedEnvelope.getUpperCorner().getOrdinate(2) - requestedEnvelope.getLowerCorner().getOrdinate(2));

                    // compute the elevation levels, we have elevationLevels values
                    if (elevationLevels > 0) {
                        elevations=new double[elevationLevels];

                        elevations[0]=requestedEnvelope.getLowerCorner().getOrdinate(2); // TODO put the extrema
                        elevations[elevationLevels-1]=requestedEnvelope.getUpperCorner().getOrdinate(2);
                        if(elevationLevels>2){
                            final int adjustedLevelsNum=elevationLevels-1;
                            double step = (elevations[elevationLevels-1]-elevations[0])/adjustedLevelsNum;
                            for(int i=1;i<adjustedLevelsNum;i++)
                                elevations[i]=elevations[i-1]+step;
                        }
                    }
                }
                gridToCRS = new AffineTransform2D(tx);
            }
           
            //
            //   TIME Values
            //
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. 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.