<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (11.0.4) on Fri Sep 20 12:10:30 CEST 2019 -->
<title>GeodeticObjectFactory (Apache SIS 1.0 API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="dc.created" content="2019-09-20">
<meta name="keywords" content="org.apache.sis.referencing.factory.GeodeticObjectFactory class">
<meta name="keywords" content="complete()">
<meta name="keywords" content="createGeocentricCRS()">
<meta name="keywords" content="createCartesianCS()">
<meta name="keywords" content="createSphericalCS()">
<meta name="keywords" content="createGeographicCRS()">
<meta name="keywords" content="createGeodeticDatum()">
<meta name="keywords" content="createPrimeMeridian()">
<meta name="keywords" content="createEllipsoidalCS()">
<meta name="keywords" content="createEllipsoid()">
<meta name="keywords" content="createFlattenedSphere()">
<meta name="keywords" content="createProjectedCRS()">
<meta name="keywords" content="createDerivedCRS()">
<meta name="keywords" content="createVerticalCRS()">
<meta name="keywords" content="createVerticalDatum()">
<meta name="keywords" content="createVerticalCS()">
<meta name="keywords" content="createTemporalCRS()">
<meta name="keywords" content="createTemporalDatum()">
<meta name="keywords" content="createTimeCS()">
<meta name="keywords" content="createParametricCRS()">
<meta name="keywords" content="createParametricDatum()">
<meta name="keywords" content="createParametricCS()">
<meta name="keywords" content="createCompoundCRS()">
<meta name="keywords" content="createImageCRS()">
<meta name="keywords" content="createImageDatum()">
<meta name="keywords" content="createAffineCS()">
<meta name="keywords" content="createEngineeringCRS()">
<meta name="keywords" content="createEngineeringDatum()">
<meta name="keywords" content="createCylindricalCS()">
<meta name="keywords" content="createPolarCS()">
<meta name="keywords" content="createLinearCS()">
<meta name="keywords" content="createUserDefinedCS()">
<meta name="keywords" content="createCoordinateSystemAxis()">
<meta name="keywords" content="createFromXML()">
<meta name="keywords" content="createFromWKT()">
<link rel="stylesheet" type="text/css" href="../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../sis.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery/jquery-ui.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../../jquery/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../../jquery/jquery-3.3.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-migrate-3.0.1.js"></script>
<script type="text/javascript" src="../../../../../jquery/jquery-ui.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="GeodeticObjectFactory (Apache SIS 1.0 API)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10,"i28":10,"i29":10,"i30":10,"i31":10,"i32":10,"i33":10,"i34":10,"i35":10,"i36":10,"i37":10,"i38":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../../";
var useModuleDirectories = false;
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<header role="banner">
<nav role="navigation">
<div class="fixedNav">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/GeodeticObjectFactory.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<ul class="navListSearch">
<li><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
</div>
<div class="navPadding">&nbsp;</div>
<script type="text/javascript"><!--
$('.navPadding').css('padding-top', $('.fixedNav').css("height"));
//-->
</script>
</nav>
</header>
<!-- ======== START OF CLASS DATA ======== -->
<main role="main">
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.referencing.factory</a></div>
<h2 title="Class GeodeticObjectFactory" class="title">Class GeodeticObjectFactory</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></li>
<li>
<ul class="inheritance">
<li><a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a></li>
<li>
<ul class="inheritance">
<li>GeodeticObjectFactory</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../../io/wkt/Parser.html" title="interface in org.apache.sis.io.wkt">Parser</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/ObjectFactory.html?is-external=true" title="class or interface in org.opengis.referencing" class="externalLink">Object­Factory</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory</a></code></dd>
</dl>
<hr>
<pre>public class <span class="typeNameLabel">GeodeticObjectFactory</span>
extends <a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a>
implements <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">DatumFactory</a>, <a href="../../io/wkt/Parser.html" title="interface in org.apache.sis.io.wkt">Parser</a></pre>
<div class="block">Creates <a href="../crs/AbstractCRS.html" title="class in org.apache.sis.referencing.crs">Coordinate Reference System</a> (CRS) implementations,
 with their <a href="../cs/AbstractCS.html" title="class in org.apache.sis.referencing.cs">Coordinate System</a> (CS)
 and <a href="../datum/AbstractDatum.html" title="class in org.apache.sis.referencing.datum">Datum</a> components.
 This factory serves two purposes:

 <ul>
   <li><b>For users</b>, allows the creation of complex objects that can not be created by the authority factories,
       without explicit dependency to Apache SIS (when using the GeoAPI interfaces implemented by this class).</li>
   <li><b>For providers</b>, allows <cite>inversion of control</cite> by overriding methods in this class,
       then specifying the customized instance to other services that consume <code>CRSFactory</code> (for example
       authority factories or <a href="../../io/wkt/WKTFormat.html" title="class in org.apache.sis.io.wkt">WKT parsers</a>).</li>
 </ul>

 This <code>Geodetic­Object­Factory</code> class is not easy to use directly.
 Users are encouraged to use an authority factory instead
 (or the <a href="../CRS.html#forCode(java.lang.String)"><code>CRS​.for­Code(String)</code></a> convenience method)
 when the CRS object to construct can be identified by a code in the namespace of an authority (typically EPSG).

 <div class="section">Object properties</div>
 Most factory methods expect a <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink"><code>Map&lt;String,?&gt;</code></a> argument, often followed by explicit arguments.
 Unless otherwise noticed, information provided in the <code>properties</code> map are considered ignorable metadata
 while information provided in explicit arguments have an impact on coordinate transformation results.

 <p>The following table lists the keys recognized by the <code>Geodetic­Object­Factory</code> default implementation,
 together with the type of values associated to those keys.
 A value for the <code>"name"</code> key is mandatory for all objects, while all other properties are optional.
 <code>Geodetic­Object­Factory</code> methods ignore all unknown properties.</p>

 <table class="sis">
   <caption>Recognized properties (non exhaustive list)</caption>
   <tr>
     <th>Property name</th>
     <th>Value type</th>
     <th>Returned by</th>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true#NAME_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"name"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/Identifier.html?is-external=true" title="class or interface in org.opengis.metadata" class="externalLink"><code>Identifier</code></a> or <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../AbstractIdentifiedObject.html#getName()"><code>AbstractIdentifiedObject.getName()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/Identifier.html?is-external=true#AUTHORITY_KEY" title="class or interface in org.opengis.metadata" class="externalLink">"authority"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/citation/Citation.html?is-external=true" title="class or interface in org.opengis.metadata.citation" class="externalLink"><code>Citation</code></a></td>
     <td><a href="../ImmutableIdentifier.html#getAuthority()"><code>ImmutableIdentifier.getAuthority()</code></a> on the <a href="../AbstractIdentifiedObject.html#getName()">name</a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/Identifier.html?is-external=true#CODE_KEY" title="class or interface in org.opengis.metadata" class="externalLink">"code"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../ImmutableIdentifier.html#getCode()"><code>ImmutableIdentifier.getCode()</code></a> on the <a href="../AbstractIdentifiedObject.html#getName()">name</a></td>
   </tr>
   <tr>
     <td>"codespace"</td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../ImmutableIdentifier.html#getCodeSpace()"><code>ImmutableIdentifier.getCodeSpace()</code></a> on the <a href="../AbstractIdentifiedObject.html#getName()">name</a></td>
   </tr>
   <tr>
     <td>"version"</td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../ImmutableIdentifier.html#getVersion()"><code>ImmutableIdentifier.getVersion()</code></a> on the <a href="../AbstractIdentifiedObject.html#getName()">name</a></td>
   </tr>
   <tr>
     <td>"description"</td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../ImmutableIdentifier.html#getDescription()"><code>ImmutableIdentifier.getDescription()</code></a> on the <a href="../AbstractIdentifiedObject.html#getName()">name</a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true#ALIAS_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"alias"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/GenericName.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>GenericName</code></a> or <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>Char­Sequence</code></a> (optionally as array)</td>
     <td><a href="../AbstractIdentifiedObject.html#getAlias()"><code>AbstractIdentifiedObject.getAlias()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true#IDENTIFIERS_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"identifiers"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/Identifier.html?is-external=true" title="class or interface in org.opengis.metadata" class="externalLink"><code>Identifier</code></a> (optionally as array)</td>
     <td><a href="../AbstractIdentifiedObject.html#getIdentifiers()"><code>AbstractIdentifiedObject.getIdentifiers()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/ReferenceSystem.html?is-external=true#DOMAIN_OF_VALIDITY_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"domainOfValidity"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/metadata/extent/Extent.html?is-external=true" title="class or interface in org.opengis.metadata.extent" class="externalLink"><code>Extent</code></a></td>
     <td><a href="../AbstractReferenceSystem.html#getDomainOfValidity()"><code>AbstractReferenceSystem.getDomainOfValidity()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/ReferenceSystem.html?is-external=true#SCOPE_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"scope"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>International­String</code></a></td>
     <td><a href="../AbstractReferenceSystem.html#getScope()"><code>AbstractReferenceSystem.getScope()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Datum.html?is-external=true#ANCHOR_POINT_KEY" title="class or interface in org.opengis.referencing.datum" class="externalLink">"anchorPoint"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>InternationalString</code></a> or <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../datum/AbstractDatum.html#getAnchorPoint()"><code>AbstractDatum.getAnchorPoint()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Datum.html?is-external=true#REALIZATION_EPOCH_KEY" title="class or interface in org.opengis.referencing.datum" class="externalLink">"realizationEpoch"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Date.html?is-external=true" title="class or interface in java.util" class="externalLink"><code>Date</code></a></td>
     <td><a href="../datum/AbstractDatum.html#getRealizationEpoch()"><code>AbstractDatum.getRealizationEpoch()</code></a></td>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/IdentifiedObject.html?is-external=true#REMARKS_KEY" title="class or interface in org.opengis.referencing" class="externalLink">"remarks"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink"><code>InternationalString</code></a> or <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>String</code></a></td>
     <td><a href="../AbstractIdentifiedObject.html#getRemarks()"><code>AbstractIdentifiedObject.getRemarks()</code></a></td>
   </tr>
   <tr>
     <td><a href="../AbstractIdentifiedObject.html#DEPRECATED_KEY">"deprecated"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html?is-external=true" title="class or interface in java.lang" class="externalLink"><code>Boolean</code></a></td>
     <td><a href="../AbstractIdentifiedObject.html#isDeprecated()"><code>AbstractIdentifiedObject.isDeprecated()</code></a></td>
   </tr>
   <tr>
     <td><a href="../AbstractIdentifiedObject.html#LOCALE_KEY">"locale"</a></td>
     <td><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true" title="class or interface in java.util" class="externalLink"><code>Locale</code></a></td>
     <td>(none)</td>
   </tr>
 </table>

 <div class="section">Localization</div>
 All localizable attributes like <code>"remarks"</code> may have a language and country code suffix.
 For example the <code>"remarks_fr"</code> property stands for remarks in <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true#FRENCH" title="class or interface in java.util" class="externalLink">French</a> and
 the <code>"remarks_fr_CA"</code> property stands for remarks in <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Locale.html?is-external=true#CANADA_FRENCH" title="class or interface in java.util" class="externalLink">French Canadian</a>.
 They are convenience properties for building the <code>International­String</code> value.

 <p>The <code>"locale"</code> property applies only in case of exception for formatting the error message, and
 is used only on a <cite>best effort</cite> basis. The locale is discarded after successful construction
 since localizations are applied by the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/InternationalString.html?is-external=true#toString(java.util.Locale)" title="class or interface in org.opengis.util" class="externalLink"><code>International­String​.to­String(Locale)</code></a> method.</p></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.6</dd>

<p><font size="-1">Defined in the <code>sis-referencing</code> module</font></p>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Constructor</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E()">GeodeticObjectFactory</a></span>()</code></th>
<td class="colLast">
<div class="block">Constructs a factory with no default properties.</div>
</td>
</tr>
<tr class="rowColor">
<th class="colConstructorName" scope="row"><code><span class="memberNameLink"><a href="#%3Cinit%3E(java.util.Map)">GeodeticObjectFactory</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Constructs a factory with the given default properties.</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ========== METHOD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>protected <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#complete(java.util.Map)">complete</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Returns the union of the given <code>properties</code> map with the default properties given at
 <a href="#%3Cinit%3E(java.util.Map)">construction time</a>.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createAffineCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)</code></th>
