Class GeodeticObjectFactory

java.lang.Object
org.apache.sis.util.iso.AbstractFactory
org.apache.sis.referencing.factory.GeodeticObjectFactory
All Implemented Interfaces:
Parser, org.opengis.referencing.crs.CRSFactory, org.opengis.referencing.cs.CSFactory, org.opengis.referencing.datum.DatumFactory, org.opengis.referencing.ObjectFactory, org.opengis.util.Factory

public class GeodeticObjectFactory extends AbstractFactory implements org.opengis.referencing.crs.CRSFactory, org.opengis.referencing.cs.CSFactory, org.opengis.referencing.datum.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()
"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
Version:
1.2
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    private final Map<String,?>
    The default properties, or an empty map if none.
    private static final Logger
    The logger to use for reporting object creations.
    private org.opengis.referencing.operation.MathTransformFactory
    The math transform factory.
    private final AtomicReference<Parser>
    The Well Known Text parser for CoordinateReferenceSystem instances.
    private static Constructor<? extends Parser>
    The constructor for WKT parsers, fetched when first needed.
    Weak references to existing objects (CRS, CS, Datum, Ellipsoid or PrimeMeridian).
  • Constructor Summary

    Constructors
    Constructor
    Description
    Constructs a factory with no default 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.
    org.opengis.referencing.cs.AffineCS
    createAffineCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1)
    Creates a two-dimensional affine coordinate system from the given pair of axis.
    org.opengis.referencing.cs.AffineCS
    createAffineCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates a three-dimensional affine coordinate system from the given set of axis.
    org.opengis.referencing.cs.CartesianCS
    createCartesianCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1)
    Creates a two-dimensional Cartesian coordinate system from the given pair of axis.
    org.opengis.referencing.cs.CartesianCS
    createCartesianCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates a three-dimensional Cartesian coordinate system from the given set of axis.
    org.opengis.referencing.crs.CompoundCRS
    createCompoundCRS(Map<String,?> properties, org.opengis.referencing.crs.CoordinateReferenceSystem... components)
    Creates a compound coordinate reference system from an ordered list of CRS components.
    org.opengis.referencing.cs.CoordinateSystemAxis
    createCoordinateSystemAxis(Map<String,?> properties, String abbreviation, org.opengis.referencing.cs.AxisDirection direction, javax.measure.Unit<?> unit)
    Creates a coordinate system axis from an abbreviation and a unit.
    org.opengis.referencing.cs.CylindricalCS
    createCylindricalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates a cylindrical coordinate system from the given set of axis.
    org.opengis.referencing.crs.DerivedCRS
    createDerivedCRS(Map<String,?> properties, org.opengis.referencing.crs.CoordinateReferenceSystem baseCRS, org.opengis.referencing.operation.Conversion conversion, org.opengis.referencing.cs.CoordinateSystem derivedCS)
    Creates a derived coordinate reference system from a conversion.
    org.opengis.referencing.datum.Ellipsoid
    createEllipsoid(Map<String,?> properties, double semiMajorAxis, double semiMinorAxis, javax.measure.Unit<javax.measure.quantity.Length> unit)
    Creates an ellipsoid from semi-axis length values.
    org.opengis.referencing.cs.EllipsoidalCS
    createEllipsoidalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1)
    Creates an ellipsoidal coordinate system without ellipsoidal height.
    org.opengis.referencing.cs.EllipsoidalCS
    createEllipsoidalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates an ellipsoidal coordinate system with ellipsoidal height.
    org.opengis.referencing.crs.EngineeringCRS
    createEngineeringCRS(Map<String,?> properties, org.opengis.referencing.datum.EngineeringDatum datum, org.opengis.referencing.cs.CoordinateSystem cs)
    Creates a engineering coordinate reference system.
    org.opengis.referencing.datum.EngineeringDatum
    Creates an engineering datum.
    org.opengis.referencing.datum.Ellipsoid
    createFlattenedSphere(Map<String,?> properties, double semiMajorAxis, double inverseFlattening, javax.measure.Unit<javax.measure.quantity.Length> unit)
    Creates an ellipsoid from a major semi-axis length and inverse flattening.
    org.opengis.referencing.crs.CoordinateReferenceSystem
    Creates a Coordinate Reference System object from a Well Known Text (WKT).
    org.opengis.referencing.crs.CoordinateReferenceSystem
    Creates a coordinate reference system object from a XML string.
    org.opengis.referencing.crs.GeocentricCRS
    createGeocentricCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.CartesianCS cs)
    Creates a geocentric coordinate reference system from a Cartesian coordinate system.
    org.opengis.referencing.crs.GeocentricCRS
    createGeocentricCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.SphericalCS cs)
    Creates a geocentric coordinate reference system from a spherical coordinate system.
    org.opengis.referencing.datum.GeodeticDatum
    createGeodeticDatum(Map<String,?> properties, org.opengis.referencing.datum.Ellipsoid ellipsoid, org.opengis.referencing.datum.PrimeMeridian primeMeridian)
    Creates geodetic datum from ellipsoid and (optionally) Bursa-Wolf parameters.
    org.opengis.referencing.crs.GeographicCRS
    createGeographicCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.EllipsoidalCS cs)
    Creates a geographic coordinate reference system.
    org.opengis.referencing.crs.ImageCRS
    createImageCRS(Map<String,?> properties, org.opengis.referencing.datum.ImageDatum datum, org.opengis.referencing.cs.AffineCS cs)
    Creates an image coordinate reference system.
    org.opengis.referencing.datum.ImageDatum
    createImageDatum(Map<String,?> properties, org.opengis.referencing.datum.PixelInCell pixelInCell)
    Creates an image datum.
    org.opengis.referencing.cs.LinearCS
    createLinearCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis)
    Creates a linear coordinate system.
    Creates a parametric coordinate reference system.
    createParametricCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis)
    Creates a parametric coordinate system.
    Creates a parametric datum.
    org.opengis.referencing.cs.PolarCS
    createPolarCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1)
    Creates a polar coordinate system from the given pair of axis.
    org.opengis.referencing.datum.PrimeMeridian
    createPrimeMeridian(Map<String,?> properties, double longitude, javax.measure.Unit<javax.measure.quantity.Angle> angularUnit)
    Creates a prime meridian, relative to Greenwich.
    org.opengis.referencing.crs.ProjectedCRS
    createProjectedCRS(Map<String,?> properties, org.opengis.referencing.crs.GeographicCRS baseCRS, org.opengis.referencing.operation.Conversion conversion, org.opengis.referencing.cs.CartesianCS derivedCS)
    Creates a projected coordinate reference system from a conversion.
    org.opengis.referencing.cs.SphericalCS
    createSphericalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates a spherical coordinate system from the given set of axis.
    org.opengis.referencing.crs.TemporalCRS
    createTemporalCRS(Map<String,?> properties, org.opengis.referencing.datum.TemporalDatum datum, org.opengis.referencing.cs.TimeCS cs)
    Creates a temporal coordinate reference system.
    org.opengis.referencing.datum.TemporalDatum
    createTemporalDatum(Map<String,?> properties, Date origin)
    Creates a temporal datum from an enumerated type value.
    org.opengis.referencing.cs.TimeCS
    createTimeCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis)
    Creates a temporal coordinate system.
    org.opengis.referencing.cs.UserDefinedCS
    createUserDefinedCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1)
    Creates a two-dimensional user defined coordinate system from the given pair of axis.
    org.opengis.referencing.cs.UserDefinedCS
    createUserDefinedCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2)
    Creates a three-dimensional user defined coordinate system from the given set of axis.
    org.opengis.referencing.crs.VerticalCRS
    createVerticalCRS(Map<String,?> properties, org.opengis.referencing.datum.VerticalDatum datum, org.opengis.referencing.cs.VerticalCS cs)
    Creates a vertical coordinate reference system.
    org.opengis.referencing.cs.VerticalCS
    createVerticalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis)
    Creates a vertical coordinate system.
    org.opengis.referencing.datum.VerticalDatum
    createVerticalDatum(Map<String,?> properties, org.opengis.referencing.datum.VerticalDatumType type)
    Creates a vertical datum from an enumerated type value.
    (package private) final org.opengis.referencing.operation.MathTransformFactory
    Returns the math transform factory for internal usage only.
    private <T extends AbstractIdentifiedObject>
    T
    unique(String caller, T object)
    Returns a unique instance of the given object.

    Methods inherited from class org.apache.sis.util.iso.AbstractFactory

    getVendor

    Methods inherited from class java.lang.Object

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

    Methods inherited from interface org.opengis.util.Factory

    getVendor
  • Field Details

    • LOGGER

      private static final Logger LOGGER
      The logger to use for reporting object creations.
    • parserConstructor

      private static volatile Constructor<? extends Parser> parserConstructor
      The constructor for WKT parsers, fetched when first needed. The WKT parser is defined in the same module than this class, so we will hopefully not have security issues. But we have to use reflection because the parser class is not yet public (because we do not want to commit its API yet).
    • defaultProperties

      private final Map<String,?> defaultProperties
      The default properties, or an empty map if none. This map shall not change after construction in order to allow usage without synchronization in multi-thread context. But we do not need to wrap in a unmodifiable map since GeodeticObjectFactory does not provide public access to it.
    • mtFactory

      private volatile org.opengis.referencing.operation.MathTransformFactory mtFactory
      The math transform factory. Will be created only when first needed. This is normally not needed by this factory, except when constructing derived and projected CRS.
      See Also:
    • pool

      Weak references to existing objects (CRS, CS, Datum, Ellipsoid or PrimeMeridian). This set is used in order to return a pre-existing object instead of creating a new one.
    • parser

      private final AtomicReference<Parser> parser
      The Well Known Text parser for CoordinateReferenceSystem instances. This parser is not thread-safe, so we need to prevent two threads from using the same instance at the same time.
  • Constructor Details

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

    • 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.
    • getMathTransformFactory

      final org.opengis.referencing.operation.MathTransformFactory getMathTransformFactory()
      Returns the math transform factory for internal usage only. The MathTransformFactory is normally not needed by GeodeticObjectFactory, except when constructing the Apache SIS implementation of derived and projected CRS. For this reason, we will fetch this dependency only if really requested.
    • unique

      private <T extends AbstractIdentifiedObject> T unique(String caller, T object)
      Returns a unique instance of the given object. If this method recycles an existing object, then the existing instance is returned silently. Otherwise this method logs a message at Level.FINE or Level.FINER telling that a new object has been created. The finer level is used if the object has been creating during an operation that creates a lot of candidates in search for a CRS matching some criterion.
    • createGeocentricCRS

      public org.opengis.referencing.crs.GeocentricCRS createGeocentricCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.CartesianCS cs) throws org.opengis.util.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. The default implementation creates a DefaultGeocentricCRS instance.
      Specified by:
      createGeocentricCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createCartesianCS

      public org.opengis.referencing.cs.CartesianCS createCartesianCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createGeocentricCRS

      public org.opengis.referencing.crs.GeocentricCRS createGeocentricCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.SphericalCS cs) throws org.opengis.util.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. The default implementation creates a DefaultGeocentricCRS instance.
      Specified by:
      createGeocentricCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createSphericalCS

      public org.opengis.referencing.cs.SphericalCS createSphericalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createGeographicCRS

      public org.opengis.referencing.crs.GeographicCRS createGeographicCRS(Map<String,?> properties, org.opengis.referencing.datum.GeodeticDatum datum, org.opengis.referencing.cs.EllipsoidalCS cs) throws org.opengis.util.FactoryException
      Creates a geographic coordinate reference system. It can be (latitude, longitude) or (longitude, latitude), optionally with an ellipsoidal height. The default implementation creates a DefaultGeographicCRS instance.
      Specified by:
      createGeographicCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createGeodeticDatum

      public org.opengis.referencing.datum.GeodeticDatum createGeodeticDatum(Map<String,?> properties, org.opengis.referencing.datum.Ellipsoid ellipsoid, org.opengis.referencing.datum.PrimeMeridian primeMeridian) throws org.opengis.util.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.
      Dependencies: the components needed by this method can be created by the following methods:
      1. One of:
      2. createPrimeMeridian(Map, double, Unit)
      The default implementation creates a DefaultGeodeticDatum instance.
      Specified by:
      createGeodeticDatum in interface org.opengis.referencing.datum.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createPrimeMeridian

      public org.opengis.referencing.datum.PrimeMeridian createPrimeMeridian(Map<String,?> properties, double longitude, javax.measure.Unit<javax.measure.quantity.Angle> angularUnit) throws org.opengis.util.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 org.opengis.referencing.datum.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createEllipsoidalCS

      public org.opengis.referencing.cs.EllipsoidalCS createEllipsoidalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createEllipsoidalCS

      public org.opengis.referencing.cs.EllipsoidalCS createEllipsoidalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createEllipsoid

      public org.opengis.referencing.datum.Ellipsoid createEllipsoid(Map<String,?> properties, double semiMajorAxis, double semiMinorAxis, javax.measure.Unit<javax.measure.quantity.Length> unit) throws org.opengis.util.FactoryException
      Creates an ellipsoid from semi-axis length values. The default implementation creates a DefaultEllipsoid instance.
      Specified by:
      createEllipsoid in interface org.opengis.referencing.datum.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createFlattenedSphere

      public org.opengis.referencing.datum.Ellipsoid createFlattenedSphere(Map<String,?> properties, double semiMajorAxis, double inverseFlattening, javax.measure.Unit<javax.measure.quantity.Length> unit) throws org.opengis.util.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 org.opengis.referencing.datum.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createProjectedCRS

      public org.opengis.referencing.crs.ProjectedCRS createProjectedCRS(Map<String,?> properties, org.opengis.referencing.crs.GeographicCRS baseCRS, org.opengis.referencing.operation.Conversion conversion, org.opengis.referencing.cs.CartesianCS derivedCS) throws org.opengis.util.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 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 org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createCartesianCS

      public org.opengis.referencing.cs.CartesianCS createCartesianCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createDerivedCRS

      public org.opengis.referencing.crs.DerivedCRS createDerivedCRS(Map<String,?> properties, org.opengis.referencing.crs.CoordinateReferenceSystem baseCRS, org.opengis.referencing.operation.Conversion conversion, org.opengis.referencing.cs.CoordinateSystem derivedCS) throws org.opengis.util.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 org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createVerticalCRS

      public org.opengis.referencing.crs.VerticalCRS createVerticalCRS(Map<String,?> properties, org.opengis.referencing.datum.VerticalDatum datum, org.opengis.referencing.cs.VerticalCS cs) throws org.opengis.util.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 default implementation creates a DefaultVerticalCRS instance.
      Specified by:
      createVerticalCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createVerticalDatum

      public org.opengis.referencing.datum.VerticalDatum createVerticalDatum(Map<String,?> properties, org.opengis.referencing.datum.VerticalDatumType type) throws org.opengis.util.FactoryException
      Creates a vertical datum from an enumerated type value. The default implementation creates a DefaultVerticalDatum instance.
      Specified by:
      createVerticalDatum in interface org.opengis.referencing.datum.DatumFactory
      Parameters:
      properties - name and other properties to give to the new object.
      type - the type of this vertical datum (often geoidal).
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createVerticalCS

      public org.opengis.referencing.cs.VerticalCS createVerticalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis) throws org.opengis.util.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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis - the single axis (e.g. “height” or “depth”).
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createTemporalCRS

      public org.opengis.referencing.crs.TemporalCRS createTemporalCRS(Map<String,?> properties, org.opengis.referencing.datum.TemporalDatum datum, org.opengis.referencing.cs.TimeCS cs) throws org.opengis.util.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)
      The default implementation creates a DefaultTemporalCRS instance.
      Specified by:
      createTemporalCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createTemporalDatum

      public org.opengis.referencing.datum.TemporalDatum createTemporalDatum(Map<String,?> properties, Date origin) throws org.opengis.util.FactoryException
      Creates a temporal datum from an enumerated type value. The default implementation creates a DefaultTemporalDatum instance.
      Specified by:
      createTemporalDatum in interface org.opengis.referencing.datum.DatumFactory
      Parameters:
      properties - name and other properties to give to the new object.
      origin - the date and time origin of this temporal datum.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createTimeCS

      public org.opengis.referencing.cs.TimeCS createTimeCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis) throws org.opengis.util.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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis - the single axis.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createParametricCRS

      public DefaultParametricCRS createParametricCRS(Map<String,?> properties, DefaultParametricDatum datum, DefaultParametricCS cs) throws org.opengis.util.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)
      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 - the parametric datum to use in created CRS.
      cs - the parametric coordinate system for the created CRS.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createParametricDatum

      public DefaultParametricDatum createParametricDatum(Map<String,?> properties) throws org.opengis.util.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createParametricCS

      public DefaultParametricCS createParametricCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis) throws org.opengis.util.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createCompoundCRS

      public org.opengis.referencing.crs.CompoundCRS createCompoundCRS(Map<String,?> properties, org.opengis.referencing.crs.CoordinateReferenceSystem... components) throws org.opengis.util.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 org.opengis.referencing.crs.CRSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      components - the sequence of coordinate reference systems making the compound CRS.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createImageCRS

      public org.opengis.referencing.crs.ImageCRS createImageCRS(Map<String,?> properties, org.opengis.referencing.datum.ImageDatum datum, org.opengis.referencing.cs.AffineCS cs) throws org.opengis.util.FactoryException
      Creates an image coordinate reference system. The default implementation creates a DefaultImageCRS instance.
      Specified by:
      createImageCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createImageDatum

      public org.opengis.referencing.datum.ImageDatum createImageDatum(Map<String,?> properties, org.opengis.referencing.datum.PixelInCell pixelInCell) throws org.opengis.util.FactoryException
      Creates an image datum. The default implementation creates a DefaultImageDatum instance.
      Specified by:
      createImageDatum in interface org.opengis.referencing.datum.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createAffineCS

      public org.opengis.referencing.cs.AffineCS createAffineCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1) throws org.opengis.util.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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis0 - the first axis.
      axis1 - the second axis.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createEngineeringCRS

      public org.opengis.referencing.crs.EngineeringCRS createEngineeringCRS(Map<String,?> properties, org.opengis.referencing.datum.EngineeringDatum datum, org.opengis.referencing.cs.CoordinateSystem cs) throws org.opengis.util.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)
      The default implementation creates a DefaultEngineeringCRS instance.
      Specified by:
      createEngineeringCRS in interface org.opengis.referencing.crs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createEngineeringDatum

      public org.opengis.referencing.datum.EngineeringDatum createEngineeringDatum(Map<String,?> properties) throws org.opengis.util.FactoryException
      Creates an engineering datum. The default implementation creates a DefaultEngineeringDatum instance.
      Specified by:
      createEngineeringDatum in interface org.opengis.referencing.datum.DatumFactory
      Parameters:
      properties - name and other properties to give to the new object.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createAffineCS

      public org.opengis.referencing.cs.AffineCS createAffineCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createCylindricalCS

      public org.opengis.referencing.cs.CylindricalCS createCylindricalCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createPolarCS

      public org.opengis.referencing.cs.PolarCS createPolarCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1) throws org.opengis.util.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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis0 - the first axis.
      axis1 - the second axis.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createLinearCS

      public org.opengis.referencing.cs.LinearCS createLinearCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis) throws org.opengis.util.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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis - the single axis.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createUserDefinedCS

      public org.opengis.referencing.cs.UserDefinedCS createUserDefinedCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1) throws org.opengis.util.FactoryException
      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 org.opengis.referencing.cs.CSFactory
      Parameters:
      properties - name and other properties to give to the new object.
      axis0 - the first axis.
      axis1 - the second axis.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createUserDefinedCS

      public org.opengis.referencing.cs.UserDefinedCS createUserDefinedCS(Map<String,?> properties, org.opengis.referencing.cs.CoordinateSystemAxis axis0, org.opengis.referencing.cs.CoordinateSystemAxis axis1, org.opengis.referencing.cs.CoordinateSystemAxis axis2) throws org.opengis.util.FactoryException
      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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createCoordinateSystemAxis

      public org.opengis.referencing.cs.CoordinateSystemAxis createCoordinateSystemAxis(Map<String,?> properties, String abbreviation, org.opengis.referencing.cs.AxisDirection direction, javax.measure.Unit<?> unit) throws org.opengis.util.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 org.opengis.referencing.cs.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:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createFromXML

      public org.opengis.referencing.crs.CoordinateReferenceSystem createFromXML(String xml) throws org.opengis.util.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 org.opengis.referencing.crs.CRSFactory
      Parameters:
      xml - coordinate reference system encoded in XML format.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also:
    • createFromWKT

      public org.opengis.referencing.crs.CoordinateReferenceSystem createFromWKT(String text) throws org.opengis.util.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.
      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 amount of WKT strings should consider to use the WKTFormat class instead of this method.
      Specified by:
      createFromWKT in interface org.opengis.referencing.crs.CRSFactory
      Specified by:
      createFromWKT in interface Parser
      Parameters:
      text - coordinate system encoded in Well-Known Text format (version 1 or 2).
      Returns:
      the result of parsing the given text.
      Throws:
      org.opengis.util.FactoryException - if the object creation failed.
      See Also: