/** Should fails unless GEOT-352 has been fixed. */ @Test(expected = OperationNotFoundException.class) public void testHtoH() throws Exception { final CoordinateReferenceSystem sourceCRS = crsFactory.createFromWKT(NAD27_H); final CoordinateReferenceSystem targetCRS = crsFactory.createFromWKT(WGS84_H); final CoordinateOperation op = opFactory.createOperation(sourceCRS, targetCRS); final MathTransform mt = op.getMathTransform(); assertNotSame(sourceCRS, op.getSourceCRS()); assertNotSame(targetCRS, op.getTargetCRS()); assertFalse(mt.isIdentity()); assertInterfaced(mt); }
crs = factory.createGeographicCRS(properties, datum, cs); final Map<String, Object> properties = createProperties(name, epsg, area, scope, remarks); crs = factory.createProjectedCRS(properties, baseCRS, (Conversion) op, cs); } else { throw noSuchAuthorityCode(Projection.class, opCode); final Map<String, Object> properties = createProperties(name, epsg, area, scope, remarks); crs = factory.createVerticalCRS(properties, datum, cs); createProperties(name, epsg, area, scope, remarks); crs = factory.createCompoundCRS( properties, new CoordinateReferenceSystem[] {crs1, crs2}); createProperties(name, epsg, area, scope, remarks); if (cs instanceof CartesianCS) { crs = factory.createGeocentricCRS(properties, datum, (CartesianCS) cs); } else if (cs instanceof SphericalCS) { crs = factory.createGeocentricCRS(properties, datum, (SphericalCS) cs); } else { result.close(); final Map<String, Object> properties = createProperties(name, epsg, area, scope, remarks); crs = factory.createEngineeringCRS(properties, datum, cs);
if (crs instanceof ProjectedCRS) { modified = crsFactory.createProjectedCRS( properties, (GeographicCRS) baseCRS, fromBase, (CartesianCS) cs); } else { if (crs instanceof GeographicCRS) { modified = crsFactory.createGeographicCRS( properties, (GeodeticDatum) datum, (EllipsoidalCS) cs); } else if (crs instanceof GeocentricCRS) { final GeodeticDatum gd = (GeodeticDatum) datum; if (cs instanceof CartesianCS) { modified = crsFactory.createGeocentricCRS(properties, gd, (CartesianCS) cs); } else { modified = crsFactory.createGeocentricCRS(properties, gd, (SphericalCS) cs); crsFactory.createVerticalCRS( properties, (VerticalDatum) datum, (VerticalCS) cs); } else if (crs instanceof TemporalCRS) { modified = crsFactory.createTemporalCRS( properties, (TemporalDatum) datum, (TimeCS) cs); } else if (crs instanceof ImageCRS) { modified = crsFactory.createImageCRS(properties, (ImageDatum) datum, (AffineCS) cs); } else if (crs instanceof EngineeringCRS) { modified = crsFactory.createEngineeringCRS(properties, (EngineeringDatum) datum, cs); } else if (crs instanceof CompoundCRS) {
/** 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 transformation of a single coordinate. */ @Test public void testTransformCoordinate() throws FactoryException, TransformException { Coordinate coord = new Coordinate(10, 10); AffineTransform at = AffineTransform.getScaleInstance(0.5, 1); MathTransform2D t = (MathTransform2D) ReferencingFactoryFinder.getMathTransformFactory(null) .createAffineTransform(new GeneralMatrix(at)); coord = JTS.transform(coord, coord, t); assertEquals(new Coordinate(5, 10), coord); coord = JTS.transform(coord, coord, t.inverse()); assertEquals(new Coordinate(10, 10), coord); CoordinateReferenceSystem crs = ReferencingFactoryFinder.getCRSFactory(null).createFromWKT(UTM_ZONE_10N); t = (MathTransform2D) ReferencingFactoryFinder.getCoordinateOperationFactory(null) .createOperation(DefaultGeographicCRS.WGS84, crs) .getMathTransform(); coord = new Coordinate(-123, 55); coord = JTS.transform(coord, coord, t); coord = JTS.transform(coord, coord, t.inverse()); assertEquals(-123, coord.x, EPS); assertEquals(55, coord.y, EPS); }
public void testDatumShift7Param() throws Exception { final CoordinateReferenceSystem sourceCRS = DefaultGeographicCRS.WGS84; final CoordinateReferenceSystem targetCRS = crsFactory.createFromWKT(WKT.UTM_58S); CoordinateOperation operation = opFactory.createOperation(sourceCRS, targetCRS); if (usingDefaultFactory) { assertSame(sourceCRS, operation.getSourceCRS()); assertSame(targetCRS, operation.getTargetCRS()); assertTrue( operation .getCoordinateOperationAccuracy() .contains(PositionalAccuracyImpl.DATUM_SHIFT_APPLIED)); assertFalse( ReferencingFactoryFinder.getCoordinateOperationFactory(hints); assertNotSame(opFactory, lenientFactory); operation = lenientFactory.createOperation(sourceCRS, targetCRS); if (usingDefaultFactory) { assertSame(sourceCRS, operation.getSourceCRS());
/** * A datum identical to the specified datum except for the prime meridian, which is replaced by * Greenwich. This datum is processed in a special way by {@link #equalsIgnorePrimeMeridian}. */ private static final class TemporaryDatum extends DefaultGeodeticDatum { /** For cros-version compatibility. */ private static final long serialVersionUID = -8964199103509187219L; /** The wrapped datum. */ private final GeodeticDatum datum; /** Wrap the specified datum. */ public TemporaryDatum(final GeodeticDatum datum) { super(getTemporaryName(datum), datum.getEllipsoid(), DefaultPrimeMeridian.GREENWICH); this.datum = datum; } /** Unwrap the datum. */ public static GeodeticDatum unwrap(GeodeticDatum datum) { while (datum instanceof TemporaryDatum) { datum = ((TemporaryDatum) datum).datum; } return datum; } /** Compares this datum with the specified object for equality. */ @Override public boolean equals( final AbstractIdentifiedObject object, final boolean compareMetadata) { if (super.equals(object, compareMetadata)) {
csFactory.createCartesianCS(name("Rendered Cartesian CS"), x_axis, z_axis, y_axis); final GeocentricCRS output_crs = crsFactory.createGeocentricCRS(name("Output Cartesian CRS"), wgs84, world_cs); name("3D ellipsoidal"), longitude_axis, latitude_axis, height_axis); final GeographicCRS geographic_2d_crs = crsFactory.createGeographicCRS(name("2D geographic CRS"), wgs84, ellipsoidal_2d_cs); final GeographicCRS geographic_3d_crs = crsFactory.createGeographicCRS(name("3D geographic CRS"), wgs84, ellipsoidal_3d_cs); final VerticalCS utm_height_cs = csFactory.createVerticalCS(name("Height CS"), height_axis); final VerticalCRS height_crs = crsFactory.createVerticalCRS(name("WGS84 Height CRS"), wgs84_height, utm_height_cs); crsFactory.createProjectedCRS( name("WGS 84 / UTM Zone 12/ 2D"), geographic_2d_crs, utm_cartesian_2d_cs); final CompoundCRS compound_3d = crsFactory.createCompoundCRS( name("3D Compound WGS 84 / UTM Zone 12"), new CoordinateReferenceSystem[] {proj_2d, height_crs}); final double[] out1 = checkTransformation(opFactory.createOperation(compound_3d, output_crs)); crsFactory.createProjectedCRS( name("WGS 84 / UTM Zone 12/ 3D"), geographic_3d_crs,
crs = crsFactory.createGeographicCRS(createProperties("Coordinate Reference System", name, epsg, area, scope, remarks, deprecated), datum, cs); break; name, epsg, area, scope, remarks, deprecated); if (baseCRS instanceof GeographicCRS) { crs = crsFactory.createProjectedCRS(properties, (GeographicCRS) baseCRS, op, cs); } else { crs = crsFactory.createDerivedCRS(properties, baseCRS, op, cs); final VerticalCS cs = owner.createVerticalCS (getString(code, result, 8)); final VerticalDatum datum = owner.createVerticalDatum(getString(code, result, 9)); crs = crsFactory.createVerticalCRS(createProperties("Coordinate Reference System", name, epsg, area, scope, remarks, deprecated), datum, cs); break; final TimeCS cs = owner.createTimeCS (getString(code, result, 8)); final TemporalDatum datum = owner.createTemporalDatum(getString(code, result, 9)); crs = crsFactory.createTemporalCRS(createProperties("Coordinate Reference System", name, epsg, area, scope, remarks, deprecated), datum, cs); break; crs = crsFactory.createCompoundCRS(createProperties("Coordinate Reference System", name, epsg, area, scope, remarks, deprecated), crs1, crs2); break; name, epsg, area, scope, remarks, deprecated); if (cs instanceof CartesianCS) { crs = crsFactory.createGeocentricCRS(properties, datum, (CartesianCS) cs);
public void testFindOperations() throws Exception { final CoordinateReferenceSystem targetCRS = DefaultGeographicCRS.WGS84; final CoordinateReferenceSystem sourceCRS = crsFactory.createFromWKT(WKT.NAD83); final CoordinateReferenceSystem sourceCRS2 = crsFactory.createFromWKT( "PROJCS[\"ED50 / UTM zone 30N\",GEOGCS[\"ED50\",DATUM[\"European Datum 1950\",SPHEROID[\"International 1924\",6378388.0,297.0,AUTHORITY[\"EPSG\",\"7022\"]],TOWGS84[-116.641,-56.931,-110.559,0.893,0.921,-0.917,-3.52],AUTHORITY[\"EPSG\",\"6230\"]],PRIMEM[\"Greenwich\",0.0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.017453292519943295],AXIS[\"Geodetic latitude\",NORTH],AXIS[\"Geodetic longitude\",EAST],AUTHORITY[\"EPSG\",\"4230\"]],PROJECTION[\"Transverse_Mercator\",AUTHORITY[\"EPSG\",\"9807\"]],PARAMETER[\"central_meridian\",-3.0],PARAMETER[\"latitude_of_origin\",0.0],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000.0],PARAMETER[\"false_northing\",0.0],UNIT[\"m\",1.0],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"23030\"]]"); Set<CoordinateOperation> operations = opFactory.findOperations(sourceCRS, targetCRS); int size = operations.size(); assertSame(sourceCRS, operation.getSourceCRS()); assertSame(targetCRS, operation.getTargetCRS()); final MathTransform transform = operation.getMathTransform(); assertInterfaced(transform); operations = opFactory.findOperations(targetCRS, sourceCRS); assertEquals(size, operations.size());
CoordinateReferenceSystem createCrs(String crsName, OperationMethod method, ParameterValueGroup parameters, GeodeticDatum datum) throws FactoryException { final CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null); final CoordinateOperationFactory coFactory = ReferencingFactoryFinder.getCoordinateOperationFactory(null); final HashMap<String, Object> projProperties = new HashMap<String, Object>(); projProperties.put("name", crsName + " / " + datum.getName().getCode()); final Conversion conversion = coFactory.createDefiningConversion(projProperties, method, parameters); final HashMap<String, Object> baseCrsProperties = new HashMap<String, Object>(); baseCrsProperties.put("name", datum.getName().getCode()); final GeographicCRS baseCrs = crsFactory.createGeographicCRS(baseCrsProperties, datum, DefaultEllipsoidalCS.GEODETIC_2D); return crsFactory.createProjectedCRS(projProperties, baseCrs, conversion, DefaultCartesianCS.PROJECTED); } }
@Override public CoordinateReferenceSystem getCRS(final GeoPos referencePos, ParameterValueGroup parameters, GeodeticDatum datum) throws FactoryException { final CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null); // in some cases, depending on the parameters set, the effective transformation can be different // from the transformation given by the OperationMethod. // So we create a new one final MathTransformFactory mtFactory = ReferencingFactoryFinder.getMathTransformFactory(null); final MathTransform transform = mtFactory.createParameterizedTransform(parameters); final DefaultOperationMethod operationMethod = new DefaultOperationMethod(transform); final Conversion conversion = new DefiningConversion(AbstractIdentifiedObject.getProperties(operationMethod), operationMethod, transform); final HashMap<String, Object> baseCrsProperties = new HashMap<String, Object>(); baseCrsProperties.put("name", datum.getName().getCode()); GeographicCRS baseCrs = crsFactory.createGeographicCRS(baseCrsProperties, datum, DefaultEllipsoidalCS.GEODETIC_2D); final HashMap<String, Object> projProperties = new HashMap<String, Object>(); projProperties.put("name", conversion.getName().getCode() + " / " + datum.getName().getCode()); return crsFactory.createProjectedCRS(projProperties, baseCrs, conversion, DefaultCartesianCS.PROJECTED); } }
out.println(); out.println("create Coodinate Reference System....1: "); final DatumFactory datumFactory = ReferencingFactoryFinder.getDatumFactory(null); final CSFactory csFactory = ReferencingFactoryFinder.getCSFactory(null); final CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null); final MathTransformFactory mtFactory = ReferencingFactoryFinder.getMathTransformFactory(null); geogCRS = crsFactory.createGeographicCRS(name("Airy1830"), datum, ellCS); out.println(); out.println("create Coodinate Reference System....6: "); crsFactory.createProjectedCRS( name("Great_Britian_National_Grid"), geogCRS, conversion, cartCS); out.println();
/** * Parses a <A * HREF="http://geoapi.sourceforge.net/snapshot/javadoc/org/opengis/referencing/doc-files/WKT.html"><cite>Well * Known Text</cite></A> (WKT) into a CRS object. This convenience method is a shorthand for the * following: * * <blockquote> * * <code> * FactoryFinder.{@linkplain ReferencingFactoryFinder#getCRSFactory getCRSFactory}(null).{@linkplain * org.opengis.referencing.crs.CRSFactory#createFromWKT createFromWKT}(wkt); * </code> * * </blockquote> */ public static CoordinateReferenceSystem parseWKT(final String wkt) throws FactoryException { return ReferencingFactoryFinder.getCRSFactory(null).createFromWKT(wkt); }
/** Tests transformation between incompatible vertical CRS. */ @Test(expected = OperationNotFoundException.class) public void testIncompatibleVertical() throws Exception { final CoordinateReferenceSystem sourceCRS = crsFactory.createFromWKT(WKT.Z); final CoordinateReferenceSystem targetCRS = crsFactory.createFromWKT(WKT.HEIGHT); final CoordinateOperation op = opFactory.createOperation(sourceCRS, targetCRS); assertNull(op); // We should not reach this point. }
try { targetCRS = ReferencingFactoryFinder.getCRSFactory(hints) .createCompoundCRS( Collections.singletonMap( IdentifiedObject.NAME_KEY, final int sourceDim = toSource.getSourceDimensions(); if (upperDim - lowerDim != toSource2D.getSourceDimensions()) { ReferencingFactoryFinder.getMathTransformFactory(hints); final DimensionFilter filter = new DimensionFilter(factory); toTarget = gridToCrs2D;
initialize(CS | CRS); cs = csFactory.createEllipsoidalCS(csProps, axes[0], axes[1], axes[2]); crs = crsFactory.createGeographicCRS(crsProps, ((GeodeticCRS) crs).getDatum(), (EllipsoidalCS) cs); } else { initialize(CS | CRS | OPERATION); fromBase = opFactory.createDefiningConversion(referencing.getProperties(fromBase, true), fromBase.getMethod(), fromBase.getParameterValues()); cs = csFactory.createCartesianCS(csProps, axes[0], axes[1], axes[2]); crs = crsFactory.createProjectedCRS(crsProps, base, fromBase, (CartesianCS) cs); case 0: return null; case 1: return components[0]; default: initialize(CRS); return crsFactory.createCompoundCRS(properties, components);
baseCRS = crsFactory.createGeographicCRS(name("2D geographic CRS"), baseDatum, baseCS); heightCRS = crsFactory.createVerticalCRS (name("Height CRS"), heightDatum, heightCS); validators.validate(projectionMethod = copFactory.getOperationMethod("Transverse_Mercator")); final ParameterValueGroup paramUTM = projectionMethod.getParameters().createValue(); paramUTM.parameter("central_meridian") .setValue(-180 + utmZone*6 - 3); validators.validate(paramUTM); validators.validate(baseToUTM = copFactory .createDefiningConversion(name("Transverse_Mercator"), projectionMethod, paramUTM)); validators.validate(projectedCRS = crsFactory.createProjectedCRS(name("WGS 84 / UTM Zone 12 (2D)"), baseCRS, baseToUTM, projectedCS)); validators.validate(crs3D = crsFactory.createCompoundCRS(name("3D Compound WGS 84 / UTM Zone 12"), projectedCRS, heightCRS)); assertAxisDirectionsEqual("CompoundCRS", crs3D.getCoordinateSystem(), NORTH, EAST, UP);
out.println("Testing classification names"); out.println("----------------------------"); final CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null); final MathTransformFactory mtFactory = ReferencingFactoryFinder.getMathTransformFactory(null); final Collection<OperationMethod> methods = mtFactory.getAvailableMethods(Projection.class); final Map<String, ?> dummyName = Collections.singletonMap("name", "Test"); crsFactory.createProjectedCRS( dummyName, DefaultGeographicCRS.WGS84,
switch (type) { case GEOGRAPHIC: { return crsFactory.createGeographicCRS(name, createDatum(pj, parser), withHeight ? csFactory.createEllipsoidalCS(csName, axes[0], axes[1], axes[2]) : csFactory.createEllipsoidalCS(csName, axes[0], axes[1])); return crsFactory.createGeocentricCRS(name, createDatum(pj, parser), csFactory.createCartesianCS(csName, axes[0], axes[1], axes[2])); return crsFactory.createProjectedCRS(name, (GeographicCRS) baseCRS, fromBase, withHeight ? csFactory.createCartesianCS(csName, axes[0], axes[1], axes[2]) : csFactory.createCartesianCS(csName, axes[0], axes[1]));