GeodeticObjectFactory (Apache SIS referencing 0.6 API)

Object
- AbstractFactory
- - GeodeticObjectFactory

All Implemented Interfaces:: Parser, CRSFactory, CSFactory, DatumFactory, ObjectFactory, Factory

public class GeodeticObjectFactory
extends AbstractFactory
implements CRSFactory, CSFactory, DatumFactory, Parser

Creates Coordinate Reference System (CRS) implementations, with their Coordinate System (CS) and Datum components. This factory serves two purposes:

For users, allows the creation of complex objects that can not be created by the authority factory, without explicit dependency to Apache SIS (when using the GeoAPI interfaces implemented by this class).
For providers, allows inversion of control by overriding methods in this class, then specifying the customized instance to other services that consume CRSFactory (for example authority factories or WKT parsers).

This GeodeticObjectFactory class is not easy to use directly. Users are encouraged to use an authority factory instead (or the CRS#forCode(String) convenience method) when the CRS object to construct can be identified by a code in the namespace of an authority (typically EPSG).

Object properties

Most factory methods expect a Map<String,?> argument, often followed by explicit arguments. Unless otherwise noticed, information provided in the properties map are considered ignorable metadata while information provided in explicit arguments have an impact on coordinate transformation results.

The following table lists the keys recognized by the GeodeticObjectFactory default implementation, together with the type of values associated to those keys. A value for the "name" key is mandatory for all objects, while all other properties are optional. GeodeticObjectFactory methods ignore all unknown properties.

Recognized properties (non exhaustive list)
Property name	Value type	Returned by
"name"	`Identifier` or `String`	`AbstractIdentifiedObject.getName()`
"authority"	`String` or `Citation`	`ImmutableIdentifier.getAuthority()` on the name
"code"	`String`	`ImmutableIdentifier.getCode()` on the name
	`String`	`ImmutableIdentifier.getCodeSpace()` on the name
	`String`	`ImmutableIdentifier.getVersion()` on the name
	`String`	`ImmutableIdentifier.getDescription()` on the name
"alias"	`GenericName` or `CharSequence` (optionally as array)	`AbstractIdentifiedObject.getAlias()`
"identifiers"	`Identifier` (optionally as array)	`AbstractIdentifiedObject.getIdentifiers()`
"domainOfValidity"	`Extent`	`AbstractReferenceSystem.getDomainOfValidity()`
"scope"	`String` or `InternationalString`	`AbstractReferenceSystem.getScope()`
"anchorPoint"	`InternationalString` or `String`	`AbstractDatum.getAnchorPoint()`
"realizationEpoch"	`Date`	`AbstractDatum.getRealizationEpoch()`
"remarks"	`InternationalString` or `String`	`AbstractIdentifiedObject.getRemarks()`
"deprecated"	`Boolean`	`AbstractIdentifiedObject.isDeprecated()`
"locale"	`Locale`	(none)

Localization

All localizable attributes like "remarks" may have a language and country code suffix. For example the "remarks_fr" property stands for remarks in French and the "remarks_fr_CA" property stands for remarks in French Canadian. They are convenience properties for building the InternationalString value.

The "locale" property applies only in case of exception for formatting the error message, and is used only on a best effort basis. The locale is discarded after successful construction since localizations are applied by the InternationalString.toString(Locale) method.

Since:: 0.6

Constructor Summary

Constructors
Constructor and Description
`GeodeticObjectFactory()` Constructs a factory with no default properties.
`GeodeticObjectFactory(Map<String,?> properties)` Constructs a factory with the given default properties.

Method Summary

Methods
Modifier and Type	Method and Description
`protected Map<String,?>`	`complete(Map<String,?> properties)` Returns the union of the given `properties` map with the default properties given at construction time.
`AffineCS`	`createAffineCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)` Creates a two-dimensional affine coordinate system from the given pair of axis.
`AffineCS`	`createAffineCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates a three-dimensional affine coordinate system from the given set of axis.
`CartesianCS`	`createCartesianCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)` Creates a two-dimensional Cartesian coordinate system from the given pair of axis.
`CartesianCS`	`createCartesianCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates a three-dimensional Cartesian coordinate system from the given set of axis.
`CompoundCRS`	`createCompoundCRS(Map<String,?> properties, CoordinateReferenceSystem... elements)` Creates a compound coordinate reference system from an ordered list of `CoordinateReferenceSystem` objects.
`CoordinateSystemAxis`	`createCoordinateSystemAxis(Map<String,?> properties, String abbreviation, AxisDirection direction, Unit<?> unit)` Creates a coordinate system axis from an abbreviation and a unit.
`CylindricalCS`	`createCylindricalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates a cylindrical coordinate system from the given set of axis.
`DerivedCRS`	`createDerivedCRS(Map<String,?> properties, CoordinateReferenceSystem baseCRS, Conversion conversion, CoordinateSystem derivedCS)` Creates a derived coordinate reference system from a conversion.
`Ellipsoid`	`createEllipsoid(Map<String,?> properties, double semiMajorAxis, double semiMinorAxis, Unit<Length> unit)` Creates an ellipsoid from semi-axis length values.
`EllipsoidalCS`	`createEllipsoidalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)` Creates an ellipsoidal coordinate system without ellipsoidal height.
`EllipsoidalCS`	`createEllipsoidalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates an ellipsoidal coordinate system with ellipsoidal height.
`EngineeringCRS`	`createEngineeringCRS(Map<String,?> properties, EngineeringDatum datum, CoordinateSystem cs)` Creates a engineering coordinate reference system.
`EngineeringDatum`	`createEngineeringDatum(Map<String,?> properties)` Creates an engineering datum.
`Ellipsoid`	`createFlattenedSphere(Map<String,?> properties, double semiMajorAxis, double inverseFlattening, Unit<Length> unit)` Creates an ellipsoid from a major semi-axis length and inverse flattening.
`CoordinateReferenceSystem`	`createFromWKT(String text)` Creates a Coordinate Reference System object from a Well Known Text (WKT).
`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.
`GeodeticDatum`	`createGeodeticDatum(Map<String,?> properties, Ellipsoid ellipsoid, PrimeMeridian primeMeridian)` Creates geodetic datum from ellipsoid and (optionally) Bursa-Wolf parameters.
`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.
`ImageDatum`	`createImageDatum(Map<String,?> properties, PixelInCell pixelInCell)` Creates an image datum.
`LinearCS`	`createLinearCS(Map<String,?> properties, CoordinateSystemAxis axis)` Creates a linear coordinate system.
`PolarCS`	`createPolarCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)` Creates a polar coordinate system from the given pair of axis.
`PrimeMeridian`	`createPrimeMeridian(Map<String,?> properties, double longitude, Unit<Angle> angularUnit)` Creates a prime meridian, relative to Greenwich.
`ProjectedCRS`	`createProjectedCRS(Map<String,?> properties, GeographicCRS baseCRS, Conversion conversion, CartesianCS derivedCS)` Creates a projected coordinate reference system from a conversion.
`SphericalCS`	`createSphericalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates a spherical coordinate system from the given set of axis.
`TemporalCRS`	`createTemporalCRS(Map<String,?> properties, TemporalDatum datum, TimeCS cs)` Creates a temporal coordinate reference system.
`TemporalDatum`	`createTemporalDatum(Map<String,?> properties, Date origin)` Creates a temporal datum from an enumerated type value.
`TimeCS`	`createTimeCS(Map<String,?> properties, CoordinateSystemAxis axis)` Creates a temporal coordinate system.
`UserDefinedCS`	`createUserDefinedCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)` Creates a two-dimensional user defined coordinate system from the given pair of axis.
`UserDefinedCS`	`createUserDefinedCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)` Creates a three-dimensional user defined coordinate system from the given set of axis.
`VerticalCRS`	`createVerticalCRS(Map<String,?> properties, VerticalDatum datum, VerticalCS cs)` Creates a vertical coordinate reference system.
`VerticalCS`	`createVerticalCS(Map<String,?> properties, CoordinateSystemAxis axis)` Creates a vertical coordinate system.
`VerticalDatum`	`createVerticalDatum(Map<String,?> properties, VerticalDatumType type)` Creates a vertical datum from an enumerated type value.

Methods inherited from class AbstractFactory
getVendor

Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface Factory
getVendor

- Constructor Detail
  - GeodeticObjectFactory
```
public GeodeticObjectFactory()
```
    Constructs a factory with no default properties.
  - GeodeticObjectFactory
```
public GeodeticObjectFactory(Map<String,?> properties)
```
    Constructs a factory with the given default properties. GeodeticObjectFactory will fallback on the map given to this constructor for any property not present in the map provided to a createFoo(Map<String,?>, …) method.
    
    Parameters:
    properties - The default properties, or null if none.
- Method Detail
  - complete
```
protected Map<String,?> complete(Map<String,?> properties)
```
    Returns the union of the given properties map with the default properties given at construction time. Entries in the given properties map have precedence, even if their value is null (i.e. a null value "erase" the default property value). Entries with null value after the union will be omitted.
    This method is invoked by all createFoo(Map<String,?>, …) methods.
    
    Parameters:
    properties - The user-supplied properties.
    
    Returns:
    The union of the given properties with the default properties.
  - createGeocentricCRS
```
public GeocentricCRS createGeocentricCRS(Map<String,?> properties,
                                GeodeticDatum datum,
                                CartesianCS cs)
                                  throws FactoryException
