## org.opengis.referencing.crs
Interface CRSFactory

All Superinterfaces:
  Factory, ObjectFactory

    @UML(identifier="CS_CoordinateSystemFactory",
         specification=OGC_01009)
    public interface CRSFactory

extends ObjectFactory

Builds up complex coordinate reference systems from simpler objects or values. `CRSFactory` allows applications to make coordinate reference systems that cannot be created by a `CRSAuthorityFactory`. This factory is very flexible, whereas the authority factory is easier to use. So `CRSAuthorityFactory` can be used to make "standard" coordinate reference systems, and `CRSFactory` can be used to make "special" coordinate reference systems. For example, the EPSG authority has codes for USA state plane coordinate systems using the NAD83 datum, but these coordinate systems always use meters. EPSG does not have codes for NAD83 state plane coordinate systems that use feet units. This factory lets an application create such a hybrid coordinate system.

Since:
  GeoAPI 1.0
Version:
  Implementation specification 1.0
See Also:
  `CSFactory`, `DatumFactory`

Method Summary
`CompoundCRS` `createCompoundCRS(Map<String,?> properties, CoordinateReferenceSystem[] elements)` Creates a compound coordinate reference system from an ordered list of `CoordinateReferenceSystem` objects.
`DerivedCRS` `createDerivedCRS(Map<String,?> properties, CoordinateReferenceSystem baseCRS, Conversion conversionFromBase, CoordinateSystem derivedCS)` Creates a derived coordinate reference system.

`DerivedCRS`

`createDerivedCRS(Map<String,?> properties, OperationMethod method, CoordinateReferenceSystem base, MathTransform baseToDerived, CoordinateSystem derivedCS)`
Deprecated. Use `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)` followed by `createDerivedCRS(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.referencing.crs.CoordinateReferenceSystem, org.opengis.referencing.operation.MathTransform, org.opengis.referencing.cs.CoordinateSystem)` instead.

`EngineeringCRS` `createEngineeringCRS(Map<String,?> properties, EngineeringDatum datum, CoordinateSystem cs)` Creates a engineering coordinate reference system.
`CoordinateReferenceSystem` `createFromWKT(String wkt)` Creates a coordinate reference system object from a string.
`CoordinateReferenceSystem` `createFromXML(String xml)` Creates a coordinate reference system object from a XML string.
`GeocentricCRS` `createGeocentricCRS(Map<String,?> properties, GeodeticDatum datum, CartesianCS cs)` Creates a geocentric coordinate reference system from a cartesian coordinate system.
`GeocentricCRS` `createGeocentricCRS(Map<String,?> properties, GeodeticDatum datum, SphericalCS cs)` Creates a geocentric coordinate reference system from a spherical coordinate system.
`GeographicCRS` `createGeographicCRS(Map<String,?> properties, GeodeticDatum datum, EllipsoidalCS cs)` Creates a geographic coordinate reference system.
`ImageCRS` `createImageCRS(Map<String,?> properties, ImageDatum datum, AffineCS cs)` Creates an image coordinate reference system.
`ProjectedCRS` `createProjectedCRS(Map<String,?> properties, GeographicCRS baseCRS, Conversion conversionFromBase, CartesianCS derivedCS)` Creates a projected coordinate reference system from a defining conversion.

`ProjectedCRS`

`createProjectedCRS(Map<String,?> properties, OperationMethod method, GeographicCRS base, MathTransform baseToDerived, CartesianCS derivedCS)`
Deprecated. Use `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)` followed by `createProjectedCRS(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.referencing.crs.GeographicCRS, org.opengis.referencing.operation.MathTransform, org.opengis.referencing.cs.CartesianCS)` instead.

`TemporalCRS` `createTemporalCRS(Map<String,?> properties, TemporalDatum datum, TimeCS cs)` Creates a temporal coordinate reference system.
`VerticalCRS` `createVerticalCRS(Map<String,?> properties, VerticalDatum datum, VerticalCS cs)` Creates a vertical coordinate reference system.

Methods inherited from interface Factory
`getVendor`

Method Detail

### createCompoundCRS

    @UML(identifier="createCompoundCoordinateSystem",
         specification=OGC_01009)
    CompoundCRS createCompoundCRS(Map<String,?> properties,
                                                                      CoordinateReferenceSystem[] elements)
                                  throws FactoryException

  Creates a compound coordinate reference system from an ordered list of `CoordinateReferenceSystem` objects.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `elements` - ordered array of `CoordinateReferenceSystem` objects.
  Throws:
    `FactoryException` - if the object creation failed.