<td class="colLast">
<div class="block">Creates a two-dimensional affine coordinate system from the given pair of axis.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createAffineCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates a three-dimensional affine coordinate system from the given set of axis.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createCartesianCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)</code></th>
<td class="colLast">
<div class="block">Creates a two-dimensional Cartesian coordinate system from the given pair of axis.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createCartesianCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates a three-dimensional Cartesian coordinate system from the given set of axis.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CompoundCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CompoundCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCompoundCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem...)">createCompoundCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>...&nbsp;components)</code></th>
<td class="colLast">
<div class="block">Creates a compound coordinate reference system from an ordered list of CRS components.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)">createCoordinateSystemAxis</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;abbreviation,
                          <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AxisDirection.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AxisDirection</a>&nbsp;direction,
                          <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Creates a coordinate system axis from an abbreviation and a unit.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CylindricalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CylindricalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createCylindricalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createCylindricalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates a cylindrical coordinate system from the given set of axis.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/DerivedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">DerivedCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createDerivedCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CoordinateSystem)">createDerivedCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>&nbsp;baseCRS,
                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/Conversion.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">Conversion</a>&nbsp;conversion,
                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a>&nbsp;derivedCS)</code></th>
<td class="colLast">
<div class="block">Creates a derived coordinate reference system from a conversion.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)">createEllipsoid</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
               double&nbsp;semiMajorAxis,
               double&nbsp;semiMinorAxis,
               <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Creates an ellipsoid from semi-axis length values.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createEllipsoidalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)</code></th>
<td class="colLast">
<div class="block">Creates an ellipsoidal coordinate system without ellipsoidal height.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createEllipsoidalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates an ellipsoidal coordinate system with ellipsoidal height.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/EngineeringCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">EngineeringCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEngineeringCRS(java.util.Map,org.opengis.referencing.datum.EngineeringDatum,org.opengis.referencing.cs.CoordinateSystem)">createEngineeringCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                    <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a>&nbsp;datum,
                    <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a engineering coordinate reference system.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createEngineeringDatum(java.util.Map)">createEngineeringDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Creates an engineering datum.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)">createFlattenedSphere</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                     double&nbsp;semiMajorAxis,
                     double&nbsp;inverseFlattening,
                     <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Creates an ellipsoid from a major semi-axis length and inverse flattening.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createFromWKT(java.lang.String)">createFromWKT</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;text)</code></th>