```
    Creates a geocentric coordinate reference system from a Cartesian coordinate system. Geocentric CRS have their origin at the approximate centre of mass of the earth. An alternate method allows creation of the same kind of CRS with spherical coordinate system instead than a Cartesian one.
    The components needed by this method can be created by the following methods:
    - createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)
    - createCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
    The default implementation creates a DefaultGeocentricCRS instance.
    Specified by:
    
    createGeocentricCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - The geodetic datum to use in created CRS.
    cs - The three-dimensional Cartesian coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultGeocentricCRS.DefaultGeocentricCRS(Map, GeodeticDatum, CartesianCS)
  - createCartesianCS
```
public CartesianCS createCartesianCS(Map<String,?> properties,
                            CoordinateSystemAxis axis0,
                            CoordinateSystemAxis axis1,
                            CoordinateSystemAxis axis2)
                              throws FactoryException
```
    Creates a three-dimensional Cartesian coordinate system from the given set of axis. This coordinate system can be used with geocentric, engineering and derived CRS.
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultCartesianCS instance.
    Specified by:
    
    createCartesianCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis (e.g. “Geocentric X”).
    axis1 - The second axis (e.g. “Geocentric Y”).
    axis2 - The third axis (e.g. “Geocentric Z”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultCartesianCS.DefaultCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
  - createGeocentricCRS
```
public GeocentricCRS createGeocentricCRS(Map<String,?> properties,
                                GeodeticDatum datum,
                                SphericalCS cs)
                                  throws FactoryException