### createEngineeringCRS

    @UML(identifier="createLocalCoordinateSystem",
         specification=OGC_01009)
    EngineeringCRS createEngineeringCRS(Map<String,?> properties,
                                                                            EngineeringDatum datum,
                                                                            CoordinateSystem cs)
                                        throws FactoryException

  Creates a engineering coordinate reference system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Engineering datum to use in created CRS.
    `cs` - The coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createImageCRS

    ImageCRS createImageCRS(Map<String,?> properties,
                            ImageDatum datum,
                            AffineCS cs)
                            throws FactoryException

  Creates an image coordinate reference system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Image datum to use in created CRS.
    `cs` - The Cartesian or Oblique Cartesian coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createTemporalCRS

    TemporalCRS createTemporalCRS(Map<String,?> properties,
                                  TemporalDatum datum,
                                  TimeCS cs)
                                  throws FactoryException

  Creates a temporal coordinate reference system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Temporal datum to use in created CRS.
    `cs` - The Temporal coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createVerticalCRS

    @UML(identifier="createVerticalCoordinateSystem",
         specification=OGC_01009)
    VerticalCRS createVerticalCRS(Map<String,?> properties,
                                                                      VerticalDatum datum,
                                                                      VerticalCS cs)
                                  throws FactoryException

  Creates a vertical coordinate reference system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Vertical datum to use in created CRS.
    `cs` - The Vertical coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createGeocentricCRS

    GeocentricCRS createGeocentricCRS(Map<String,?> properties,
                                      GeodeticDatum datum,
                                      CartesianCS cs)
                                      throws FactoryException

  Creates a geocentric coordinate reference system from a cartesian coordinate system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Geodetic datum to use in created CRS.
    `cs` - The cartesian coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createGeocentricCRS

    GeocentricCRS createGeocentricCRS(Map<String,?> properties,
                                      GeodeticDatum datum,
                                      SphericalCS cs)
                                      throws FactoryException

  Creates a geocentric coordinate reference system from a spherical coordinate system.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Geodetic datum to use in created CRS.
    `cs` - The spherical coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createGeographicCRS

    @UML(identifier="createGeographicCoordinateSystem",
         specification=OGC_01009)
    GeographicCRS createGeographicCRS(Map<String,?> properties,
                                                                          GeodeticDatum datum,
                                                                          EllipsoidalCS cs)
                                      throws FactoryException

  Creates a geographic coordinate reference system. It could be Latitude/Longitude or Longitude/Latitude.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `datum` - Geodetic datum to use in created CRS.
    `cs` - The ellipsoidal coordinate system for the created CRS.
  Throws:
    `FactoryException` - if the object creation failed.

### createDerivedCRS

    @UML(identifier="createFittedCoordinateSystem",
         specification=OGC_01009)
    DerivedCRS createDerivedCRS(Map<String,?> properties,
                                                                    OperationMethod method,
                                                                    CoordinateReferenceSystem base,
                                                                    MathTransform baseToDerived,
                                                                    CoordinateSystem derivedCS)
                                throws FactoryException

  Deprecated. Use `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)` followed by `createDerivedCRS(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.referencing.crs.CoordinateReferenceSystem, org.opengis.referencing.operation.MathTransform, org.opengis.referencing.cs.CoordinateSystem)` instead.

  Creates a derived coordinate reference system. If the transformation is an affine map performing a rotation, then any mixed axes must have identical units. For example, a (lat_deg, lon_deg, height_feet) system can be rotated in the (lat, lon) plane, since both affected axes are in degrees. But you should not rotate this coordinate system in any other plane.

  It is the user's responsability to ensure that the `baseToDerived` transform performs all required steps, including unit conversions and change of axis order, if needed.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there. Properties for the `Conversion` object to be created can be specified with the `"conversion."` prefix added in front of property names (example: `"conversion.name"`).
    `method` - A description of the method for the conversion.
    `base` - Coordinate reference system to base the derived CRS on. The number of axes must matches the source dimensions of the transform `baseToDerived`.
    `baseToDerived` - The transform from the base CRS to the newly created CRS.
    `derivedCS` - The coordinate system for the derived CRS. The number of axes must matches the target dimensions of the transform `baseToDerived`.
  Throws:
    `FactoryException` - if the object creation failed.