<td class="colLast">
<div class="block">Creates a Coordinate Reference System object from a <cite>Well Known Text</cite> (WKT).</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createFromXML(java.lang.String)">createFromXML</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;xml)</code></th>
<td class="colLast">
<div class="block">Creates a coordinate reference system object from a XML string.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.CartesianCS)">createGeocentricCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a geocentric coordinate reference system from a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">Cartesian coordinate system</a>.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.SphericalCS)">createGeocentricCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a geocentric coordinate reference system from a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">spherical coordinate system</a>.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)">createGeodeticDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a>&nbsp;ellipsoid,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a>&nbsp;primeMeridian)</code></th>
<td class="colLast">
<div class="block">Creates geodetic datum from ellipsoid and (optionally) Bursa-Wolf parameters.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createGeographicCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.EllipsoidalCS)">createGeographicCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a geographic coordinate reference system.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ImageCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ImageCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createImageCRS(java.util.Map,org.opengis.referencing.datum.ImageDatum,org.opengis.referencing.cs.AffineCS)">createImageCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a>&nbsp;datum,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates an image coordinate reference system.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createImageDatum(java.util.Map,org.opengis.referencing.datum.PixelInCell)">createImageDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PixelInCell.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PixelInCell</a>&nbsp;pixelInCell)</code></th>
<td class="colLast">
<div class="block">Creates an image datum.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/LinearCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">LinearCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createLinearCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">createLinearCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)</code></th>
<td class="colLast">
<div class="block">Creates a linear coordinate system.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs">DefaultParametricCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricCRS(java.util.Map,org.apache.sis.referencing.datum.DefaultParametricDatum,org.apache.sis.referencing.cs.DefaultParametricCS)">createParametricCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a>&nbsp;datum,
                   <a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a parametric coordinate reference system.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">createParametricCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                  <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)</code></th>
<td class="colLast">
<div class="block">Creates a parametric coordinate system.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createParametricDatum(java.util.Map)">createParametricDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</code></th>
<td class="colLast">
<div class="block">Creates a parametric datum.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/PolarCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">PolarCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createPolarCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createPolarCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)</code></th>
<td class="colLast">
<div class="block">Creates a polar coordinate system from the given pair of axis.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)">createPrimeMeridian</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   double&nbsp;longitude,
                   <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;&nbsp;angularUnit)</code></th>
<td class="colLast">
<div class="block">Creates a prime meridian, relative to Greenwich.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ProjectedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ProjectedCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createProjectedCRS(java.util.Map,org.opengis.referencing.crs.GeographicCRS,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CartesianCS)">createProjectedCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                  <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a>&nbsp;baseCRS,
                  <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/Conversion.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">Conversion</a>&nbsp;conversion,
                  <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;derivedCS)</code></th>
<td class="colLast">
<div class="block">Creates a projected coordinate reference system from a conversion.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createSphericalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createSphericalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates a spherical coordinate system from the given set of axis.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/TemporalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">TemporalCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTemporalCRS(java.util.Map,org.opengis.referencing.datum.TemporalDatum,org.opengis.referencing.cs.TimeCS)">createTemporalCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a>&nbsp;datum,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a temporal coordinate reference system.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTemporalDatum(java.util.Map,java.util.Date)">createTemporalDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Date.html?is-external=true" title="class or interface in java.util" class="externalLink">Date</a>&nbsp;origin)</code></th>
<td class="colLast">
<div class="block">Creates a temporal datum from an enumerated type value.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createTimeCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">createTimeCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
            <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)</code></th>
<td class="colLast">
<div class="block">Creates a temporal coordinate system.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/UserDefinedCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">UserDefinedCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createUserDefinedCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)</code></th>
<td class="colLast">
<div class="block">Creates a two-dimensional user defined coordinate system from the given pair of axis.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/UserDefinedCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">UserDefinedCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">createUserDefinedCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)</code></th>
<td class="colLast">
<div class="block">Creates a three-dimensional user defined coordinate system from the given set of axis.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">VerticalCRS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalCRS(java.util.Map,org.opengis.referencing.datum.VerticalDatum,org.opengis.referencing.cs.VerticalCS)">createVerticalCRS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a>&nbsp;datum,
                 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a>&nbsp;cs)</code></th>
<td class="colLast">
<div class="block">Creates a vertical coordinate reference system.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">createVerticalCS</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)</code></th>
<td class="colLast">
<div class="block">Creates a vertical coordinate system.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#createVerticalDatum(java.util.Map,org.opengis.referencing.datum.VerticalDatumType)">createVerticalDatum</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatumType.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatumType</a>&nbsp;type)</code></th>
<td class="colLast">
<div class="block">Creates a vertical datum from an enumerated type value.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.AbstractFactory">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="../../util/iso/AbstractFactory.html" title="class in org.apache.sis.util.iso">AbstractFactory</a></h3>
<code><a href="../../util/iso/AbstractFactory.html#getVendor()">get­Vendor</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang" class="externalLink">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang" class="externalLink">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang" class="externalLink">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang" class="externalLink">get­Class</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang" class="externalLink">hash­Code</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang" class="externalLink">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang" class="externalLink">notify­All</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">to­String</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long,int)" title="class or interface in java.lang" class="externalLink">wait</a></code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.Factory">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/Factory.html?is-external=true#getVendor()" title="class or interface in org.opengis.util" class="externalLink">get­Vendor</a></code></li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a id="&lt;init&gt;()">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>GeodeticObjectFactory</h4>
<pre>public&nbsp;GeodeticObjectFactory()</pre>
<div class="block">Constructs a factory with no default properties.</div>
</li>
</ul>
<a id="&lt;init&gt;(java.util.Map)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>GeodeticObjectFactory</h4>
<pre>public&nbsp;GeodeticObjectFactory&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</pre>
<div class="block">Constructs a factory with the given default properties.
 <code>Geodetic­Object­Factory</code> will fallback on the map given to this constructor for any property
 not present in the map provided to a <code>create­Foo(Map&lt;String,?&gt;, …)</code> method.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - the default properties, or <code>null</code> if none.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
<!-- ============ METHOD DETAIL ========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a id="complete(java.util.Map)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>complete</h4>
<pre class="methodSignature">protected&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;complete&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)</pre>
<div class="block">Returns the union of the given <code>properties</code> map with the default properties given at
 <a href="#%3Cinit%3E(java.util.Map)">construction time</a>. Entries in the given properties
 map have precedence, even if their <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html?is-external=true#getValue()" title="class or interface in java.util" class="externalLink">value</a> is <code>null</code>
 (i.e. a null value "erase" the default property value).
 Entries with null value after the union will be omitted.

 <p>This method is invoked by all <code>create­Foo(Map&lt;String,?&gt;, …)</code> methods.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - the user-supplied properties.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the union of the given properties with the default properties.</dd>