```
    Creates a geocentric coordinate reference system from a spherical coordinate system. Geocentric CRS have their origin at the approximate centre of mass of the earth. An alternate method allows creation of the same kind of CRS with Cartesian coordinate system instead than a spherical one.
    The components needed by this method can be created by the following methods:
    - createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)
    - createSphericalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
    The default implementation creates a DefaultGeocentricCRS instance.
    Specified by:
    
    createGeocentricCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - Geodetic datum to use in created CRS.
    cs - The spherical coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultGeocentricCRS.DefaultGeocentricCRS(Map, GeodeticDatum, SphericalCS)
  - createSphericalCS
```
public SphericalCS createSphericalCS(Map<String,?> properties,
                            CoordinateSystemAxis axis0,
                            CoordinateSystemAxis axis1,
                            CoordinateSystemAxis axis2)
                              throws FactoryException
```
    Creates a spherical coordinate system from the given set of axis. This coordinate system can be used with geocentric, engineering and derived CRS.
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultSphericalCS instance.
    Specified by:
    
    createSphericalCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis (e.g. “Spherical latitude”).
    axis1 - The second axis (e.g. “Spherical longitude”).
    axis2 - The third axis (e.g. “Geocentric radius”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultSphericalCS.DefaultSphericalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
  - createGeographicCRS
```
public GeographicCRS createGeographicCRS(Map<String,?> properties,
                                GeodeticDatum datum,
                                EllipsoidalCS cs)
                                  throws FactoryException
```
    Creates a geographic coordinate reference system. It can be (latitude, longitude) or (longitude, latitude), optionally with an ellipsoidal height.
    The components needed by this method can be created by the following methods:
    - createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)
    - createEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
    The default implementation creates a DefaultGeographicCRS instance.
    Specified by:
    
    createGeographicCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - Geodetic datum to use in created CRS.
    cs - The two- or three-dimensional ellipsoidal coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultGeographicCRS.DefaultGeographicCRS(Map, GeodeticDatum, EllipsoidalCS)
  - createGeodeticDatum
```
public GeodeticDatum createGeodeticDatum(Map<String,?> properties,
                                Ellipsoid ellipsoid,
                                PrimeMeridian primeMeridian)
                                  throws FactoryException
