# Class GeodeticObjectFactory

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 cannot be created by the authority factories, 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
"codespace" | `String` | `ImmutableIdentifier.getCodeSpace()` on the name
"version" | `String` | `ImmutableIdentifier.getVersion()` on the name
"description" | `String` | `ImmutableIdentifier.getDescription()` on the name
"alias" | `GenericName` or `CharSequence` (optionally as array) | `AbstractIdentifiedObject.getAlias()`
"identifiers" | `Identifier` (optionally as array) | `AbstractIdentifiedObject.getIdentifiers()`
"domains" | `DefaultObjectDomain` (optionally as array) | `AbstractIdentifiedObject.getDomains()`
"domainOfValidity" | `Extent` | `DefaultObjectDomain.getDomainOfValidity()`
"scope" | `String` or `InternationalString` | `DefaultObjectDomain.getScope()`
"anchorPoint" | `InternationalString` or `String` | `AbstractDatum.getAnchorDefinition()`
| `Temporal` | `AbstractDatum.getAnchorEpoch()`
"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
  Description
  `GeodeticObjectFactory()`
  Constructs a factory with no default properties.
  `GeodeticObjectFactory(Map<String,?> properties)`
  Constructs a factory with the given default properties.

- ## Method Summary

  Modifier and Type
  Method
  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... components)`
  Creates a compound coordinate reference system from an ordered list of CRS components.
  `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.
  `<D extends Datum>
  DefaultDatumEnsemble<D>`
  `createDatumEnsemble(Map<String,?> properties, Collection<? extends D> members, PositionalAccuracy accuracy)`
  Creates a datum ensemble from a collection of members and an ensemble accuracy.
  `DerivedCRS`
  `createDerivedCRS(Map<String,?> properties, CoordinateReferenceSystem baseCRS, Conversion baseToDerived, 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, DefaultDatumEnsemble<EngineeringDatum> ensemble, CoordinateSystem cs)`
  Creates a engineering coordinate reference system.
  `EngineeringCRS`
  `createEngineeringCRS(Map<String,?> properties, EngineeringDatum datum, CoordinateSystem cs)`
  Creates a engineering CRS with a datum that may be a datum ensemble.
  `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 wkt)`
  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)`
  Deprecated.
  ISO 19111:2019 does not define an explicit class for geocentric CRS.
  `GeodeticCRS`
  `createGeodeticCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, CartesianCS cs)`
  Creates a geocentric coordinate reference system from a Cartesian coordinate system.
  `GeodeticCRS`
  `createGeodeticCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, SphericalCS cs)`
  Creates a geocentric coordinate reference system from a spherical coordinate system.
  `GeodeticDatum`
  `createGeodeticDatum(Map<String,?> properties, Ellipsoid ellipsoid, PrimeMeridian primeMeridian)`
  Creates a static geodetic reference frame from ellipsoid and (optionally) Bursa-Wolf parameters.
  `GeodeticDatum`
  `createGeodeticDatum(Map<String,?> properties, Ellipsoid ellipsoid, PrimeMeridian primeMeridian, Temporal epoch)`
  Creates a dynamic geodetic reference frame from ellipsoid and frame reference epoch.
  `GeographicCRS`
  `createGeographicCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, EllipsoidalCS cs)`
  Creates a geographic coordinate reference system.
  `GeographicCRS`
  `createGeographicCRS(Map<String,?> properties, GeodeticDatum datum, EllipsoidalCS cs)`
  Creates a geographic CRS with a datum that may be a datum ensemble.
  `ImageCRS`
  `createImageCRS(Map<String,?> properties, ImageDatum datum, AffineCS cs)`
  Deprecated.
  The `ImageCRS` class has been removed in ISO 19111:2019.
  `ImageDatum`
  `createImageDatum(Map<String,?> properties, PixelInCell pixelInCell)`
  Deprecated.
  The `ImageDatum` class has been removed in ISO 19111:2019.
  `LinearCS`
  `createLinearCS(Map<String,?> properties, CoordinateSystemAxis axis)`
  Creates a linear coordinate system.
  `DefaultParametricCRS`
  `createParametricCRS(Map<String,?> properties, DefaultParametricDatum datum, DefaultParametricCS cs)`
  Creates a parametric CRS from a datum.
  `DefaultParametricCRS`
  `createParametricCRS(Map<String,?> properties, DefaultParametricDatum datum, DefaultDatumEnsemble<DefaultParametricDatum> ensemble, DefaultParametricCS cs)`
  Creates a parametric coordinate reference system.
  `DefaultParametricCS`
  `createParametricCS(Map<String,?> properties, CoordinateSystemAxis axis)`
  Creates a parametric coordinate system.
  `DefaultParametricDatum`
  `createParametricDatum(Map<String,?> properties)`
  Creates a parametric datum.
  `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 baseToDerived, CartesianCS derivedCS)`
  Creates a projected coordinate reference system from a conversion.
  `SphericalCS`
  `createSphericalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1)`
  Creates a spherical coordinate system without radius.
  `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, DefaultDatumEnsemble<TemporalDatum> ensemble, TimeCS cs)`
  Creates a temporal coordinate reference system.
  `TemporalCRS`
  `createTemporalCRS(Map<String,?> properties, TemporalDatum datum, TimeCS cs)`
  Creates a temporal CRS with a datum that may be a datum ensemble.
  `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)`
  Deprecated.
  The `UserDefinedCS` class has been removed from ISO 19111:2019.
  `UserDefinedCS`
  `createUserDefinedCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2)`
  Deprecated.
  The `UserDefinedCS` class has been removed from ISO 19111:2019.
  `VerticalCRS`
  `createVerticalCRS(Map<String,?> properties, VerticalDatum datum, DefaultDatumEnsemble<VerticalDatum> ensemble, VerticalCS cs)`
  Creates a vertical coordinate reference system.
  `VerticalCRS`
  `createVerticalCRS(Map<String,?> properties, VerticalDatum datum, VerticalCS cs)`
  Creates a vertical CRS with a datum that may be a datum ensemble.
  `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.
  `VerticalDatum`
  `createVerticalDatum(Map<String,?> properties, VerticalDatumType type, Temporal epoch)`
  Creates a dynamic vertical datum from an enumerated type value and a frame reference epoch.
  `static GeodeticObjectFactory`
  `provider()`
  Returns the default provider of `IdentifiedObject` instances.

  ### Methods inherited from class AbstractFactory

  `getVendor, toString`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface Factory

  `getVendor`

