/** Returns the inverse of this math transform. */ public MathTransform inverse() throws NoninvertibleTransformException { return transform.inverse(); }
/** Creates the inverse transform of this object. */ @Override public synchronized MathTransform inverse() throws NoninvertibleTransformException { if (inverse == null) { inverse = new PassThroughTransform( firstAffectedOrdinate, subTransform.inverse(), numTrailingOrdinates); inverse.inverse = this; } return inverse; }
/** Creates the inverse transform of this object. */ @Override public synchronized MathTransform inverse() throws NoninvertibleTransformException { assert isValid(); if (inverse == null) { inverse = createConcatenatedTransform(transform2.inverse(), transform1.inverse()); inverse.inverse = this; } return inverse; }
public MathTransform inverse() throws NoninvertibleTransformException { MathTransform inverse = delegate.inverse(); if (inverse instanceof GeographicOffsetWrapper) { return inverse; } else { return new GeographicOffsetWrapper(inverse); } }
MathTransform crsToGrid = meta.getGrid().getGridToCRS().inverse(); GeneralEnvelope requestedGrid = CRS.transform(crsToGrid, requestedEnvelope); double[] spans = new double[requestedGrid.getDimension()];
/** @throws org.opengis.referencing.operation.NoninvertibleTransformException */ private Decimator getDecimator(MathTransform mathTransform) { // returns a decimator that does nothing if the currently set generalization // distance is zero (no generalization desired) or if the datastore has // already done full generalization at the desired level if (generalizationDistance == 0 || !inMemoryGeneralization) return NULL_DECIMATOR; Decimator decimator = (Decimator) decimators.get(mathTransform); if (decimator == null) { try { if (mathTransform != null && !mathTransform.isIdentity()) decimator = new Decimator( mathTransform.inverse(), screenSize, generalizationDistance); else decimator = new Decimator(null, screenSize, generalizationDistance); } catch (org.opengis.referencing.operation.NoninvertibleTransformException e) { decimator = new Decimator(null, screenSize, generalizationDistance); } decimators.put(mathTransform, decimator); } return decimator; } }
/** * Format the inner part of a <A * HREF="http://geoapi.sourceforge.net/snapshot/javadoc/org/opengis/referencing/doc-files/WKT.html"><cite>Well * Known Text</cite> (WKT)</A> element. * * @param formatter The formatter to use. * @return The name of the WKT element type, which is {@code "FITTED_CS"}. */ @Override protected String formatWKT(final Formatter formatter) { MathTransform inverse = conversionFromBase.getMathTransform(); try { inverse = inverse.inverse(); } catch (NoninvertibleTransformException exception) { // TODO: provide a more accurate error message. throw new IllegalStateException(exception.getLocalizedMessage(), exception); } formatter.append(inverse); formatter.append(baseCRS); return "FITTED_CS"; } }
/** * Return a crop region from a specified envelope, leveraging on the grid to world * transformation. * * @param refinedRequestedBBox the crop envelope * @return a {@code Rectangle} representing the crop region. * @throws TransformException in case a problem occurs when going back to raster space. */ private Rectangle getCropRegion() throws TransformException { final MathTransform gridToWorldTransform = getOriginalGridToWorld(PixelInCell.CELL_CORNER); final MathTransform worldToGridTransform = gridToWorldTransform.inverse(); final GeneralEnvelope rasterArea = CRS.transform(worldToGridTransform, requestedBBox); final Rectangle2D ordinates = rasterArea.toRectangle2D(); // THIS IS FUNDAMENTAL IN ORDER TO AVOID PROBLEMS WHEN DOING TILING return ordinates.getBounds(); }
/** * Returns a new point with the same coordinates than this one, but transformed in the given * CRS. This method never returns {@code this}, so the returned point usually doesn't need to be * cloned. * * @param crs The CRS for the position to be returned. * @return The same position than {@code this}, but transformed in the specified CRS. * @throws TransformException if a coordinate transformation was required and failed. * @since 2.3 */ public DirectPosition inverseTransform(final CoordinateReferenceSystem crs) throws TransformException { if (inverse == null || !CRS.equalsIgnoreMetadata(sourceCRS, crs)) { ensureNonNull("crs", crs); setSourceCRS(crs); inverse = forward.inverse(); } return inverse.transform(this, null); }
private Rectangle createQueryGridEnvelope(DirectPosition pos) { final GridCoverage2DReader reader = sourceRef.get(); try { MathTransform worldToGridTransform = reader.getOriginalGridToWorld(PixelInCell.CELL_CORNER).inverse(); DirectPosition midPos = worldToGridTransform.transform(pos, null); int x = (int) midPos.getOrdinate(0); int y = (int) midPos.getOrdinate(1); int halfWidth = CACHED_RASTER_WIDTH / 2; final Rectangle queryRect = new Rectangle( x - halfWidth, y - halfWidth, CACHED_RASTER_WIDTH, CACHED_RASTER_WIDTH); GridEnvelope gridEnv = reader.getOriginalGridRange(); Rectangle rect = new Rectangle( gridEnv.getLow(0), gridEnv.getLow(1), gridEnv.getSpan(0), gridEnv.getSpan(1)); XRectangle2D.intersect(queryRect, rect, queryRect); return queryRect; } catch (Exception ex) { throw new RuntimeException(ex); } } }
private static void expandEnvelopeByLongitude( double longitude, DirectPosition input, GeneralEnvelope transformed, CoordinateReferenceSystem sourceCRS) { try { MathTransform mt = findMathTransform(sourceCRS, DefaultGeographicCRS.WGS84); DirectPosition2D pos = new DirectPosition2D(sourceCRS); mt.transform(input, pos); pos.setOrdinate(0, longitude); mt.inverse().transform(pos, pos); transformed.add(pos); } catch (Exception e) { LOGGER.log( Level.FINER, "Tried to expand target envelope to include longitude " + longitude + " but failed. This is not necesseraly and issue, " + "this is a best effort attempt to handle the polar stereographic " + "pole singularity during reprojection", e); } }
@BeforeClass public static void setupClass() throws FactoryException, TransformException { sphericalGeosCRS = CRS.parseWKT(sphericalGeosWKT); sphericalGeosToGeog = CRS.findMathTransform( sphericalGeosCRS, CRS.getProjectedCRS(sphericalGeosCRS).getBaseCRS(), true); geogToSphericalGeos = sphericalGeosToGeog.inverse(); ellipsoidalGeosCRS = CRS.parseWKT(ellipsoidalGeosWKT); ellipsoidalGeosToGeog = CRS.findMathTransform( ellipsoidalGeosCRS, CRS.getProjectedCRS(ellipsoidalGeosCRS).getBaseCRS(), true); geogToEllipsoidalGeos = ellipsoidalGeosToGeog.inverse(); }
/** * Helper method to test transform from a source to a target point. Coordinate points are (x,y) * or (long, lat) */ private static void doTransform( DirectPosition source, DirectPosition target, MathTransform transform, final double[] tolerance) throws TransformException { DirectPosition calculated; calculated = transform.transform(source, null); assertPositionEquals(target, calculated, tolerance); // The inverse target = source; source = calculated; calculated = transform.inverse().transform(source, null); assertPositionEquals(target, calculated, TOL_DEG); }
/** * Tests similarity transform on the example provided in the EPSG projection guide, page 99 * * @throws Exception */ public void testSimilarityTransform() throws Exception { // Tombak LNG Plant CoordinateReferenceSystem tombak = CRS.decode("EPSG:5817", true); // Nakhl-e Ghanem / UTM zone 39N CoordinateReferenceSystem ng39 = CRS.decode("EPSG:3307", true); // forward double[] src = new double[] {20000, 10000}; double[] dst = new double[2]; MathTransform mt = CRS.findMathTransform(tombak, ng39); mt.transform(src, 0, dst, 0, 1); assertEquals(618336.748, dst[0], 0.001); assertEquals(3067774.210, dst[1], 0.001); // and back mt.inverse().transform(dst, 0, src, 0, 1); assertEquals(20000, src[0], 0.001); assertEquals(10000, src[1], 0.001); }
@Test public void testInvertible() throws NoninvertibleTransformException { final GeneralMatrix matrix = new GeneralMatrix(3); matrix.setElement(0, 1, -1); matrix.setElement(1, 0, 1); final MathTransform transform = new ProjectiveTransform2D(matrix); Assert.assertNotNull(transform.inverse()); } }
@Test public void testUTMDatelineWrapping() throws Exception { CoordinateReferenceSystem crs = CRS.decode("EPSG:32601", true); ReferencedEnvelope re = new ReferencedEnvelope(300000, 409800, 5890200, 6000000, crs); MathTransform mt = CRS.findMathTransform(crs, WGS84); Geometry geom = JTS.toGeometry(re); ReferencedEnvelope targetReferenceEnvelope = new ReferencedEnvelope(-180, 180, -90, 90, WGS84); ProjectionHandler ph = ProjectionHandlerFinder.getHandler(targetReferenceEnvelope, crs, true); Geometry preProcessed = ph.preProcess(geom); Geometry transformed = JTS.transform(preProcessed, mt); Geometry postProcessed = ph.postProcess(mt.inverse(), transformed); // sits across the dateline and it's "small" (used to cover the entire planet) Envelope ppEnvelope = postProcessed.getGeometryN(0).getEnvelopeInternal(); assertTrue(ppEnvelope.contains(180, 54)); // the original width is 109km, at this latitude one degree of longitude is only 65km assertEquals(1.7, ppEnvelope.getWidth(), 0.1); }
@Test public void testWrapGeometrySmall() throws Exception { // projected dateline CRS CoordinateReferenceSystem FIJI = CRS.decode("EPSG:3460", true); // a small geometry that will cross the dateline Geometry g = new WKTReader() .read( "POLYGON ((2139122 5880020, 2139122 5880030, 2139922 5880030, 2139122 5880020))"); Geometry original = g.copy(); // rendering bounds only slightly bigger than geometry ReferencedEnvelope world = new ReferencedEnvelope(178, 181, -1, 1, WGS84); // make sure the geometry is not wrapped, but it is preserved ProjectionHandler handler = ProjectionHandlerFinder.getHandler(world, FIJI, true); assertTrue(handler.requiresProcessing(g)); Geometry preProcessed = handler.preProcess(g); // no cutting expected assertEquals(original, preProcessed); // post process MathTransform mt = CRS.findMathTransform(FIJI, WGS84); Geometry transformed = JTS.transform(g, mt); Geometry postProcessed = handler.postProcess(mt.inverse(), transformed); // check the geometry is in the same area as the rendering envelope assertTrue(world.contains(postProcessed.getEnvelopeInternal())); }
/** Tests a transformation on a {@link DirectPosition} object. */ @Test public void testDirectPositionTransform() throws FactoryException, TransformException { CoordinateReferenceSystem crs = ReferencingFactoryFinder.getCRSFactory(null).createFromWKT(WKT.UTM_10N); MathTransform t = ReferencingFactoryFinder.getCoordinateOperationFactory(null) .createOperation(DefaultGeographicCRS.WGS84, crs) .getMathTransform(); DirectPosition position = new GeneralDirectPosition(-123, 55); position = t.transform(position, position); position = t.inverse().transform(position, position); assertEquals(-123, position.getOrdinate(0), 1E-6); assertEquals(55, position.getOrdinate(1), 1E-6); }
/** Tests the transformations of an envelope. */ @Test public void testEnvelopeTransformation() throws FactoryException, TransformException { final CoordinateReferenceSystem mapCRS = CRS.parseWKT(WKT.UTM_10N); final CoordinateReferenceSystem WGS84 = DefaultGeographicCRS.WGS84; final MathTransform crsTransform = CRS.findMathTransform(WGS84, mapCRS, true); assertFalse(crsTransform.isIdentity()); final GeneralEnvelope firstEnvelope, transformedEnvelope, oldEnvelope; firstEnvelope = new GeneralEnvelope(new double[] {-124, 42}, new double[] {-122, 43}); firstEnvelope.setCoordinateReferenceSystem(WGS84); transformedEnvelope = CRS.transform(crsTransform, firstEnvelope); transformedEnvelope.setCoordinateReferenceSystem(mapCRS); oldEnvelope = CRS.transform(crsTransform.inverse(), transformedEnvelope); oldEnvelope.setCoordinateReferenceSystem(WGS84); assertTrue(oldEnvelope.contains(firstEnvelope, true)); assertTrue(oldEnvelope.equals(firstEnvelope, 0.02, true)); }
@Test public void testWrapGeometryMercator() throws Exception { ReferencedEnvelope world = new ReferencedEnvelope(160, 180, -40, 40, WGS84); ReferencedEnvelope mercatorEnvelope = world.transform(MERCATOR, true); // move it so that it crosses the dateline (measures are still accurate for something // crossing the dateline mercatorEnvelope.translate(mercatorEnvelope.getWidth() / 2, 0); // a geometry that will cross the dateline and sitting in the same area as the // rendering envelope Geometry g = new WKTReader().read("LINESTRING(170 -40, 190 40)"); // make sure the geometry is not wrapped ProjectionHandler handler = ProjectionHandlerFinder.getHandler(mercatorEnvelope, WGS84, true); assertTrue(handler.requiresProcessing(g)); Geometry preProcessed = handler.preProcess(g); // no cutting expected assertEquals(g, preProcessed); // transform and post process MathTransform mt = CRS.findMathTransform(WGS84, MERCATOR, true); Geometry transformed = JTS.transform(g, mt); Geometry postProcessed = handler.postProcess(mt.inverse(), transformed); Envelope env = postProcessed.getEnvelopeInternal(); // check the geometry is in the same area as the rendering envelope assertEquals(mercatorEnvelope.getMinX(), env.getMinX(), EPS); assertEquals(mercatorEnvelope.getMaxX(), env.getMaxX(), EPS); }