```
    Creates geodetic datum from ellipsoid and (optionally) Bursa-Wolf parameters. Geodetic datum defines the location and orientation of an ellipsoid that approximates the shape of the earth. This datum can be used with geographic, geocentric and engineering CRS.
    The components needed by this method can be created by the following methods:
    - createEllipsoid(Map, double, double, Unit) or createFlattenedSphere(Map, double, double, Unit)
    - createPrimeMeridian(Map, double, Unit)
    The default implementation creates a DefaultGeodeticDatum instance.
    Specified by:
    
    createGeodeticDatum in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    ellipsoid - The ellipsoid to use in new geodetic datum.
    primeMeridian - The prime meridian to use in new geodetic datum.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultGeodeticDatum.DefaultGeodeticDatum(Map, Ellipsoid, PrimeMeridian)
  - createPrimeMeridian
```
public PrimeMeridian createPrimeMeridian(Map<String,?> properties,
                                double longitude,
                                Unit<Angle> angularUnit)
                                  throws FactoryException
```
    Creates a prime meridian, relative to Greenwich. Defines the origin from which longitude values are determined.
    The default implementation creates a DefaultPrimeMeridian instance.
    
    Specified by:
    
    createPrimeMeridian in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    longitude - The longitude of prime meridian in supplied angular units East of Greenwich.
    angularUnit - The angular units of longitude.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultPrimeMeridian.DefaultPrimeMeridian(Map, double, Unit)
  - createEllipsoidalCS
```
public EllipsoidalCS createEllipsoidalCS(Map<String,?> properties,
                                CoordinateSystemAxis axis0,
                                CoordinateSystemAxis axis1)
                                  throws FactoryException
```
    Creates an ellipsoidal coordinate system without ellipsoidal height. It can be (latitude, longitude) or (longitude, latitude).
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultEllipsoidalCS instance.
    Specified by:
    
    createEllipsoidalCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis (e.g. “Geodetic latitude”).
    axis1 - The second axis (e.g. “Geodetic longitude”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEllipsoidalCS.DefaultEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createEllipsoidalCS
```
public EllipsoidalCS createEllipsoidalCS(Map<String,?> properties,
                                CoordinateSystemAxis axis0,
                                CoordinateSystemAxis axis1,
                                CoordinateSystemAxis axis2)
                                  throws FactoryException
```
    Creates an ellipsoidal coordinate system with ellipsoidal height. It can be (latitude, longitude, height) or (longitude, latitude, height).
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultEllipsoidalCS instance.
    Specified by:
    
    createEllipsoidalCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis (e.g. “Geodetic latitude”).
    axis1 - The second axis (e.g. “Geodetic longitude”).
    axis2 - The third axis (e.g. “Ellipsoidal height”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEllipsoidalCS.DefaultEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
  - createEllipsoid
```
public Ellipsoid createEllipsoid(Map<String,?> properties,
                        double semiMajorAxis,
                        double semiMinorAxis,
                        Unit<Length> unit)
                          throws FactoryException
```
    Creates an ellipsoid from semi-axis length values. The default implementation creates a DefaultEllipsoid instance.
    
    Specified by:
    
    createEllipsoid in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    semiMajorAxis - The equatorial radius in supplied linear units.
    semiMinorAxis - The polar radius in supplied linear units.
    unit - The linear units of ellipsoid axes.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEllipsoid.createEllipsoid(Map, double, double, Unit)
  - createFlattenedSphere
```
public Ellipsoid createFlattenedSphere(Map<String,?> properties,
                              double semiMajorAxis,
                              double inverseFlattening,
                              Unit<Length> unit)
                                throws FactoryException
```
    Creates an ellipsoid from a major semi-axis length and inverse flattening. The default implementation creates a DefaultEllipsoid instance.
    
    Specified by:
    
    createFlattenedSphere in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    semiMajorAxis - The equatorial radius in supplied linear units.
    inverseFlattening - The eccentricity of ellipsoid.
    unit - The linear units of major axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEllipsoid.createFlattenedSphere(Map, double, double, Unit)
  - createProjectedCRS
```
public ProjectedCRS createProjectedCRS(Map<String,?> properties,
                              GeographicCRS baseCRS,
                              Conversion conversion,
                              CartesianCS derivedCS)
                                throws FactoryException
