Class CRS


  • public final class CRS
    extends Static
    Static methods working on Coordinate Reference Systems. The methods defined in this class can be grouped in three categories:
    Usage example
    The most frequently used methods in this class are for­Code(…), from­WKT(…) and find­Operation(…). An usage example is like below (see the Apache SIS™ Coordinate Reference System (CRS) codes page for the complete list of EPSG codes):
    CoordinateReferenceSystem source = CRS.forCode("EPSG:4326");                   // WGS 84
    CoordinateReferenceSystem target = CRS.forCode("EPSG:3395");                   // WGS 84 / World Mercator
    CoordinateOperation operation = CRS.findOperation(source, target, null);
    if (CRS.getLinearAccuracy(operation) > 100) {
        // If the accuracy is coarser than 100 metres (or any other threshold at application choice)
        // maybe the operation is not suitable. Decide here what to do (throw an exception, etc).
    }
    MathTransform mt = operation.getMathTransform();
    DirectPosition position = new DirectPosition2D(20, 30);            // 20°N 30°E   (watch out axis order!)
    position = mt.transform(position, position);
    System.out.println(position);
    Note on kinds of CRS
    The get­Single­Components(Coordinate­Reference­System) method decomposes an arbitrary CRS into a flat list of single components. In such flat list, vertical and temporal components can easily be identified by instanceof checks. But identifying the horizontal component is not as easy. The list below suggests ways to classify the components:
    • if (crs instanceof Temporal­CRS) determines if the CRS is for the temporal component.
    • if (crs instanceof Vertical­CRS) determines if the CRS is for the vertical component.
    • if (CRS.is­Horizontal­CRS(crs)) determines if the CRS is for the horizontal component.
    Since:
    0.3

    Defined in the sis-referencing module

    • Method Detail

      • forCode

        public static CoordinateReferenceSystem forCode​(String code)
                                                 throws NoSuchAuthorityCodeException,
                                                        FactoryException
        Returns the Coordinate Reference System for the given authority code. The set of available codes depends on the CRSAuthority­Factory instances available on the classpath. There is many thousands of CRS defined by EPSG authority or by other authorities. The following table lists a very small subset of codes which are guaranteed to be available on any installation of Apache SIS:
        Minimal set of supported authority codes
        Code Enum CRS Type Description
        CRS:27 NAD27 Geographic Like EPSG:4267 except for (longitude, latitude) axis order
        CRS:83 NAD83 Geographic Like EPSG:4269 except for (longitude, latitude) axis order
        CRS:84 WGS84 Geographic Like EPSG:4326 except for (longitude, latitude) axis order
        EPSG:4047 SPHERE Geographic GRS 1980 Authalic Sphere
        EPSG:4230 ED50 Geographic European Datum 1950
        EPSG:4258 ETRS89 Geographic European Terrestrial Reference Frame 1989
        EPSG:4267 NAD27 Geographic North American Datum 1927
        EPSG:4269 NAD83 Geographic North American Datum 1983
        EPSG:4322 WGS72 Geographic World Geodetic System 1972
        EPSG:4326 WGS84 Geographic World Geodetic System 1984
        EPSG:4936 ETRS89 Geocentric European Terrestrial Reference Frame 1989
        EPSG:4937 ETRS89 Geographic 3D European Terrestrial Reference Frame 1989
        EPSG:4978 WGS84 Geocentric World Geodetic System 1984
        EPSG:4979 WGS84 Geographic 3D World Geodetic System 1984
        EPSG:4984 WGS72 Geocentric World Geodetic System 1972
        EPSG:4985 WGS72 Geographic 3D World Geodetic System 1972
        EPSG:5041 WGS84 Projected WGS 84 / UPS North (E,N)
        EPSG:5042 WGS84 Projected WGS 84 / UPS South (E,N)
        EPSG:322##WGS72 Projected WGS 72 / UTM zone ##N
        EPSG:323##WGS72 Projected WGS 72 / UTM zone ##S
        EPSG:326##WGS84 Projected WGS 84 / UTM zone ##N
        EPSG:327##WGS84 Projected WGS 84 / UTM zone ##S
        EPSG:5715 DEPTH Vertical Mean Sea Level depth
        EPSG:5714 MEAN_SEA_LEVEL Vertical Mean Sea Level height
        This method accepts also the URN and URL syntaxes. For example the following codes are considered equivalent to "EPSG:4326":
        • "EPSG::4326"
        • "urn:ogc:def:crs:EPSG::4326"
        • "http://www​.opengis​.net/def/crs/epsg/0/4326"
        • "http://www​.opengis​.net/gml/srs/epsg​.xml#4326"
        URIs can be combined for creating larger objects. For example the following URIs combine a two-dimensional WGS84 reference system (EPSG:4326) with a Mean Sea Level height (EPSG:5714). The result is a three-dimensional compound coordinate reference system:
        • "urn:ogc:def:crs,crs:EPSG::4326,crs:EPSG::5714"
        • "http://www​.opengis​.net/def/crs-compound?
          1=http://www​.opengis​.net/def/crs/epsg/0/4326&
          2=http://www​.opengis​.net/def/crs/epsg/0/5714"

        URNs (but not URLs) can also combine a geodetic datum with an ellipsoidal coordinate system for creating a new geographic CRS, or a base geographic CRS with a conversion and a Cartesian coordinate system for creating a new projected coordinate reference system.

        Note that the Identified­Objects​.lookup­URN(Identified­Object, Citation) method can be seen as a converse of this method. More codes may also be supported depending on which extension modules are available.
        Parameters:
        code - the authority code.
        Returns:
        the Coordinate Reference System for the given authority code.
        Throws:
        No­Such­Authority­Code­Exception - if there is no known CRS associated to the given code.
        Factory­Exception - if the CRS creation failed for an other reason.
        See Also:
        get­Authority­Factory(String), Geodetic­Authority­Factory, EPSG Geodetic Registry
      • fromWKT

        public static CoordinateReferenceSystem fromWKT​(String text)
                                                 throws FactoryException
        Creates a Coordinate Reference System object from a Well Known Text (WKT). The default Apache SIS parser understands both version 1 (a.k.a. OGC 01-009) and version 2 (a.k.a. ISO 19162) of the WKT format.
        Example: below is a slightly simplified WKT 2 string for a Mercator projection. For making this example smaller, some optional UNIT[…] and ORDER[…] elements have been omitted.
        ProjectedCRS["SIRGAS 2000 / Brazil Mercator",
          BaseGeodCRS["SIRGAS 2000",
            Datum["Sistema de Referencia Geocentrico para las Americas 2000",
              Ellipsoid["GRS 1980", 6378137, 298.257222101]]],
          Conversion["Petrobras Mercator",
            Method["Mercator (variant B)", Id["EPSG",9805]],
            Parameter["Latitude of 1st standard parallel", -2],
            Parameter["Longitude of natural origin", -43],
            Parameter["False easting", 5000000],
            Parameter["False northing", 10000000]],
          CS[cartesian,2],
            Axis["easting (E)", east],
            Axis["northing (N)", north],
            LengthUnit["metre", 1],
          Id["EPSG",5641]]
        If the parsing produced warnings, they will be reported in a logger named "org​.apache​.sis​.io​.wkt". In particular, this method verifies if the description provided by the WKT matches the description provided by the authority ("EPSG:5641" in above example) and reports discrepancies. Note that this comparison between parsed CRS and authoritative CRS is specific to this convenience method; other APIs documented in see also section do not perform this comparison automatically. Should the WKT description and the authoritative description be in conflict, the WKT description prevails as mandated by ISO 19162 standard (see from­Authority(…) if a different behavior is needed).
        Usage and performance considerations
        This convenience method delegates to Geodetic­Object­Factory​.create­From­WKT(String) using a default factory instance. This is okay for occasional use, but has the following limitations:
        • Performance may be sub-optimal in a multi-thread environment.
        • No control on the WKT conventions in use.
        • No control on the handling of warnings.
        Applications which need to parse a large amount of WKT strings should consider to use the WKTFormat class instead than this method.
        Parameters:
        text - coordinate system encoded in Well-Known Text format (version 1 or 2).
        Returns:
        the parsed Coordinate Reference System.
        Throws:
        Factory­Exception - if the given WKT can not be parsed.
        Since:
        0.6
        See Also:
        WKTFormat, Geodetic­Object­Factory​.create­From­WKT(String), Envelopes​.from­WKT(Char­Sequence), WKT 2 specification
      • fromXML

        public static CoordinateReferenceSystem fromXML​(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. For reading XML documents from readers or input streams, see static methods in the XML class.

        If the unmarshalling produced warnings, they will be reported in a logger named "org​.apache​.sis​.xml". In particular, this method verifies if the description provided by the XML matches the description provided by the authority code given in <gml:identifier> element, and reports discrepancies. Note that this comparison between unmarshalled CRS and authoritative CRS is specific to this convenience method; other APIs documented in see also section do not perform this comparison automatically. Should the XML description and the authoritative description be in conflict, the XML description prevails (see from­Authority(…) if a different behavior is needed).

        Parameters:
        xml - coordinate reference system encoded in XML format.
        Returns:
        the unmarshalled Coordinate Reference System.
        Throws:
        Factory­Exception - if the object creation failed.
        Since:
        0.7
        See Also:
        Geodetic­Object­Factory​.create­From­XML(String), XML​.unmarshal(String)
      • fromAuthority

        public static CoordinateReferenceSystem fromAuthority​(CoordinateReferenceSystem crs,
                                                              CRSAuthorityFactory factory,
                                                              Filter warningFilter)
                                                       throws FactoryException
        Replaces the given coordinate reference system by an authoritative description, if one can be found. This method can be invoked after constructing a CRS in a context where the EPSG (or other authority) code is suspected more reliable than the rest of the description. A common case is a Well Known Text (WKT) string declaring wrong projection method or parameter values for the EPSG code that it pretends to describe. For example:
        PROJCS["WGS 84 / Pseudo-Mercator",
          (…base CRS omitted for brevity…)
          PROJECTION["Mercator (variant A)"], — wrong: shall be "Popular Visualisation Pseudo Mercator"
          (…parameters and axes omitted for brevity…)
          AUTHORITY["EPSG", "3857"]]
        In such cases, Apache SIS behavior in from­WKT(String), from­XML(String) and other methods is conform to the ISO 19162 specification:
        "Should any attributes or values given in the cited identifier be in conflict with attributes or values given explicitly in the WKT description, the WKT values shall prevail."
        In situations where the opposite behavior is desired (i.e. to make the authority identifier prevails), this method can be invoked. This method performs the following actions:
        • If the given CRS has an identifier and if the authority factory can create a CRS for that identifier, then:
          • If the CRS defined by the authority is equal, ignoring metadata, to the given CRS, then this method returns silently the authoritative CRS.
          • Otherwise if the CRS defined by the authority is equal, ignoring axis order and units, to the given CRS, then this method returns a new CRS derived from the authoritative one but with same axes convention than the given CRS. A warning is emitted.
          • Otherwise this method discards the given CRS and returns the authoritative CRS. A warning is emitted with a message indicating where a difference has been found.
        • Otherwise if the given CRS does not have identifier, then this method searches for an equivalent CRS defined by the authority factory. If such CRS is found, then:
          • If the CRS defined by the authority is equal, ignoring metadata, to the given CRS, then this method returns silently the authoritative CRS.
          • Otherwise if the CRS defined by the authority is equal, ignoring axis order and units, to the given CRS, then this method returns silently a new CRS derived from the authoritative one but with same axes convention than the given CRS.
        • Otherwise this method silently returns the given CRS as-is.
        Avoiding warning redundancies
        The warnings logged by this method are redundant with warnings logged by other methods in this class, in particular from­WKT(String) and from­XML(String) methods. For avoiding this annoyance, a null value for the warning­Filter argument means to shut off those redundant loggings. A non-null warning­Filter argument is more useful for CRS parsed by methods outside this class, for example WKTFormat or XML​.unmarshal(String).
        Parameters:
        crs - the CRS to replace by an authoritative CRS, or null.
        factory - the factory where to search for authoritative definitions, or null for the default.
        warning­Filter - whether to log warnings, or null for the default behavior (which is to filter out the warnings that are redundant with warnings emitted by other methods in this class).
        Returns:
        the suggested CRS to use (may be the crs argument itself), or null if the given CRS was null.
        Throws:
        Factory­Exception - if an error occurred while querying the authority factory.
        Since:
        1.0
      • suggestCommonTarget

        public static CoordinateReferenceSystem suggestCommonTarget​(GeographicBoundingBox regionOfInterest,
                                                                    CoordinateReferenceSystem... sourceCRS)
        Suggests a coordinate reference system which could be a common target for coordinate operations having the given sources. This method compares the domain of validity of all given CRSs. If a CRS has a domain of validity that contains the domain of all other CRS, than that CRS is returned. Otherwise this method verifies if a base CRS (usually a geographic CRS instance) would be suitable. If no suitable CRS is found, then this method returns null.
        Use case: before to test if two arbitrary envelopes intersect each other, they need to be transformed in the same CRS. However if one CRS is a Transverse Mercator projection while the other CRS is a world-wide geographic CRS, then attempts to use the Transverse Mercator projection as the common CRS is likely to fail since the geographic envelope may span an area far outside the projection domain of validity. This suggest­Common­Target(…) method can used for choosing a common CRS which is less likely to fail.
        Parameters:
        region­Of­Interest - the geographic area for which the coordinate operations will be applied, or null if unknown. Will be intersected with CRS domains of validity.
        source­CRS - the coordinate reference systems for which a common target CRS is desired. May contain null elements, in which case this method returns null.
        Returns:
        a CRS that may be used as a common target for all the given source CRS in the given region of interest, or null if this method did not find a common target CRS. The returned CRS may be different than all given CRS.
        Since:
        0.8
      • getDomainOfValidity

        public static Envelope getDomainOfValidity​(CoordinateReferenceSystem crs)
        Returns the domain of validity of the specified coordinate reference system, or null if unknown. If non-null, then the returned envelope will use the same coordinate reference system them the given CRS argument.
        Parameters:
        crs - the coordinate reference system, or null.
        Returns:
        the envelope with coordinates in the given CRS, or null if none.
        Since:
        0.8
        See Also:
        get­Geographic­Bounding­Box(Coordinate­Reference­System)
      • compound

        public static CoordinateReferenceSystem compound​(CoordinateReferenceSystem... components)
                                                  throws FactoryException
        Creates a compound coordinate reference system from an ordered list of CRS components. A CRS is inferred from the given components and the domain of validity is set to the intersection of the domain of validity of all components.
        Ellipsoidal height
        If a two-dimensional geographic or projected CRS if followed or preceded by a vertical CRS with ellipsoidal datum type, then this method combines them in a single three-dimensional geographic or projected CRS. Note that standalone ellipsoidal heights are not allowed according ISO 19111. But if such situation is nevertheless found, then the action described here fixes the issue. This is the reverse of get­Vertical­Component(crs, true).
        Components order
        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 Geographic­CRS or Projected­CRS or Engineering­CRS).
        2. Optionally followed by a Vertical­CRS or a Parametric­CRS (but not both).
        3. Optionally followed by a Temporal­CRS.
        Parameters:
        components - the sequence of coordinate reference systems making the compound CRS.
        Returns:
        the compound CRS, or components[0] if the given array contains only one component.
        Throws:
        Illegal­Argument­Exception - if the given array is empty or if the array contains incompatible components.
        Factory­Exception - if the geodetic factory failed to create the compound CRS.
        Since:
        0.8
        See Also:
        Default­Compound­CRS, Geodetic­Object­Factory​.create­Compound­CRS(Map, Coordinate­Reference­System...), Envelopes​.compound(Envelope...), Math­Transforms​.compound(Math­Transform...)
      • reduce

        public static CoordinateReferenceSystem reduce​(CoordinateReferenceSystem crs,
                                                       int... dimensions)
                                                throws FactoryException
        Gets or creates a coordinate reference system with a subset of the dimensions of the given CRS. This method can be used for dimensionality reduction, but not for changing axis order. The specified dimensions are used as if they were in strictly increasing order without duplicated values.
        Ellipsoidal height
        This method can transform a three-dimensional geographic CRS into a two-dimensional geographic CRS. In this aspect, this method is the converse of compound(Coordinate­Reference­System...). This method can also extract the ellipsoidal height from a three-dimensional geographic CRS, but this is generally not recommended since ellipsoidal heights make little sense without their (latitude, longitude) locations.
        Parameters:
        crs - the CRS to reduce the dimensionality, or null if none.
        dimensions - the dimensions to retain. The dimensions will be taken in increasing order, ignoring duplicated values.
        Returns:
        a coordinate reference system for the given dimensions. May be the given crs, which may be null.
        Throws:
        Illegal­Argument­Exception - if the given array is empty or if the array contains invalid indices.
        Factory­Exception - if the geodetic factory failed to create a compound CRS.
        Since:
        1.0
        See Also:
        get­Component­At(Coordinate­Reference­System, int, int), compound(Coordinate­Reference­System...)
      • isHorizontalCRS

        public static boolean isHorizontalCRS​(CoordinateReferenceSystem crs)
        Returns true if the given CRS is horizontal. The current implementation considers a CRS as horizontal if it is two-dimensional and comply with one of the following conditions: In case of doubt, this method conservatively returns false.
        Parameters:
        crs - the coordinate reference system, or null.
        Returns:
        true if the given CRS is non-null and likely horizontal, or false otherwise.
        See Also:
        get­Horizontal­Component(Coordinate­Reference­System)
        TODO:
        Future SIS implementation may extend the above conditions list. For example a radar station could use a polar coordinate system in a Derived­CRS instance based on a projected CRS. Conversely, a future SIS versions may impose more conditions on Engineering­CRS. See SIS-161.
      • getHorizontalComponent

        public static SingleCRS getHorizontalComponent​(CoordinateReferenceSystem crs)
        Returns the first horizontal coordinate reference system found in the given CRS, or null if there is none. If the given CRS is already horizontal according is­Horizontal­CRS(Coordinate­Reference­System), then this method returns it as-is. Otherwise if the given CRS is compound, then this method searches for the first horizontal component in the order of the single components list.

        In the special case where a three-dimensional geographic or projected CRS is found, this method will create a two-dimensional geographic or projected CRS without the vertical axis.

        Parameters:
        crs - the coordinate reference system, or null.
        Returns:
        the first horizontal CRS, or null if none.
      • getVerticalComponent

        public static VerticalCRS getVerticalComponent​(CoordinateReferenceSystem crs,
                                                       boolean allowCreateEllipsoidal)
        Returns the first vertical coordinate reference system found in the given CRS, or null if there is none. If the given CRS is already an instance of Vertical­CRS, then this method returns it as-is. Otherwise if the given CRS is compound, then this method searches for the first vertical component in the order of the single components list.
        Height in a three-dimensional geographic CRS
        In ISO 19111 model, ellipsoidal heights are indissociable from geographic CRS because such heights without their (latitude, longitude) locations make little sense. Consequently a standard-conformant library should return null when asked for the Vertical­CRS component of a geographic CRS. This is what get­Vertical­Component(…) does when the allow­Create­Ellipsoidal argument is false.

        However in some exceptional cases, handling ellipsoidal heights like any other kind of heights may simplify the task. For example when computing difference between heights above the same datum, the impact of ignoring locations may be smaller (but not necessarily canceled). Orphan Vertical­CRS may also be useful for information purpose like labeling a plot axis. If the caller feels confident that ellipsoidal heights are safe for his task, he can set the allow­Create­Ellipsoidal argument to true. In such case, this get­Vertical­Component(…) method will create a temporary Vertical­CRS from the first three-dimensional Geographic­CRS in last resort, only if it can not find an existing Vertical­CRS instance. Note that this is not a valid CRS according ISO 19111 — use with care.

        Parameters:
        crs - the coordinate reference system, or null.
        allow­Create­Ellipsoidal - true for allowing the creation of orphan CRS for ellipsoidal heights. The recommended value is false.
        Returns:
        the first vertical CRS, or null if none.
        See Also:
        compound(Coordinate­Reference­System...)
      • getTemporalComponent

        public static TemporalCRS getTemporalComponent​(CoordinateReferenceSystem crs)
        Returns the first temporal coordinate reference system found in the given CRS, or null if there is none. If the given CRS is already an instance of Temporal­CRS, then this method returns it as-is. Otherwise if the given CRS is compound, then this method searches for the first temporal component in the order of the single components list.
        Parameters:
        crs - the coordinate reference system, or null.
        Returns:
        the first temporal CRS, or null if none.
      • getSingleComponents

        public static List<SingleCRS> getSingleComponents​(CoordinateReferenceSystem crs)
        Returns the ordered list of single coordinate reference systems for the specified CRS. This method performs the following choices:
        • If the given CRS is null, returns an empty list.
        • If the given CRS is an instance of Single­CRS, returns that instance in a singleton list.
        • If the given CRS is an instance of Compound­CRS, returns a flattened list of its components. Some components may themselves be other Compound­CRS instances, in which case those compound CRS are also flattened in their list of Single­CRS components.
        • Otherwise throws a Class­Cast­Exception.
        Example: Apache SIS allows 4-dimensional (x,y,z,t) coordinate reference system to be built in two different ways as shown below:

        Hierarchical structure

        Compound­CRS — (x, y, z, t)
          ├─Compound­CRS — (x, y, z)
          │   ├─Projected­CRS — (x, y)
          │   └─Vertical­CRS — (z)
          └─Temporal­CRS — (t)

        Flat list

        Compound­CRS — (x, y, z, t)
          ├─Projected­CRS — (x, y)
          ├─Vertical­CRS — (z)
          └─Temporal­CRS — (t)
        This method guaranteed that the returned list is a flat one as shown on the right side. Note that such flat lists are the only one allowed by ISO/OGC standards for compound CRS. The hierarchical structure is an Apache SIS flexibility.
        Parameters:
        crs - the coordinate reference system, or null.
        Returns:
        the single coordinate reference systems, or an empty list if the given CRS is null.
        Throws:
        Class­Cast­Exception - if a CRS is neither a Single­CRS or a Compound­CRS.
        See Also:
        Default­Compound­CRS​.get­Single­Components()
      • getComponentAt

        public static CoordinateReferenceSystem getComponentAt​(CoordinateReferenceSystem crs,
                                                               int lower,
                                                               int upper)
        Returns the coordinate reference system in the given range of dimension indices. This method processes as below:
        • If the given crs is null, then this method returns null.
        • Otherwise if lower is 0 and upper is the number of CRS dimensions, then this method returns the given CRS unchanged.
        • Otherwise if the given CRS is an instance of Compound­CRS, then this method searches for a component where:
          • The number of dimensions is equals to upper - lower;
          • The sum of the number of dimensions of all previous CRS is equals to lower.
          If such component is found, then it is returned.
        • Otherwise (i.e. no component match), this method returns null.
        This method does not build new CRS from the components. For example this method does not create a Compound­CRS or a three-dimensional CRS if the given range spans more than one component.
        Parameters:
        crs - the coordinate reference system to decompose, or null.
        lower - the first dimension to keep, inclusive.
        upper - the last dimension to keep, exclusive.
        Returns:
        the sub-coordinate system, or null if the given crs was null or can not be decomposed for dimensions in the [lowerupper] range.
        Throws:
        Index­Out­Of­Bounds­Exception - if the given index are out of bounds.
        Since:
        0.5
        See Also:
        reduce(Coordinate­Reference­System, int...), General­Envelope​.sub­Envelope(int, int)
      • getGreenwichLongitude

        public static double getGreenwichLongitude​(GeodeticCRS crs)
        Returns the Greenwich longitude of the prime meridian of the given CRS in degrees. If the prime meridian uses an other unit than degrees, then the value will be converted.
        Parameters:
        crs - the coordinate reference system from which to get the prime meridian.
        Returns:
        the Greenwich longitude (in degrees) of the prime meridian of the given CRS.
        Since:
        0.5
        See Also:
        Default­Prime­Meridian​.get­Greenwich­Longitude(Unit)
      • getAuthorityFactory

        public static CRSAuthorityFactory getAuthorityFactory​(String authority)
                                                       throws FactoryException
        Returns the system-wide authority factory used by for­Code(String) and other SIS methods. If the given authority is non-null, then this method returns a factory specifically for that authority. Otherwise, this method returns the Multi­Authorities­Factory instance that manages all other factories.

        The authority argument can be "EPSG", "OGC" or any other authority found on the classpath. In the "EPSG" case, whether the full set of EPSG codes is supported or not depends on whether a connection to the database can be established. If no connection can be established, then this method returns a small embedded EPSG factory containing at least the CRS defined in the for­Code(String) method javadoc.

        User-defined authorities can be added to the SIS environment by creating a CRSAuthority­Factory implementation with a public no-argument constructor, and declaring the fully-qualified name of that class in a file at the following location:

        META-INF/services/org.opengis.referencing.crs.CRSAuthorityFactory
        Parameters:
        authority - the authority of the desired factory (typically "EPSG" or "OGC"), or null for the Multi­Authorities­Factory instance that manage all factories.
        Returns:
        the system-wide authority factory used by SIS for the given authority.
        Throws:
        Factory­Exception - if no factory can be returned for the given authority.
        Since:
        0.7
        See Also:
        for­Code(String), Multi­Authorities­Factory