### createDerivedCRS

    @UML(identifier="createFittedCoordinateSystem",
         specification=OGC_01009)
    DerivedCRS createDerivedCRS(Map<String,?> properties,
                                                                    CoordinateReferenceSystem baseCRS,
                                                                    Conversion conversionFromBase,
                                                                    CoordinateSystem derivedCS)
                                throws FactoryException

  Creates a derived coordinate reference system. If the transformation is an affine map performing a rotation, then any mixed axes must have identical units. For example, a (lat_deg, lon_deg, height_feet) system can be rotated in the (lat, lon) plane, since both affected axes are in degrees. But you should not rotate this coordinate system in any other plane.

  The `conversionFromBase` should contains only the parameter values required for the conversion. It should not includes the "base to derived" transform that performs the unit conversions and change of axis order; the later should be inferred by this constructor.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `baseCRS` - Coordinate reference system to base the projection on. The number of axes must matches the source dimensions of the conversion from base.
    `conversionFromBase` - The defining conversion.
    `derivedCS` - The coordinate system for the derived CRS. The number of axes must matches the target dimensions of the conversion from base.
  Throws:
    `FactoryException` - if the object creation failed.
  Since:
    GeoAPI 2.1
  See Also:
    `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)`, `MathTransformFactory.createBaseToDerived(org.opengis.referencing.crs.CoordinateReferenceSystem, org.opengis.parameter.ParameterValueGroup, org.opengis.referencing.cs.CoordinateSystem)`

### createProjectedCRS

    @UML(identifier="createProjectedCoordinateSystem",
         specification=OGC_01009)
    ProjectedCRS createProjectedCRS(Map<String,?> properties,
                                                                        OperationMethod method,
                                                                        GeographicCRS base,
                                                                        MathTransform baseToDerived,
                                                                        CartesianCS derivedCS)
                                    throws FactoryException

  Deprecated. Use `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)` followed by `createProjectedCRS(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.referencing.crs.GeographicCRS, org.opengis.referencing.operation.MathTransform, org.opengis.referencing.cs.CartesianCS)` instead.

  Creates a projected coordinate reference system from a transform.

  It is the user's responsability to ensure that the `baseToDerived` transform performs all required steps, including unit conversions and change of axis order, if needed.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there. Properties for the `Projection` object to be created can be specified with the `"conversion."` prefix added in front of property names (example: `"conversion.name"`).
    `method` - A description of the method for the projection.
    `base` - Geographic coordinate reference system to base the projection on. The number of axes must matches the source dimensions of the transform `baseToDerived`.
    `baseToDerived` - The transform from the geographic to the projected CRS.
    `derivedCS` - The coordinate system for the projected CRS. The number of axes must matches the target dimensions of the transform `baseToDerived`.
  Throws:
    `FactoryException` - if the object creation failed.

### createProjectedCRS

    @UML(identifier="createProjectedCoordinateSystem",
         specification=OGC_01009)
    ProjectedCRS createProjectedCRS(Map<String,?> properties,
                                                                        GeographicCRS baseCRS,
                                                                        Conversion conversionFromBase,
                                                                        CartesianCS derivedCS)
                                    throws FactoryException

  Creates a projected coordinate reference system from a defining conversion. The `conversionFromBase` should contains only the parameter values required for the map projection. It should not includes the "base to derived" transform that performs the unit conversions and change of axis order; the later should be inferred by this constructor.

  Parameters:
    `properties` - Name and other properties to give to the new object. Available properties are listed there.
    `baseCRS` - Geographic coordinate reference system to base the projection on. The number of axes must matches the source dimensions of the conversion from base.
    `conversionFromBase` - The defining conversion.
    `derivedCS` - The coordinate system for the projected CRS. The number of axes must matches the target dimensions of the conversion from base.
  Throws:
    `FactoryException` - if the object creation failed.
  Since:
    GeoAPI 2.1
  See Also:
    `CoordinateOperationFactory.createDefiningConversion(java.util.Map<java.lang.String, ?>, org.opengis.referencing.operation.OperationMethod, org.opengis.parameter.ParameterValueGroup)`, `MathTransformFactory.createBaseToDerived(org.opengis.referencing.crs.CoordinateReferenceSystem, org.opengis.parameter.ParameterValueGroup, org.opengis.referencing.cs.CoordinateSystem)`

### createFromXML

    @UML(identifier="createFromXML",
         specification=OGC_01009)
    CoordinateReferenceSystem createFromXML(String xml)
                                            throws FactoryException

  Creates a coordinate reference system object from a XML string.

  Parameters:
    `xml` - Coordinate reference system encoded in XML format.
  Throws:
    `FactoryException` - if the object creation failed.

### createFromWKT

    @UML(identifier="createFromWKT",
         specification=OGC_01009)
    CoordinateReferenceSystem createFromWKT(String wkt)
                                            throws FactoryException

  Creates a coordinate reference system object from a string. The definition for WKT is shown using Extended Backus Naur Form (EBNF).

  Parameters:
    `wkt` - Coordinate system encoded in Well-Known Text format.
  Throws:
    `FactoryException` - if the object creation failed.

Copyright © 1994-2008 Open Geospatial Consortium. All Rights Reserved.