</dl>
</li>
</ul>
<a id="createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.CartesianCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeocentricCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a>&nbsp;createGeocentricCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;cs)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a geocentric coordinate reference system from a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">Cartesian coordinate system</a>.
 Geocentric CRS have their origin at the approximate centre of mass of the earth.
 An <a href="#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.SphericalCS)">alternate method</a> allows creation of the
 same kind of CRS with spherical coordinate system instead than a Cartesian one.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Cartesian­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
   <li>One of:<ul>
     <li><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>create­Ellipsoid(Map, double, double, Unit)</code></a></li>
     <li><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>create­Flattened­Sphere(Map, double, double, Unit)</code></a></li>
   </ul></li>
   <li><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)"><code>create­Prime­Meridian(Map, double, Unit)</code></a></li>
   <li><a href="#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)"><code>create­Geodetic­Datum(Map, Ellipsoid, Prime­Meridian)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultGeocentricCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Geocentric­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.CartesianCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Geocentric­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the geodetic datum to use in created CRS.</dd>
<dd><code>cs</code> - the three-dimensional Cartesian coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="GeodeticAuthorityFactory.html#createGeocentricCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Geocentric­CRS(String)</code></a>, 
<a href="../crs/DefaultGeocentricCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.CartesianCS)"><code>Default­Geocentric­CRS(Map, Geodetic­Datum, Cartesian­CS)</code></a></dd>
</dl>
</li>
</ul>
<a id="createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCartesianCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;createCartesianCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultCartesianCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Cartesian­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Cartesian­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis (e.g. “Geocentric X”).</dd>
<dd><code>axis1</code> - the second axis (e.g. “Geocentric Y”).</dd>
<dd><code>axis2</code> - the third  axis (e.g. “Geocentric Z”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCartesianCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Cartesian­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createCartesianCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Cartesian­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.SphericalCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeocentricCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeocentricCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeocentricCRS</a>&nbsp;createGeocentricCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a>&nbsp;cs)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a geocentric coordinate reference system from a <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">spherical coordinate system</a>.
 Geocentric CRS have their origin at the approximate centre of mass of the earth.
 An <a href="#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.CartesianCS)">alternate method</a> allows creation of the
 same kind of CRS with Cartesian coordinate system instead than a spherical one.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createSphericalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Spherical­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
   <li>One of:<ul>
     <li><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>create­Ellipsoid(Map, double, double, Unit)</code></a></li>
     <li><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>create­Flattened­Sphere(Map, double, double, Unit)</code></a></li>
   </ul></li>
   <li><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)"><code>create­Prime­Meridian(Map, double, Unit)</code></a></li>
   <li><a href="#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)"><code>create­Geodetic­Datum(Map, Ellipsoid, Prime­Meridian)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultGeocentricCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Geocentric­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createGeocentricCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.SphericalCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Geocentric­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - geodetic datum to use in created CRS.</dd>
<dd><code>cs</code> - the spherical coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultGeocentricCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.SphericalCS)"><code>Default­Geocentric­CRS(Map, Geodetic­Datum, Spherical­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createGeocentricCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Geocentric­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createSphericalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createSphericalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/SphericalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">SphericalCS</a>&nbsp;createSphericalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a spherical coordinate system from the given set of axis.
 This coordinate system can be used with geocentric, engineering and derived CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultSphericalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Spherical­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createSphericalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Spherical­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis (e.g. “Spherical latitude”).</dd>
<dd><code>axis1</code> - the second axis (e.g. “Spherical longitude”).</dd>
<dd><code>axis2</code> - the third  axis (e.g. “Geocentric radius”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultSphericalCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Spherical­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createSphericalCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Spherical­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeographicCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.EllipsoidalCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeographicCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a>&nbsp;createGeographicCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;datum,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a>&nbsp;cs)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a geographic coordinate reference system. It can be (<var>latitude</var>, <var>longitude</var>)
 or (<var>longitude</var>, <var>latitude</var>), optionally with an ellipsoidal height.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li>One of:<ul>
     <li><a href="#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Ellipsoidal­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
     <li><a href="#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Ellipsoidal­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
   </ul></li>
   <li>One of:<ul>
     <li><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>create­Ellipsoid(Map, double, double, Unit)</code></a></li>
     <li><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>create­Flattened­Sphere(Map, double, double, Unit)</code></a></li>
   </ul></li>
   <li><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)"><code>create­Prime­Meridian(Map, double, Unit)</code></a></li>
   <li><a href="#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)"><code>create­Geodetic­Datum(Map, Ellipsoid, Prime­Meridian)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultGeographicCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Geographic­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createGeographicCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.EllipsoidalCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Geographic­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - geodetic datum to use in created CRS.</dd>
<dd><code>cs</code> - the two- or three-dimensional ellipsoidal coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultGeographicCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.EllipsoidalCS)"><code>Default­Geographic­CRS(Map, Geodetic­Datum, Ellipsoidal­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createGeographicCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Geographic­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createGeodeticDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/GeodeticDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">GeodeticDatum</a>&nbsp;createGeodeticDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a>&nbsp;ellipsoid,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a>&nbsp;primeMeridian)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li>One of:<ul>
     <li><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>create­Ellipsoid(Map, double, double, Unit)</code></a></li>
     <li><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>create­Flattened­Sphere(Map, double, double, Unit)</code></a></li>
   </ul></li>
   <li><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)"><code>create­Prime­Meridian(Map, double, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../datum/DefaultGeodeticDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Geodetic­Datum</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Geodetic­Datum</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>ellipsoid</code> - the ellipsoid to use in new geodetic datum.</dd>
<dd><code>prime­Meridian</code> - the prime meridian to use in new geodetic datum.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultGeodeticDatum.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)"><code>Default­Geodetic­Datum(Map, Ellipsoid, Prime­Meridian)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createGeodeticDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Geodetic­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createPrimeMeridian(java.util.Map,double,javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPrimeMeridian</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PrimeMeridian.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PrimeMeridian</a>&nbsp;createPrimeMeridian&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         double&nbsp;longitude,
                                         <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;&nbsp;angularUnit)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a prime meridian, relative to Greenwich.
 Defines the origin from which longitude values are determined.

 <p>The default implementation creates a <a href="../datum/DefaultPrimeMeridian.html" title="class in org.apache.sis.referencing.datum"><code>Default­Prime­Meridian</code></a> instance.</p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Prime­Meridian</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>longitude</code> - the longitude of prime meridian in supplied angular units East of Greenwich.</dd>