```
    Creates a projected coordinate reference system from a conversion. Projected CRS are used to approximate the shape of the earth on a planar surface in such a way that the distortion that is inherent to the approximation is controlled and known.
    The components needed by this method can be created by the following methods:
    The supplied conversion argument shall not includes the operation steps for performing unit conversions and change of axis order since those operations will be inferred by this constructor.
    The default implementation creates a DefaultProjectedCRS instance.
    Specified by:
    
    createProjectedCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    baseCRS - The geographic coordinate reference system to base projection on.
    conversion - The defining conversion from a normalized base to a normalized derived CRS.
    derivedCS - The coordinate system for the projected CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultProjectedCRS.DefaultProjectedCRS(Map, GeographicCRS, Conversion, CartesianCS)
  - createCartesianCS
```
public CartesianCS createCartesianCS(Map<String,?> properties,
                            CoordinateSystemAxis axis0,
                            CoordinateSystemAxis axis1)
                              throws FactoryException
```
    Creates a two-dimensional Cartesian coordinate system from the given pair of axis. This coordinate system can be used with projected, engineering and derived CRS.
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultCartesianCS instance.
    Specified by:
    
    createCartesianCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis (e.g. “Easting”).
    axis1 - The second axis (e.g. “Northing”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultCartesianCS.DefaultCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createDerivedCRS
```
public DerivedCRS createDerivedCRS(Map<String,?> properties,
                          CoordinateReferenceSystem baseCRS,
                          Conversion conversion,
                          CoordinateSystem derivedCS)
                            throws FactoryException
```
    Creates a derived coordinate reference system from a conversion. The derived CRS returned by this method may also implement the GeodeticCRS, VerticalCRS, TemporalCRS or EngineeringCRS interface depending on the type of the base CRS and the coordinate system.
    The components needed by this method can be created by the following methods:
    - An other createFooCRS(…) method for geocentric, geographic, vertical, temporal or engineering CRS.
    - DefaultCoordinateOperationFactory.createDefiningConversion(Map, OperationMethod, ParameterValueGroup)
    - A createFooCS(…) method for Cartesian, spherical, ellipsoidal, vertical, temporal, linear, affine, polar, cylindrical or user-defined CS.
    The supplied conversion argument shall not includes the operation steps for performing unit conversions and change of axis order since those operations will be inferred by this constructor.
    The default implementation creates a DefaultDerivedCRS instance.
    Specified by:
    
    createDerivedCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    baseCRS - The coordinate reference system to base projection on. Shall be an instance of SingleCRS.
    conversion - The defining conversion from a normalized base to a normalized derived CRS.
    derivedCS - The coordinate system for the derived CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultDerivedCRS.create(Map, SingleCRS, Conversion, CoordinateSystem)
  - createVerticalCRS
```
public VerticalCRS createVerticalCRS(Map<String,?> properties,
                            VerticalDatum datum,
                            VerticalCS cs)
                              throws FactoryException
```
    Creates a vertical coordinate reference system. Vertical CRSs make use of the direction of gravity to define the concept of height or depth, but the relationship with gravity may not be straightforward.
    The components needed by this method can be created by the following methods:
    - createVerticalDatum(Map, VerticalDatumType)
    - createVerticalCS(Map, CoordinateSystemAxis)
    The default implementation creates a DefaultVerticalCRS instance.
    Specified by:
    
    createVerticalCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - The vertical datum to use in created CRS.
    cs - The vertical coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultVerticalCRS.DefaultVerticalCRS(Map, VerticalDatum, VerticalCS)
  - createVerticalDatum
```
public VerticalDatum createVerticalDatum(Map<String,?> properties,
                                VerticalDatumType type)
                                  throws FactoryException
```
    Creates a vertical datum from an enumerated type value. The default implementation creates a DefaultVerticalDatum instance.
    
    Specified by:
    
    createVerticalDatum in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    type - The type of this vertical datum (often geoidal).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultVerticalDatum.DefaultVerticalDatum(Map, VerticalDatumType)
  - createVerticalCS
```
public VerticalCS createVerticalCS(Map<String,?> properties,
                          CoordinateSystemAxis axis)
                            throws FactoryException