- ## Constructor Details

  - ### GeodeticObjectFactory

    public GeodeticObjectFactory()
    Constructs a factory with no default properties.
    See Also:
      - `provider()`

  - ### 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 Details

  - ### provider

    public static GeodeticObjectFactory provider()
    Returns the default provider of `IdentifiedObject` instances. This is the factory used by the Apache SIS library when no non-null `CRSFactory`, `CSFactory` or `DatumFactory` has been explicitly specified. This method can be invoked directly, or indirectly through `ServiceLoader​.load(T)` where T is one of above-cited interfaces.
    Returns:
      the default provider of geodetic objects.
    Since:
      1.4
    See Also:
      - `ServiceLoader`

  - ### 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. Subclasses can override this method if they want to add, remove or edit property values with more flexibility than constant values specified at construction time.

    Parameters:
      `properties` - the properties supplied in a call to a `createFoo(Map, …)` method.
    Returns:
      the union of the given properties with the default properties.

  - ### createGeodeticCRS

    public GeodeticCRS createGeodeticCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, 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 of a Cartesian one.
    Warning: In a future SIS version, the return type may be changed to the `GeodeticCRS` parent interface. This is because ISO 19111 does not defines specific interface for the geocentric case. Users should assign the return value to a `GeodeticCRS` type.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
    3. One of:
       - `createEllipsoid(Map, double, double, Unit)`
       - `createFlattenedSphere(Map, double, double, Unit)`
    4. `createPrimeMeridian(Map, double, Unit)`
    5. `createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)`
    6. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultGeocentricCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - geodetic reference frame, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of reference frames which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the three-dimensional Cartesian coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultGeocentricCRS(Map, GeodeticDatum, DefaultDatumEnsemble, CartesianCS)`
      - invalid reference

            GeodeticAuthorityFactory#createGeodeticCRS(String)

  - ### createGeocentricCRS

    public GeocentricCRS createGeocentricCRS(Map<String,?> properties, GeodeticDatum datum, CartesianCS cs) throws FactoryException
    Creates a geocentric coordinate reference system from a Cartesian coordinate system.
    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.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `GeodeticAuthorityFactory​.createGeocentricCRS(String)`
      - invalid reference

            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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createCartesianCS(String)`

  - ### createGeodeticCRS

    public GeodeticCRS createGeodeticCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, 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 of a spherical one.
    Warning: In a future SIS version, the return type may be changed to the `GeodeticCRS` parent interface. This is because ISO 19111 does not defines specific interface for the geocentric case. Users should assign the return value to a `GeodeticCRS` type.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createSphericalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
    3. One of:
       - `createEllipsoid(Map, double, double, Unit)`
       - `createFlattenedSphere(Map, double, double, Unit)`
    4. `createPrimeMeridian(Map, double, Unit)`
    5. `createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)`
    6. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultGeocentricCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - geodetic reference frame, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of reference frames which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the spherical coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultGeocentricCRS(Map, GeodeticDatum, DefaultDatumEnsemble, SphericalCS)`
      - invalid reference

            GeodeticAuthorityFactory#createGeodeticCRS(String)

  - ### createGeocentricCRS

    @Deprecated public GeocentricCRS createGeocentricCRS(Map<String,?> properties, GeodeticDatum datum, SphericalCS cs) throws FactoryException
    Deprecated.
    ISO 19111:2019 does not define an explicit class for geocentric CRS. Use
    invalid reference

        #createGeodeticCRS(Map, GeodeticDatum, SphericalCS)

    instead.
    Creates a geocentric coordinate reference system from a spherical coordinate system.
    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.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultSphericalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createSphericalCS(String)`

  - ### createSphericalCS

    public SphericalCS createSphericalCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1) throws FactoryException
    Creates a spherical coordinate system without radius. This coordinate system can be used with geocentric, engineering and derived CRS.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    The default implementation creates a `DefaultSphericalCS` instance.
    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”).
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.4
    See Also:
      - `DefaultSphericalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`

  - ### createGeographicCRS

    public GeographicCRS createGeographicCRS(Map<String,?> properties, GeodeticDatum datum, DefaultDatumEnsemble<GeodeticDatum> ensemble, EllipsoidalCS cs) throws FactoryException
    Creates a geographic coordinate reference system. It can be (latitude, longitude) or (longitude, latitude), optionally with an ellipsoidal height.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. One of:
       - `createEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
       - `createEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
    3. One of:
       - `createEllipsoid(Map, double, double, Unit)`
       - `createFlattenedSphere(Map, double, double, Unit)`
    4. `createPrimeMeridian(Map, double, Unit)`
    5. `createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)`
    6. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultGeographicCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - geodetic reference frame, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of reference frames which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the two- or three-dimensional ellipsoidal coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultGeographicCRS(Map, GeodeticDatum, DefaultDatumEnsemble, EllipsoidalCS)`
      - `GeodeticAuthorityFactory​.createGeographicCRS(String)`

  - ### createGeographicCRS

    public GeographicCRS createGeographicCRS(Map<String,?> properties, GeodeticDatum datum, EllipsoidalCS cs) throws FactoryException
    Creates a geographic CRS with a datum that may be a datum ensemble. If the given `datum` argument is a datum ensemble viewed as a pseudo-datum, then it is used as the `ensemble` argument of the above constructor.
    Specified by:
      `createGeographicCRS` in interface `CRSFactory`
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - the geodetic reference frame or datum ensemble viewed as a pseudo-datum.
      `cs` - the two- or three-dimensional ellipsoidal coordinate system for the created CRS.
    Returns:
      the coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### createDatumEnsemble

    public <D extends Datum> DefaultDatumEnsemble<D> createDatumEnsemble(Map<String,?> properties, Collection<? extends D> members, PositionalAccuracy accuracy) throws FactoryException
    Creates a datum ensemble from a collection of members and an ensemble accuracy.
    Upcoming API change — generalization
    The element type will be changed to the `DatumEnsemble` interface when GeoAPI will provide it (tentatively in GeoAPI 3.1).
    Type Parameters:
      `D` - the type of datum contained in the ensemble.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `members` - datum or reference frames which are members of the datum ensemble.
      `accuracy` - inaccuracy introduced through use of the given collection of datums.
    Returns:
      the datum ensemble for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5

  - ### createGeodeticDatum

    public GeodeticDatum createGeodeticDatum(Map<String,?> properties, Ellipsoid ellipsoid, PrimeMeridian primeMeridian) throws FactoryException
    Creates a static geodetic reference frame from ellipsoid and (optionally) Bursa-Wolf parameters. Geodetic reference frame defines the location and orientation of an ellipsoid that approximates the shape of the earth. This datum can be used with geographic and geocentric CRS.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. One of:
       - `createEllipsoid(Map, double, double, Unit)`
       - `createFlattenedSphere(Map, double, double, Unit)`
    2. `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 reference frame.
      `primeMeridian` - the prime meridian to use in new geodetic reference frame.
    Returns:
      The datum for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultGeodeticDatum(Map, Ellipsoid, PrimeMeridian)`
      - `GeodeticAuthorityFactory​.createGeodeticDatum(String)`

  - ### createGeodeticDatum

    public GeodeticDatum createGeodeticDatum(Map<String,?> properties, Ellipsoid ellipsoid, PrimeMeridian primeMeridian, Temporal epoch) throws FactoryException
    Creates a dynamic geodetic reference frame from ellipsoid and frame reference epoch. The arguments are the same as for the static datum, with the addition of a mandatory frame reference epoch.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `ellipsoid` - the ellipsoid to use in new geodetic reference frame.
      `primeMeridian` - the prime meridian to use in new geodetic reference frame.
      `epoch` - the epoch to which the definition of the dynamic reference frame is referenced.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `Dynamic(Map, Ellipsoid, PrimeMeridian, Temporal)`
      - `GeodeticAuthorityFactory​.createGeodeticDatum(String)`

  - ### 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.
    Returns:
      The prime meridian for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultPrimeMeridian(Map, double, Unit)`
      - `GeodeticAuthorityFactory​.createPrimeMeridian(String)`

  - ### 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).

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createEllipsoidalCS(String)`

  - ### 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).

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createEllipsoidalCS(String)`

  - ### 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.
    Returns:
      The ellipsoid for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultEllipsoid​.createEllipsoid(Map, double, double, Unit)`
      - `GeodeticAuthorityFactory​.createEllipsoid(String)`

  - ### 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.
    Returns:
      The ellipsoid for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultEllipsoid​.createFlattenedSphere(Map, double, double, Unit)`
      - `GeodeticAuthorityFactory​.createEllipsoid(String)`

  - ### createProjectedCRS

    public ProjectedCRS createProjectedCRS(Map<String,?> properties, GeographicCRS baseCRS, Conversion baseToDerived, 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
    3. `createEllipsoidalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
    4. One of:
       - `createEllipsoid(Map, double, double, Unit)`
       - `createFlattenedSphere(Map, double, double, Unit)`
    5. `createPrimeMeridian(Map, double, Unit)`
    6. `createGeodeticDatum(Map, Ellipsoid, PrimeMeridian)`
    7. `createGeographicCRS(Map, GeodeticDatum, EllipsoidalCS)`
    8. `DefaultCoordinateOperationFactory​.createDefiningConversion(Map, OperationMethod, ParameterValueGroup)`
    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.
      `baseToDerived` - the defining conversion from a normalized base to a normalized derived CRS.
      `derivedCS` - the coordinate system for the projected CRS.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultProjectedCRS(Map, GeographicCRS, Conversion, CartesianCS)`
      - `GeodeticAuthorityFactory​.createProjectedCRS(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultCartesianCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createCartesianCS(String)`

  - ### createDerivedCRS

    public DerivedCRS createDerivedCRS(Map<String,?> properties, CoordinateReferenceSystem baseCRS, Conversion baseToDerived, 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. A `createFooCS(…)` method for Cartesian, spherical, ellipsoidal, vertical, temporal, linear, affine, polar, cylindrical or user-defined CS.
    3. Another `createFooCRS(…)` method for geocentric, geographic, vertical, temporal or engineering CRS.
    4. `DefaultCoordinateOperationFactory​.createDefiningConversion(Map, OperationMethod, ParameterValueGroup)`
    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`.
      `baseToDerived` - the defining conversion from a normalized base to a normalized derived CRS.
      `derivedCS` - the coordinate system for the derived CRS.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultDerivedCRS​.create(Map, SingleCRS, Conversion, CoordinateSystem)`
      - `GeodeticAuthorityFactory​.createDerivedCRS(String)`

  - ### createVerticalCRS

    public VerticalCRS createVerticalCRS(Map<String,?> properties, VerticalDatum datum, DefaultDatumEnsemble<VerticalDatum> ensemble, 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createVerticalCS(Map, CoordinateSystemAxis)`
    3. `createVerticalDatum(Map, VerticalDatumType)`
    4. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultVerticalCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - vertical reference frame, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of reference frames which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the vertical coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultVerticalCRS(Map, VerticalDatum, DefaultDatumEnsemble, VerticalCS)`
      - `GeodeticAuthorityFactory​.createVerticalCRS(String)`

  - ### createVerticalCRS

    public VerticalCRS createVerticalCRS(Map<String,?> properties, VerticalDatum datum, VerticalCS cs) throws FactoryException
    Creates a vertical CRS with a datum that may be a datum ensemble. If the given `datum` argument is a datum ensemble viewed as a pseudo-datum, then it is used as the `ensemble` argument of the above constructor.
    Specified by:
      `createVerticalCRS` in interface `CRSFactory`
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - the vertical reference frame or datum ensemble viewed as a pseudo-datum.
      `cs` - the vertical coordinate system for the created CRS.
    Returns:
      the coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### 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).
    Returns:
      The datum for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultVerticalDatum(Map, VerticalDatumType)`
      - `GeodeticAuthorityFactory​.createVerticalDatum(String)`

  - ### createVerticalDatum

    public VerticalDatum createVerticalDatum(Map<String,?> properties, VerticalDatumType type, Temporal epoch) throws FactoryException
    Creates a dynamic vertical datum from an enumerated type value and a frame reference epoch. The arguments are the same as for the static datum, with the addition of a mandatory frame reference epoch.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `type` - the type of this vertical datum (often geoidal).
      `epoch` - the epoch to which the definition of the dynamic reference frame is referenced.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `Dynamic(Map, VerticalDatumType, Temporal)`
      - `GeodeticAuthorityFactory​.createVerticalDatum(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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”).
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultVerticalCS(Map, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createVerticalCS(String)`

  - ### createTemporalCRS

    public TemporalCRS createTemporalCRS(Map<String,?> properties, TemporalDatum datum, DefaultDatumEnsemble<TemporalDatum> ensemble, TimeCS cs) throws FactoryException
    Creates a temporal coordinate reference system.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createTimeCS(Map, CoordinateSystemAxis)`
    3. `createTemporalDatum(Map, Date)`
    4. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultTemporalCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - temporal datum, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of datum which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the temporal coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultTemporalCRS(Map, TemporalDatum, DefaultDatumEnsemble, TimeCS)`
      - `GeodeticAuthorityFactory​.createTemporalCRS(String)`

  - ### createTemporalCRS

    public TemporalCRS createTemporalCRS(Map<String,?> properties, TemporalDatum datum, TimeCS cs) throws FactoryException
    Creates a temporal CRS with a datum that may be a datum ensemble. If the given `datum` argument is a datum ensemble viewed as a pseudo-datum, then it is used as the `ensemble` argument of the above constructor.
    Specified by:
      `createTemporalCRS` in interface `CRSFactory`
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - the temporal datum or datum ensemble viewed as a pseudo-datum.
      `cs` - the temporal coordinate system for the created CRS.
    Returns:
      the coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### 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.
    Returns:
      The datum for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultTemporalDatum(Map, Date)`
      - `GeodeticAuthorityFactory​.createTemporalDatum(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultTimeCS(Map, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createTimeCS(String)`

  - ### createParametricCRS

    public DefaultParametricCRS createParametricCRS(Map<String,?> properties, DefaultParametricDatum datum, DefaultDatumEnsemble<DefaultParametricDatum> ensemble, DefaultParametricCS cs) throws FactoryException
    Creates a parametric coordinate reference system. Parametric CRS can be used for physical properties or functions that vary monotonically with height. A typical example is the pressure in meteorological applications.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. `createParametricCS(Map, CoordinateSystemAxis)`
    3. `createParametricDatum(Map)`
    4. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultParametricCRS` instance.
    Warning: in a future SIS version, the parameter types may be changed to `org​.opengis​.referencing​.datum​.ParametricDatum` and `org​.opengis​.referencing​.cs​.ParametricCS`, and the return type may be changed to `org​.opengis​.referencing​.crs​.ParametricCRS`. Those change are pending GeoAPI revision.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - parametric datum, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of datum which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the parametric coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - `DefaultParametricCRS(Map, DefaultParametricDatum, DefaultDatumEnsemble, ParametricCS)`
      - `GeodeticAuthorityFactory​.createParametricCRS(String)`

  - ### createParametricCRS

    public DefaultParametricCRS createParametricCRS(Map<String,?> properties, DefaultParametricDatum datum, DefaultParametricCS cs) throws FactoryException
    Creates a parametric CRS from a datum. This is a shortcut for the more generic method without datum ensemble.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - the parametric datum or datum ensemble viewed as a pseudo-datum.
      `cs` - the parametric coordinate system for the created CRS.
    Returns:
      the coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### createParametricDatum

    public DefaultParametricDatum createParametricDatum(Map<String,?> properties) throws FactoryException
    Creates a parametric datum. The default implementation creates a `DefaultParametricDatum` instance.
    Warning: in a future SIS version, the return type may be changed to `org​.opengis​.referencing​.datum​.ParametricDatum`. This change is pending GeoAPI revision.
    Parameters:
      `properties` - name and other properties to give to the new object.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultParametricDatum(Map)`
      - `GeodeticAuthorityFactory​.createParametricDatum(String)`

  - ### createParametricCS

    public DefaultParametricCS createParametricCS(Map<String,?> properties, CoordinateSystemAxis axis) throws FactoryException
    Creates a parametric coordinate system. This coordinate system can be used only with parametric CRS.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    The default implementation creates a `DefaultParametricCS` instance.
    Warning: in a future SIS version, the return type may be changed to `org​.opengis​.referencing​.cs​.ParametricCS`. This change is pending GeoAPI revision.
    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:
      - `DefaultParametricCS(Map, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createParametricCS(String)`

  - ### createCompoundCRS

    public CompoundCRS createCompoundCRS(Map<String,?> properties, CoordinateReferenceSystem... components) throws FactoryException
    Creates a compound coordinate reference system from an ordered list of CRS components. Apache SIS is permissive on the order of 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:
    1. A mandatory horizontal CRS (only one of two-dimensional `GeographicCRS` or `ProjectedCRS` or `EngineeringCRS`).
    2. Optionally followed by a `VerticalCRS` or a `ParametricCRS` (but not both).
    3. 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.
      `components` - the sequence of coordinate reference systems making the compound CRS.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultCompoundCRS(Map, CoordinateReferenceSystem...)`
      - `GeodeticAuthorityFactory​.createCompoundCRS(String)`
      - `CRS​.compound(CoordinateReferenceSystem...)`

  - ### createImageCRS

    @Deprecated(since="1.5") public ImageCRS createImageCRS(Map<String,?> properties, ImageDatum datum, AffineCS cs) throws FactoryException
    Deprecated.
    The `ImageCRS` class has been removed in ISO 19111:2019. It is replaced by `EngineeringCRS`.
    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.
    Returns:
      The coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultImageCRS(Map, ImageDatum, AffineCS)`
      - `GeodeticAuthorityFactory​.createImageCRS(String)`

  - ### createImageDatum

    @Deprecated(since="1.5") public ImageDatum createImageDatum(Map<String,?> properties, PixelInCell pixelInCell) throws FactoryException
    Deprecated.
    The `ImageDatum` class has been removed in ISO 19111:2019. It is replaced by `EngineeringDatum`.
    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.
    Returns:
      The datum for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultImageDatum(Map, PixelInCell)`
      - `GeodeticAuthorityFactory​.createImageDatum(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultAffineCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`

  - ### createEngineeringCRS

    public EngineeringCRS createEngineeringCRS(Map<String,?> properties, EngineeringDatum datum, DefaultDatumEnsemble<EngineeringDatum> ensemble, 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `createCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
    2. A `createFooCS(…)` method for Cartesian, spherical, linear, affine, polar, cylindrical or user-defined CS.
    3. `createEngineeringDatum(Map)`
    4. `createDatumEnsemble(Map, Collection, PositionalAccuracy)` (optional)
    At least one of the `datum` and `ensemble` arguments shall be non-null. The default implementation creates a `DefaultEngineeringCRS` instance.
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - engineering datum, or `null` if the CRS is associated only to a datum ensemble.
      `ensemble` - collection of datum which for low accuracy requirements may be considered to be insignificantly different from each other, or `null` if there is no such ensemble.
      `cs` - the coordinate system for the created CRS.
    Throws:
      `FactoryException` - if the object creation failed.
    Since:
      1.5
    See Also:
      - invalid reference

            DefaultEngineeringCRS#DefaultEngineeringCRS(Map, EngineeringDatum, CoordinateSystem)

      - `GeodeticAuthorityFactory​.createEngineeringCRS(String)`

  - ### createEngineeringCRS

    public EngineeringCRS createEngineeringCRS(Map<String,?> properties, EngineeringDatum datum, CoordinateSystem cs) throws FactoryException
    Creates a engineering CRS with a datum that may be a datum ensemble. If the given `datum` argument is a datum ensemble viewed as a pseudo-datum, then it is used as the `ensemble` argument of the above constructor.
    Specified by:
      `createEngineeringCRS` in interface `CRSFactory`
    Parameters:
      `properties` - name and other properties to give to the new object.
      `datum` - the engineering datum or datum ensemble viewed as a pseudo-datum.
      `cs` - the coordinate system for the created CRS.
    Returns:
      the coordinate reference system for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.

  - ### 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.
    Returns:
      The datum for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultEngineeringDatum(Map)`
      - `GeodeticAuthorityFactory​.createEngineeringDatum(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultAffineCS(Map, CoordinateSystemAxis, 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultCylindricalCS(Map, CoordinateSystemAxis, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createCylindricalCS(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultPolarCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`
      - `GeodeticAuthorityFactory​.createPolarCS(String)`

  - ### 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.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultLinearCS(Map, CoordinateSystemAxis)`

  - ### createUserDefinedCS

    @Deprecated(since="1.5") public UserDefinedCS createUserDefinedCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1) throws FactoryException
    Deprecated.
    The `UserDefinedCS` class has been removed from ISO 19111:2019.
    Creates a two-dimensional user defined coordinate system from the given pair of axis. This coordinate system can be used with engineering CRS.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultUserDefinedCS(Map, CoordinateSystemAxis, CoordinateSystemAxis)`

  - ### createUserDefinedCS

    @Deprecated(since="1.5") public UserDefinedCS createUserDefinedCS(Map<String,?> properties, CoordinateSystemAxis axis0, CoordinateSystemAxis axis1, CoordinateSystemAxis axis2) throws FactoryException
    Deprecated.
    The `UserDefinedCS` class has been removed from ISO 19111:2019.
    Creates a three-dimensional user defined coordinate system from the given set of axis. This coordinate system can be used with engineering CRS.

    #### Dependencies

    The components needed by this method can be created by the following methods:
    1. `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.
    Returns:
      The coordinate system for the given properties and axes.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `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.
    Returns:
      The axis for the given properties.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `DefaultCoordinateSystemAxis(Map, String, AxisDirection, Unit)`
      - `GeodeticAuthorityFactory​.createCoordinateSystemAxis(String)`

  - ### 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.
    Returns:
      The coordinate reference system for the given XML.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `XML​.unmarshal(String)`
      - `CRS​.fromXML(String)`

  - ### createFromWKT

    public CoordinateReferenceSystem createFromWKT(String wkt) 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",
          BaseGeogCRS["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]]

    #### Logging

    If the given text contains non-fatal anomalies (unknown or unsupported WKT elements, inconsistent unit definitions, unparsable axis abbreviations, etc.), warnings may be reported in a logger named `"org​.apache​.sis​.io​.wkt"`. However, this parser does not verify if the overall parsed object matches the EPSG (or other authority) definition, since this geodetic object factory is not an authority factory. For such verification, see the `CRS​.fromWKT(String)` convenience method.

    #### 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 number of WKT strings should consider to use the `WKTFormat` class instead of this method.
    Specified by:
      `createFromWKT` in interface `CRSFactory`
    Specified by:
      `createFromWKT` in interface `Parser`
    Parameters:
      `wkt` - coordinate system encoded in Well-Known Text format (version 1 or 2).
    Returns:
      The coordinate reference system for the given WKT.
    Throws:
      `FactoryException` - if the object creation failed.
    See Also:
      - `org​.apache​.sis​.io​.wkt`
      - `CRS​.fromWKT(String)`