<dd><code>angular­Unit</code> - the angular units of longitude.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultPrimeMeridian.html#%3Cinit%3E(java.util.Map,double,javax.measure.Unit)"><code>Default­Prime­Meridian(Map, double, Unit)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createPrimeMeridian(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Prime­Meridian(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEllipsoidalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a>&nbsp;createEllipsoidalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an ellipsoidal coordinate system without ellipsoidal height.
 It can be (<var>latitude</var>, <var>longitude</var>) or (<var>longitude</var>, <var>latitude</var>).

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultEllipsoidalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Ellipsoidal­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Ellipsoidal­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis (e.g. “Geodetic latitude”).</dd>
<dd><code>axis1</code> - the second axis (e.g. “Geodetic longitude”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultEllipsoidalCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Ellipsoidal­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEllipsoidalCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Ellipsoidal­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEllipsoidalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/EllipsoidalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">EllipsoidalCS</a>&nbsp;createEllipsoidalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an ellipsoidal coordinate system with ellipsoidal height.
 It can be (<var>latitude</var>, <var>longitude</var>, <var>height</var>)
 or (<var>longitude</var>, <var>latitude</var>, <var>height</var>).

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultEllipsoidalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Ellipsoidal­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Ellipsoidal­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis (e.g. “Geodetic latitude”).</dd>
<dd><code>axis1</code> - the second axis (e.g. “Geodetic longitude”).</dd>
<dd><code>axis2</code> - the third  axis (e.g. “Ellipsoidal height”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultEllipsoidalCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Ellipsoidal­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEllipsoidalCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Ellipsoidal­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEllipsoid(java.util.Map,double,double,javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEllipsoid</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a>&nbsp;createEllipsoid&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                 double&nbsp;semiMajorAxis,
                                 double&nbsp;semiMinorAxis,
                                 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;&nbsp;unit)
                          throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an ellipsoid from semi-axis length values.
 The default implementation creates a <a href="../datum/DefaultEllipsoid.html" title="class in org.apache.sis.referencing.datum"><code>Default­Ellipsoid</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Ellipsoid</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>semi­Major­Axis</code> - the equatorial radius in supplied linear units.</dd>
<dd><code>semi­Minor­Axis</code> - the polar radius in supplied linear units.</dd>
<dd><code>unit</code> - the linear units of ellipsoid axes.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultEllipsoid.html#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>Default­Ellipsoid​.create­Ellipsoid(Map, double, double, Unit)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEllipsoid(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Ellipsoid(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createFlattenedSphere</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/Ellipsoid.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Ellipsoid</a>&nbsp;createFlattenedSphere&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                       double&nbsp;semiMajorAxis,
                                       double&nbsp;inverseFlattening,
                                       <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;&nbsp;unit)
                                throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an ellipsoid from a major semi-axis length and inverse flattening.
 The default implementation creates a <a href="../datum/DefaultEllipsoid.html" title="class in org.apache.sis.referencing.datum"><code>Default­Ellipsoid</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Flattened­Sphere</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>semi­Major­Axis</code> - the equatorial radius in supplied linear units.</dd>
<dd><code>inverse­Flattening</code> - the eccentricity of ellipsoid.</dd>
<dd><code>unit</code> - the linear units of major axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultEllipsoid.html#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>Default­Ellipsoid​.create­Flattened­Sphere(Map, double, double, Unit)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEllipsoid(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Ellipsoid(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createProjectedCRS(java.util.Map,org.opengis.referencing.crs.GeographicCRS,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CartesianCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createProjectedCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ProjectedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ProjectedCRS</a>&nbsp;createProjectedCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeographicCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">GeographicCRS</a>&nbsp;baseCRS,
                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/Conversion.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">Conversion</a>&nbsp;conversion,
                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;derivedCS)
                                throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Cartesian­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
   <li><a href="#createEllipsoidalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Ellipsoidal­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></li>
   <li>One of:<ul>
     <li><a href="#createEllipsoid(java.util.Map,double,double,javax.measure.Unit)"><code>create­Ellipsoid(Map, double, double, Unit)</code></a></li>
     <li><a href="#createFlattenedSphere(java.util.Map,double,double,javax.measure.Unit)"><code>create­Flattened­Sphere(Map, double, double, Unit)</code></a></li>
   </ul></li>
   <li><a href="#createPrimeMeridian(java.util.Map,double,javax.measure.Unit)"><code>create­Prime­Meridian(Map, double, Unit)</code></a></li>
   <li><a href="#createGeodeticDatum(java.util.Map,org.opengis.referencing.datum.Ellipsoid,org.opengis.referencing.datum.PrimeMeridian)"><code>create­Geodetic­Datum(Map, Ellipsoid, Prime­Meridian)</code></a></li>
   <li><a href="#createGeographicCRS(java.util.Map,org.opengis.referencing.datum.GeodeticDatum,org.opengis.referencing.cs.EllipsoidalCS)"><code>create­Geographic­CRS(Map, Geodetic­Datum, Ellipsoidal­CS)</code></a></li>
   <li><a href="../operation/DefaultCoordinateOperationFactory.html#createDefiningConversion(java.util.Map,org.opengis.referencing.operation.OperationMethod,org.opengis.parameter.ParameterValueGroup)"><code>Default­Coordinate­Operation­Factory​.create­Defining­Conversion(Map, Operation­Method, Parameter­Value­Group)</code></a></li>
 </ol></div>

 The supplied <code>conversion</code> argument shall <strong>not</strong> includes the operation steps
 for performing <a href="../cs/CoordinateSystems.html#swapAndScaleAxes(org.opengis.referencing.cs.CoordinateSystem,org.opengis.referencing.cs.CoordinateSystem)">unit
 conversions and change of axis order</a> since those operations will be inferred by this constructor.

 <p>The default implementation creates a <a href="../crs/DefaultProjectedCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Projected­CRS</code></a> instance.</p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createProjectedCRS(java.util.Map,org.opengis.referencing.crs.GeographicCRS,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CartesianCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Projected­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>base­CRS</code> - the geographic coordinate reference system to base projection on.</dd>
<dd><code>conversion</code> - the defining conversion from a <a href="../cs/AxesConvention.html#NORMALIZED">normalized</a> base to a normalized derived CRS.</dd>
<dd><code>derived­CS</code> - the coordinate system for the projected CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultProjectedCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.crs.GeographicCRS,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CartesianCS)"><code>Default­Projected­CRS(Map, Geographic­CRS, Conversion, Cartesian­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createProjectedCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Projected­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCartesianCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CartesianCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CartesianCS</a>&nbsp;createCartesianCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultCartesianCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Cartesian­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createCartesianCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Cartesian­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis (e.g. “Easting”).</dd>
<dd><code>axis1</code> - the second axis (e.g. “Northing”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCartesianCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Cartesian­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createCartesianCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Cartesian­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createDerivedCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CoordinateSystem)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createDerivedCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/DerivedCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">DerivedCRS</a>&nbsp;createDerivedCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>&nbsp;baseCRS,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/operation/Conversion.html?is-external=true" title="class or interface in org.opengis.referencing.operation" class="externalLink">Conversion</a>&nbsp;conversion,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a>&nbsp;derivedCS)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a derived coordinate reference system from a conversion.
 The derived CRS returned by this method may also implement the <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/GeodeticCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Geodetic­CRS</code></a>, <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Vertical­CRS</code></a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/TemporalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Temporal­CRS</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/EngineeringCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Engineering­CRS</code></a> interface depending on the type of the base CRS and the
 coordinate system.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li>A <code>create­Foo­CS(…)</code> method for Cartesian, spherical, ellipsoidal, vertical, temporal, linear, affine, polar, cylindrical or user-defined CS.</li>
   <li>An other <code>create­Foo­CRS(…)</code> method for geocentric, geographic, vertical, temporal or engineering CRS.</li>
   <li><a href="../operation/DefaultCoordinateOperationFactory.html#createDefiningConversion(java.util.Map,org.opengis.referencing.operation.OperationMethod,org.opengis.parameter.ParameterValueGroup)"><code>Default­Coordinate­Operation­Factory​.create­Defining­Conversion(Map, Operation­Method, Parameter­Value­Group)</code></a></li>
 </ol></div>

 The supplied <code>conversion</code> argument shall <strong>not</strong> includes the operation steps
 for performing <a href="../cs/CoordinateSystems.html#swapAndScaleAxes(org.opengis.referencing.cs.CoordinateSystem,org.opengis.referencing.cs.CoordinateSystem)">unit
 conversions and change of axis order</a> since those operations will be inferred by this constructor.

 <p>The default implementation creates a <a href="../crs/DefaultDerivedCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Derived­CRS</code></a> instance.</p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createDerivedCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CoordinateSystem)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Derived­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>base­CRS</code> - the coordinate reference system to base projection on. Shall be an instance of <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/SingleCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink"><code>Single­CRS</code></a>.</dd>