```
    Creates a vertical coordinate system. This coordinate system can be used with vertical and derived CRS.
    The components needed by this method can be created by the following method:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultVerticalCS instance.
    Specified by:
    
    createVerticalCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis - The single axis (e.g. “height” or “depth”).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultVerticalCS.DefaultVerticalCS(Map, CoordinateSystemAxis)
  - createTemporalCRS
```
public TemporalCRS createTemporalCRS(Map<String,?> properties,
                            TemporalDatum datum,
                            TimeCS cs)
                              throws FactoryException
```
    Creates a temporal coordinate reference system.
    The components needed by this method can be created by the following methods:
    - createTemporalDatum(Map, Date)
    - createTimeCS(Map, CoordinateSystemAxis)
    The default implementation creates a DefaultTemporalCRS instance.
    Specified by:
    
    createTemporalCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - The temporal datum to use in created CRS.
    cs - The temporal coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultTemporalCRS.DefaultTemporalCRS(Map, TemporalDatum, TimeCS)
  - createTemporalDatum
```
public TemporalDatum createTemporalDatum(Map<String,?> properties,
                                Date origin)
                                  throws FactoryException
```
    Creates a temporal datum from an enumerated type value. The default implementation creates a DefaultTemporalDatum instance.
    
    Specified by:
    
    createTemporalDatum in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    origin - The date and time origin of this temporal datum.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultTemporalDatum.DefaultTemporalDatum(Map, Date)
  - createTimeCS
```
public TimeCS createTimeCS(Map<String,?> properties,
                  CoordinateSystemAxis axis)
                    throws FactoryException
```
    Creates a temporal coordinate system. This coordinate system can be used with temporal and derived CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultTimeCS instance.
    Specified by:
    
    createTimeCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis - The single axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultTimeCS.DefaultTimeCS(Map, CoordinateSystemAxis)
  - createCompoundCRS
```
public CompoundCRS createCompoundCRS(Map<String,?> properties,
                            CoordinateReferenceSystem... elements)
                              throws FactoryException
```
    Creates a compound coordinate reference system from an ordered list of CoordinateReferenceSystem objects. Apache SIS puts no restriction on the components that can be used in a compound CRS. However for better inter-operability, users are encouraged to follow the order mandated by ISO 19162:
    - A mandatory horizontal CRS (only one of two-dimensional GeographicCRS or ProjectedCRS or EngineeringCRS).
    - Optionally followed by a VerticalCRS or a ParametricCRS (but not both).
    - Optionally followed by a TemporalCRS.
    The default implementation creates a DefaultCompoundCRS instance.
    Specified by:
    
    createCompoundCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    elements - Ordered array of CoordinateReferenceSystem objects.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultCompoundCRS.DefaultCompoundCRS(Map, CoordinateReferenceSystem...)
  - createImageCRS
```
public ImageCRS createImageCRS(Map<String,?> properties,
                      ImageDatum datum,
                      AffineCS cs)
                        throws FactoryException
```
    Creates an image coordinate reference system. The default implementation creates a DefaultImageCRS instance.
    
    Specified by:
    
    createImageCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - The 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.
    See Also:
    DefaultImageCRS.DefaultImageCRS(Map, ImageDatum, AffineCS)
  - createImageDatum
```
public ImageDatum createImageDatum(Map<String,?> properties,
                          PixelInCell pixelInCell)
                            throws FactoryException
```
    Creates an image datum. The default implementation creates a DefaultImageDatum instance.
    
    Specified by:
    
    createImageDatum in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    pixelInCell - Specification of the way the image grid is associated with the image data attributes.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultImageDatum.DefaultImageDatum(Map, PixelInCell)
  - createAffineCS
```
public AffineCS createAffineCS(Map<String,?> properties,
                      CoordinateSystemAxis axis0,
                      CoordinateSystemAxis axis1)
                        throws FactoryException
```
    Creates a two-dimensional affine coordinate system from the given pair of axis. This coordinate system can be used with image and engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultAffineCS instance.
    Specified by:
    
    createAffineCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultAffineCS.DefaultAffineCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createEngineeringCRS
```
public EngineeringCRS createEngineeringCRS(Map<String,?> properties,
                                  EngineeringDatum datum,
                                  CoordinateSystem cs)
                                    throws FactoryException