<dd><code>conversion</code> - the defining conversion from a <a href="../cs/AxesConvention.html#NORMALIZED">normalized</a> base to a normalized derived CRS.</dd>
<dd><code>derived­CS</code> - the coordinate system for the derived CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultDerivedCRS.html#create(java.util.Map,org.opengis.referencing.crs.SingleCRS,org.opengis.referencing.operation.Conversion,org.opengis.referencing.cs.CoordinateSystem)"><code>Default­Derived­CRS​.create(Map, Single­CRS, Conversion, Coordinate­System)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createDerivedCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Derived­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalCRS(java.util.Map,org.opengis.referencing.datum.VerticalDatum,org.opengis.referencing.cs.VerticalCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/VerticalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">VerticalCRS</a>&nbsp;createVerticalCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a>&nbsp;datum,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a>&nbsp;cs)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createVerticalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Vertical­CS(Map, Coordinate­System­Axis)</code></a></li>
   <li><a href="#createVerticalDatum(java.util.Map,org.opengis.referencing.datum.VerticalDatumType)"><code>create­Vertical­Datum(Map, Vertical­Datum­Type)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultVerticalCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Vertical­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createVerticalCRS(java.util.Map,org.opengis.referencing.datum.VerticalDatum,org.opengis.referencing.cs.VerticalCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Vertical­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the vertical datum to use in created CRS.</dd>
<dd><code>cs</code> - the vertical coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultVerticalCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.VerticalDatum,org.opengis.referencing.cs.VerticalCS)"><code>Default­Vertical­CRS(Map, Vertical­Datum, Vertical­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createVerticalCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Vertical­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalDatum(java.util.Map,org.opengis.referencing.datum.VerticalDatumType)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatum</a>&nbsp;createVerticalDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/VerticalDatumType.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">VerticalDatumType</a>&nbsp;type)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a vertical datum from an enumerated type value.
 The default implementation creates a <a href="../datum/DefaultVerticalDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Vertical­Datum</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createVerticalDatum(java.util.Map,org.opengis.referencing.datum.VerticalDatumType)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Vertical­Datum</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>type</code> - the type of this vertical datum (often geoidal).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultVerticalDatum.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.VerticalDatumType)"><code>Default­Vertical­Datum(Map, Vertical­Datum­Type)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createVerticalDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Vertical­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createVerticalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createVerticalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/VerticalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">VerticalCS</a>&nbsp;createVerticalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a vertical coordinate system.
 This coordinate system can be used with vertical and derived CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultVerticalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Vertical­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createVerticalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Vertical­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis</code> - the single axis (e.g. “height” or “depth”).</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultVerticalCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Vertical­CS(Map, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createVerticalCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Vertical­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createTemporalCRS(java.util.Map,org.opengis.referencing.datum.TemporalDatum,org.opengis.referencing.cs.TimeCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTemporalCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/TemporalCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">TemporalCRS</a>&nbsp;createTemporalCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a>&nbsp;datum,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a>&nbsp;cs)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a temporal coordinate reference system.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createTimeCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Time­CS(Map, Coordinate­System­Axis)</code></a></li>
   <li><a href="#createTemporalDatum(java.util.Map,java.util.Date)"><code>create­Temporal­Datum(Map, Date)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultTemporalCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Temporal­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createTemporalCRS(java.util.Map,org.opengis.referencing.datum.TemporalDatum,org.opengis.referencing.cs.TimeCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Temporal­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the temporal datum to use in created CRS.</dd>
<dd><code>cs</code> - the temporal coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultTemporalCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.TemporalDatum,org.opengis.referencing.cs.TimeCS)"><code>Default­Temporal­CRS(Map, Temporal­Datum, Time­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createTemporalCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Temporal­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createTemporalDatum(java.util.Map,java.util.Date)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTemporalDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/TemporalDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">TemporalDatum</a>&nbsp;createTemporalDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Date.html?is-external=true" title="class or interface in java.util" class="externalLink">Date</a>&nbsp;origin)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a temporal datum from an enumerated type value.
 The default implementation creates a <a href="../datum/DefaultTemporalDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Temporal­Datum</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createTemporalDatum(java.util.Map,java.util.Date)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Temporal­Datum</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>origin</code> - the date and time origin of this temporal datum.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultTemporalDatum.html#%3Cinit%3E(java.util.Map,java.util.Date)"><code>Default­Temporal­Datum(Map, Date)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createTemporalDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Temporal­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createTimeCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTimeCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/TimeCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">TimeCS</a>&nbsp;createTimeCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)
                    throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a temporal coordinate system.
 This coordinate system can be used with temporal and derived CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultTimeCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Time­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createTimeCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Time­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis</code> - the single axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultTimeCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Time­CS(Map, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createTimeCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Time­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricCRS(java.util.Map,org.apache.sis.referencing.datum.DefaultParametricDatum,org.apache.sis.referencing.cs.DefaultParametricCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs">DefaultParametricCRS</a>&nbsp;createParametricCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                                <a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a>&nbsp;datum,
                                                <a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a>&nbsp;cs)
                                         throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li><a href="#createParametricCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>create­Parametric­CS(Map, Coordinate­System­Axis)</code></a></li>
   <li><a href="#createParametricDatum(java.util.Map)"><code>create­Parametric­Datum(Map)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Parametric­CRS</code></a> instance.

 <div class="warning"><b>Warning:</b> in a future SIS version, the parameter types may be changed to
 <code>org​.opengis​.referencing​.datum​.Parametric­Datum</code> and <code>org​.opengis​.referencing​.cs​.Parametric­CS</code>,
 and the return type may be changed to <code>org​.opengis​.referencing​.crs​.Parametric­CRS</code>.
 Those change are pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the parametric datum to use in created CRS.</dd>
<dd><code>cs</code> - the parametric coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultParametricCRS.html#%3Cinit%3E(java.util.Map,org.apache.sis.referencing.datum.DefaultParametricDatum,org.apache.sis.referencing.cs.DefaultParametricCS)"><code>Default­Parametric­CRS(Map, Default­Parametric­Datum, Default­Parametric­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createParametricCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Parametric­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricDatum(java.util.Map)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum">DefaultParametricDatum</a>&nbsp;createParametricDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)
                                             throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a parametric datum.
 The default implementation creates a <a href="../datum/DefaultParametricDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Parametric­Datum</code></a> instance.

 <div class="warning"><b>Warning:</b> in a future SIS version, the return type may be changed
 to <code>org​.opengis​.referencing​.datum​.Parametric­Datum</code>. This change is pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultParametricDatum.html#%3Cinit%3E(java.util.Map)"><code>Default­Parametric­Datum(Map)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createParametricDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Parametric­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createParametricCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createParametricCS</h4>
<pre class="methodSignature">public&nbsp;<a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs">DefaultParametricCS</a>&nbsp;createParametricCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                              <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)
                                       throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a parametric coordinate system.
 This coordinate system can be used only with parametric CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultParametricCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Parametric­CS</code></a> instance.

 <div class="warning"><b>Warning:</b> in a future SIS version, the return type may be changed
 to <code>org​.opengis​.referencing​.cs​.Parametric­CS</code>. This change is pending GeoAPI revision.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis</code> - the single axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultParametricCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Parametric­CS(Map, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createParametricCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Parametric­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createCompoundCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCompoundCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CompoundCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CompoundCRS</a>&nbsp;createCompoundCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                     <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>...&nbsp;components)
                              throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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:

 <ol>
   <li>A mandatory horizontal CRS (only one of two-dimensional <code>Geographic­CRS</code> or <code>Projected­CRS</code> or <code>Engineering­CRS</code>).</li>
   <li>Optionally followed by a <code>Vertical­CRS</code> or a <code>Parametric­CRS</code> (but not both).</li>
   <li>Optionally followed by a <code>Temporal­CRS</code>.</li>
 </ol>

 The default implementation creates a <a href="../crs/DefaultCompoundCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Compound­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createCompoundCRS(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem...)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Compound­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>components</code> - the sequence of coordinate reference systems making the compound CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultCompoundCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.crs.CoordinateReferenceSystem...)"><code>Default­Compound­CRS(Map, Coordinate­Reference­System...)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createCompoundCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Compound­CRS(String)</code></a>, 
<a href="../CRS.html#compound(org.opengis.referencing.crs.CoordinateReferenceSystem...)"><code>CRS​.compound(Coordinate­Reference­System...)</code></a></dd>
</dl>
</li>
</ul>
<a id="createImageCRS(java.util.Map,org.opengis.referencing.datum.ImageDatum,org.opengis.referencing.cs.AffineCS)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createImageCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/ImageCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">ImageCRS</a>&nbsp;createImageCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a>&nbsp;datum,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a>&nbsp;cs)
                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an image coordinate reference system.
 The default implementation creates a <a href="../crs/DefaultImageCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Image­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createImageCRS(java.util.Map,org.opengis.referencing.datum.ImageDatum,org.opengis.referencing.cs.AffineCS)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Image­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the image datum to use in created CRS.</dd>
<dd><code>cs</code> - the Cartesian or oblique Cartesian coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultImageCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.ImageDatum,org.opengis.referencing.cs.AffineCS)"><code>Default­Image­CRS(Map, Image­Datum, Affine­CS)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createImageCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Image­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createImageDatum(java.util.Map,org.opengis.referencing.datum.PixelInCell)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createImageDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/ImageDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">ImageDatum</a>&nbsp;createImageDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                   <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/PixelInCell.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">PixelInCell</a>&nbsp;pixelInCell)
                            throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an image datum.
 The default implementation creates a <a href="../datum/DefaultImageDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Image­Datum</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createImageDatum(java.util.Map,org.opengis.referencing.datum.PixelInCell)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Image­Datum</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - Name and other properties to give to the new object.</dd>
<dd><code>pixel­In­Cell</code> - Specification of the way the image grid is associated with the image data attributes.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultImageDatum.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.PixelInCell)"><code>Default­Image­Datum(Map, Pixel­In­Cell)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createImageDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Image­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAffineCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a>&nbsp;createAffineCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)
                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a two-dimensional affine coordinate system from the given pair of axis.
 This coordinate system can be used with image and engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultAffineCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Affine­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Affine­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultAffineCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Affine­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEngineeringCRS(java.util.Map,org.opengis.referencing.datum.EngineeringDatum,org.opengis.referencing.cs.CoordinateSystem)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEngineeringCRS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/EngineeringCRS.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">EngineeringCRS</a>&nbsp;createEngineeringCRS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a>&nbsp;datum,
                                           <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystem.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystem</a>&nbsp;cs)
                                    throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a engineering coordinate reference system.
 Engineering CRS can be divided into two broad categories:

 <ul>
   <li>earth-fixed systems applied to engineering activities on or near the surface of the earth;</li>
   <li>CRSs on moving platforms such as road vehicles, vessels, aircraft, or spacecraft.</li>
 </ul>

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
   <li>A <code>create­Foo­CS(…)</code> method for Cartesian, spherical, linear, affine, polar, cylindrical or user-defined CS.</li>
   <li><a href="#createEngineeringDatum(java.util.Map)"><code>create­Engineering­Datum(Map)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../crs/DefaultEngineeringCRS.html" title="class in org.apache.sis.referencing.crs"><code>Default­Engineering­CRS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createEngineeringCRS(java.util.Map,org.opengis.referencing.datum.EngineeringDatum,org.opengis.referencing.cs.CoordinateSystem)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­Engineering­CRS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>datum</code> - the engineering datum to use in created CRS.</dd>