```
    Creates a engineering coordinate reference system. Engineering CRS can be divided into two broad categories:
    - earth-fixed systems applied to engineering activities on or near the surface of the earth;
    - CRSs on moving platforms such as road vehicles, vessels, aircraft, or spacecraft.
    The components needed by this method can be created by the following methods:
    - createEngineeringDatum(Map)
    - A createFooCS(…) method for Cartesian, spherical, linear, affine, polar, cylindrical or user-defined CS.
    The default implementation creates a DefaultEngineeringCRS instance.
    Specified by:
    
    createEngineeringCRS in interface CRSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    datum - The engineering datum to use in created CRS.
    cs - The coordinate system for the created CRS.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEngineeringCRS.DefaultEngineeringCRS(Map, EngineeringDatum, CoordinateSystem)
  - createEngineeringDatum
```
public EngineeringDatum createEngineeringDatum(Map<String,?> properties)
                                        throws FactoryException
```
    Creates an engineering datum. The default implementation creates a DefaultEngineeringDatum instance.
    
    Specified by:
    
    createEngineeringDatum in interface DatumFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultEngineeringDatum.DefaultEngineeringDatum(Map)
  - createAffineCS
```
public AffineCS createAffineCS(Map<String,?> properties,
                      CoordinateSystemAxis axis0,
                      CoordinateSystemAxis axis1,
                      CoordinateSystemAxis axis2)
                        throws FactoryException
```
    Creates a three-dimensional affine coordinate system from the given set of axis. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultAffineCS instance.
    Specified by:
    
    createAffineCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    axis2 - The third axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultAffineCS.DefaultAffineCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createCylindricalCS
```
public CylindricalCS createCylindricalCS(Map<String,?> properties,
                                CoordinateSystemAxis axis0,
                                CoordinateSystemAxis axis1,
                                CoordinateSystemAxis axis2)
                                  throws FactoryException
```
    Creates a cylindrical coordinate system from the given set of axis. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultCylindricalCS instance.
    Specified by:
    
    createCylindricalCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    axis2 - The third axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultCylindricalCS.DefaultCylindricalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
  - createPolarCS
```
public PolarCS createPolarCS(Map<String,?> properties,
                    CoordinateSystemAxis axis0,
                    CoordinateSystemAxis axis1)
                      throws FactoryException
```
    Creates a polar coordinate system from the given pair of axis. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultPolarCS instance.
    Specified by:
    
    createPolarCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultPolarCS.DefaultPolarCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createLinearCS
```
public LinearCS createLinearCS(Map<String,?> properties,
                      CoordinateSystemAxis axis)
                        throws FactoryException
```
    Creates a linear coordinate system. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultLinearCS instance.
    Specified by:
    
    createLinearCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis - The single axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultLinearCS.DefaultLinearCS(Map, CoordinateSystemAxis)
  - createUserDefinedCS
```
public UserDefinedCS createUserDefinedCS(Map<String,?> properties,
                                CoordinateSystemAxis axis0,
                                CoordinateSystemAxis axis1)
                                  throws FactoryException
```
    Creates a two-dimensional user defined coordinate system from the given pair of axis. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultUserDefinedCS instance.
    Specified by:
    
    createUserDefinedCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultUserDefinedCS.DefaultUserDefinedCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)
  - createUserDefinedCS
```
public UserDefinedCS createUserDefinedCS(Map<String,?> properties,
                                CoordinateSystemAxis axis0,
                                CoordinateSystemAxis axis1,
                                CoordinateSystemAxis axis2)
                                  throws FactoryException
```
    Creates a three-dimensional user defined coordinate system from the given set of axis. This coordinate system can be used with engineering CRS.
    The components needed by this method can be created by the following methods:
    - createCoordinateSystemAxis(Map, String, AxisDirection, Unit)
    The default implementation creates a DefaultUserDefinedCS instance.
    Specified by:
    
    createUserDefinedCS in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    axis0 - The first axis.
    axis1 - The second axis.
    axis2 - The third axis.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultUserDefinedCS.DefaultUserDefinedCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)
  - createCoordinateSystemAxis
```
public CoordinateSystemAxis createCoordinateSystemAxis(Map<String,?> properties,
                                              String abbreviation,
                                              AxisDirection direction,
                                              Unit<?> unit)
                                                throws FactoryException