<dd><code>cs</code> - the coordinate system for the created CRS.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../crs/DefaultEngineeringCRS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.datum.EngineeringDatum,org.opengis.referencing.cs.CoordinateSystem)"><code>Default­Engineering­CRS(Map, Engineering­Datum, Coordinate­System)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEngineeringCRS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Engineering­CRS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createEngineeringDatum(java.util.Map)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createEngineeringDatum</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/EngineeringDatum.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">EngineeringDatum</a>&nbsp;createEngineeringDatum&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties)
                                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates an engineering datum.
 The default implementation creates a <a href="../datum/DefaultEngineeringDatum.html" title="class in org.apache.sis.referencing.datum"><code>Default­Engineering­Datum</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true#createEngineeringDatum(java.util.Map)" title="class or interface in org.opengis.referencing.datum" class="externalLink">create­Engineering­Datum</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/datum/DatumFactory.html?is-external=true" title="class or interface in org.opengis.referencing.datum" class="externalLink">Datum­Factory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../datum/DefaultEngineeringDatum.html#%3Cinit%3E(java.util.Map)"><code>Default­Engineering­Datum(Map)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createEngineeringDatum(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Engineering­Datum(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createAffineCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AffineCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AffineCS</a>&nbsp;createAffineCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a three-dimensional affine coordinate system from the given set of axis.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultAffineCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Affine­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createAffineCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Affine­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dd><code>axis2</code> - the third  axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultAffineCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Affine­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></dd>
</dl>
</li>
</ul>
<a id="createCylindricalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCylindricalCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CylindricalCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CylindricalCS</a>&nbsp;createCylindricalCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a cylindrical coordinate system from the given set of axis.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultCylindricalCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Cylindrical­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createCylindricalCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Cylindrical­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dd><code>axis2</code> - the third  axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCylindricalCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Cylindrical­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createCylindricalCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Cylindrical­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createPolarCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createPolarCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/PolarCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">PolarCS</a>&nbsp;createPolarCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                             <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)
                      throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a polar coordinate system from the given pair of axis.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultPolarCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Polar­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createPolarCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Polar­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultPolarCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Polar­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createPolarCS(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Polar­CS(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createLinearCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createLinearCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/LinearCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">LinearCS</a>&nbsp;createLinearCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                               <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis)
                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a linear coordinate system.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultLinearCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­Linear­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createLinearCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Linear­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis</code> - the single axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultLinearCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­Linear­CS(Map, Coordinate­System­Axis)</code></a></dd>
</dl>
</li>
</ul>
<a id="createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createUserDefinedCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/UserDefinedCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">UserDefinedCS</a>&nbsp;createUserDefinedCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a two-dimensional user defined coordinate system from the given pair of axis.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultUserDefinedCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­User­Defined­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­User­Defined­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultUserDefinedCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­User­Defined­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></dd>
</dl>
</li>
</ul>
<a id="createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createUserDefinedCS</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/UserDefinedCS.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">UserDefinedCS</a>&nbsp;createUserDefinedCS&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis0,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis1,
                                         <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;axis2)
                                  throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a three-dimensional user defined coordinate system from the given set of axis.
 This coordinate system can be used with engineering CRS.

 <div class="note"><b>Dependencies:</b>
 the components needed by this method can be created by the following methods:
 <ol>
   <li><a href="#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
 </ol></div>

 The default implementation creates a <a href="../cs/DefaultUserDefinedCS.html" title="class in org.apache.sis.referencing.cs"><code>Default­User­Defined­CS</code></a> instance.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createUserDefinedCS(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­User­Defined­CS</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>axis0</code> - the first  axis.</dd>
<dd><code>axis1</code> - the second axis.</dd>
<dd><code>axis2</code> - the third  axis.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultUserDefinedCS.html#%3Cinit%3E(java.util.Map,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis,org.opengis.referencing.cs.CoordinateSystemAxis)"><code>Default­User­Defined­CS(Map, Coordinate­System­Axis, Coordinate­System­Axis, Coordinate­System­Axis)</code></a></dd>
</dl>
</li>
</ul>
<a id="createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCoordinateSystemAxis</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CoordinateSystemAxis</a>&nbsp;createCoordinateSystemAxis&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util" class="externalLink">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>,&#8203;?&gt;&nbsp;properties,
                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;abbreviation,
                                                       <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/AxisDirection.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">AxisDirection</a>&nbsp;direction,
                                                       <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)
                                                throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">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 <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CoordinateSystemAxis.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink"><code>Coordinate­System­Axis</code></a> javadoc for more information.

 <p>The default implementation creates a <a href="../cs/DefaultCoordinateSystemAxis.html" title="class in org.apache.sis.referencing.cs"><code>Default­Coordinate­System­Axis</code></a> instance.</p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)" title="class or interface in org.opengis.referencing.cs" class="externalLink">create­Coordinate­System­Axis</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/cs/CSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.cs" class="externalLink">CSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>properties</code> - name and other properties to give to the new object.</dd>
<dd><code>abbreviation</code> - the coordinate axis abbreviation.</dd>
<dd><code>direction</code> - the axis direction.</dd>
<dd><code>unit</code> - the coordinate axis unit.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../cs/DefaultCoordinateSystemAxis.html#%3Cinit%3E(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>Default­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a>, 
<a href="GeodeticAuthorityFactory.html#createCoordinateSystemAxis(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Coordinate­System­Axis(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createFromXML(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createFromXML</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>&nbsp;createFromXML&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;xml)
                                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a coordinate reference system object from a XML string.
 Note that the given argument is the XML document itself,
 <strong>not</strong> a URL to a XML document.

 <p>The default implementation delegates to <a href="../../xml/XML.html#unmarshal(java.lang.String)"><code>XML​.unmarshal(String)</code></a></p></div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createFromXML(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­From­XML</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>xml</code> - coordinate reference system encoded in XML format.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../xml/XML.html#unmarshal(java.lang.String)"><code>XML​.unmarshal(String)</code></a>, 
<a href="../CRS.html#fromXML(java.lang.String)"><code>CRS​.from­XML(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="createFromWKT(java.lang.String)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>createFromWKT</h4>
<pre class="methodSignature">public&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CoordinateReferenceSystem.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CoordinateReferenceSystem</a>&nbsp;createFromWKT&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;text)
                                        throws <a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">FactoryException</a></pre>
<div class="block">Creates a Coordinate Reference System object from a <cite>Well Known Text</cite> (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.

 <div class="note"><b>Example:</b> below is a slightly simplified WKT 2 string for a Mercator projection.
 For making this example smaller, some optional <code>UNIT[…]</code> and <code>ORDER[…]</code> elements have been omitted.

 <blockquote><pre>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]]</pre></blockquote>
 </div>

 If the given text contains non-fatal anomalies
 (unknown or unsupported WKT elements, inconsistent unit definitions, unparsable axis abbreviations, <i>etc.</i>),
 warnings may be reported in a <a href="https://docs.oracle.com/javase/8/docs/api/java/util/logging/Logger.html?is-external=true" title="class or interface in java.util.logging" class="externalLink">logger</a> named <code>"org​.apache​.sis​.io​.wkt"</code>.
 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 <a href="GeodeticAuthorityFactory.html" title="class in org.apache.sis.referencing.factory">authority factory</a>.
 For such verification, see the <a href="../CRS.html#fromWKT(java.lang.String)"><code>CRS​.from­WKT(String)</code></a> convenience method.

 <div class="section">Usage and performance considerations</div>
 The default implementation uses a shared instance of <a href="../../io/wkt/WKTFormat.html" title="class in org.apache.sis.io.wkt"><code>WKTFormat</code></a>
 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 <a href="../../io/wkt/Convention.html" title="enum in org.apache.sis.io.wkt">conventions</a>
 in use and on the handling of <a href="../../io/wkt/Warnings.html" title="class in org.apache.sis.io.wkt">warnings</a>.
 Applications which need to parse a large amount of WKT strings should consider to use
 the <a href="../../io/wkt/WKTFormat.html" title="class in org.apache.sis.io.wkt"><code>WKTFormat</code></a> class instead than this method.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true#createFromWKT(java.lang.String)" title="class or interface in org.opengis.referencing.crs" class="externalLink">create­From­WKT</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/crs/CRSFactory.html?is-external=true" title="class or interface in org.opengis.referencing.crs" class="externalLink">CRSFactory</a></code></dd>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../io/wkt/Parser.html#createFromWKT(java.lang.String)">create­From­WKT</a></code>&nbsp;in interface&nbsp;<code><a href="../../io/wkt/Parser.html" title="interface in org.apache.sis.io.wkt">Parser</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>text</code> - coordinate system encoded in Well-Known Text format (version 1 or 2).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the result of parsing the given text.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org/opengis/util/FactoryException.html?is-external=true" title="class or interface in org.opengis.util" class="externalLink">Factory­Exception</a></code> - if the object creation failed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../io/wkt/package-summary.html"><code>org​.apache​.sis​.io​.wkt</code></a>, 
<a href="../CRS.html#fromWKT(java.lang.String)"><code>CRS​.from­WKT(String)</code></a>, 
<a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html">WKT 2 specification</a>, 
<a href="http://www.geoapi.org/3.0/javadoc/org/opengis/referencing/doc-files/WKT.html">Legacy WKT 1</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
</div>
</main>
<!-- ========= END OF CLASS DATA ========= -->
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/GeodeticObjectFactory.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &#169; 2010&#x2013;2019 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</body>
</html>