```
    Creates a coordinate system axis from an abbreviation and a unit. Note that the axis name is constrained by ISO 19111 depending on the coordinate reference system type. See the GeoAPI CoordinateSystemAxis javadoc for more information.
    The default implementation creates a DefaultCoordinateSystemAxis instance.
    
    Specified by:
    
    createCoordinateSystemAxis in interface CSFactory
    
    Parameters:
    properties - Name and other properties to give to the new object.
    abbreviation - The coordinate axis abbreviation.
    direction - The axis direction.
    unit - The coordinate axis unit.
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    DefaultCoordinateSystemAxis.DefaultCoordinateSystemAxis(Map, String, AxisDirection, Unit)
  - createFromXML
```
public CoordinateReferenceSystem createFromXML(String xml)
                                        throws FactoryException
```
    Creates a coordinate reference system object from a XML string. Note that the given argument is the XML document itself, not a URL to a XML document.
    The default implementation delegates to XML.unmarshal(String)
    
    Specified by:
    
    createFromXML in interface CRSFactory
    
    Parameters:
    xml - Coordinate reference system encoded in XML format.
    
    Throws:
    
    FactoryException - if the object creation failed.
  - createFromWKT
```
public CoordinateReferenceSystem createFromWKT(String text)
                                        throws FactoryException
```
    Creates a Coordinate Reference System object from a Well Known Text (WKT). This method understands both version 1 (a.k.a. OGC 01-009) and version 2 (a.k.a. ISO 19162) of the WKT format.
    Example: below is a slightly simplified WKT 2 string for a Mercator projection. For making this example smaller, some optional UNIT[…] and ORDER[…] elements have been omitted.
    ProjectedCRS["SIRGAS 2000 / Brazil Mercator", BaseGeodCRS["SIRGAS 2000", Datum["Sistema de Referencia Geocentrico para las Americas 2000", Ellipsoid["GRS 1980", 6378137, 298.257222101]]], Conversion["Petrobras Mercator", Method["Mercator (variant B)", Id["EPSG",9805]], Parameter["Latitude of 1st standard parallel", -2], Parameter["Longitude of natural origin", -43], Parameter["False easting", 5000000], Parameter["False northing", 10000000]], CS[cartesian,2], Axis["easting (E)", east], Axis["northing (N)", north], LengthUnit["metre", 1], Id["EPSG",5641]]
    Usage and performance considerations
    The default implementation uses a shared instance of WKTFormat with the addition of thread-safety. This is okay for occasional use, but is sub-optimal if this method is extensively used in a multi-thread environment. Furthermore this method offers no control on the WKT conventions in use and on the handling of warnings. Applications which need to parse a large amount of WKT strings should consider to use the WKTFormat class instead than this method.
    Specified by:
    
    createFromWKT in interface Parser
    
    Specified by:
    
    createFromWKT in interface CRSFactory
    
    Parameters:
    text - Coordinate system encoded in Well-Known Text format (version 1 or 2).
    
    Throws:
    
    FactoryException - if the object creation failed.
    See Also:
    org.apache.sis.io.wkt, WKT 2 specification, Legacy WKT 1

Class GeodeticObjectFactory

Constructor Summary

Method Summary

Methods inherited from class AbstractFactory

Methods inherited from class Object

Methods inherited from interface Factory

Constructor Detail

GeodeticObjectFactory

GeodeticObjectFactory

Method Detail

complete

createGeocentricCRS

createCartesianCS

createGeocentricCRS

createSphericalCS

createGeographicCRS

createGeodeticDatum

createPrimeMeridian

createEllipsoidalCS

createEllipsoidalCS

createEllipsoid

createFlattenedSphere

createProjectedCRS

createCartesianCS

createDerivedCRS

createVerticalCRS

createVerticalDatum

createVerticalCS

createTemporalCRS

createTemporalDatum

createTimeCS

createCompoundCRS

createImageCRS

createImageDatum

createAffineCS

createEngineeringCRS

createEngineeringDatum

createAffineCS

createCylindricalCS

createPolarCS

createLinearCS

createUserDefinedCS

createUserDefinedCS

createCoordinateSystemAxis

createFromXML

createFromWKT