<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (19) -->
<title>DefaultCoordinateSystemAxis (Apache SIS 1.3 API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.sis.referencing.cs, class: DefaultCoordinateSystemAxis">
<meta name="generator" content="javadoc/ClassWriterImpl">
<meta name="keywords" content="org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis class">
<meta name="keywords" content="MINIMUM_VALUE_KEY">
<meta name="keywords" content="MAXIMUM_VALUE_KEY">
<meta name="keywords" content="RANGE_MEANING_KEY">
<meta name="keywords" content="castOrCopy()">
<meta name="keywords" content="getInterface()">
<meta name="keywords" content="getDirection()">
<meta name="keywords" content="getAbbreviation()">
<meta name="keywords" content="getUnit()">
<meta name="keywords" content="getMinimumValue()">
<meta name="keywords" content="getMaximumValue()">
<meta name="keywords" content="getRangeMeaning()">
<meta name="keywords" content="isHeuristicMatchForName()">
<meta name="keywords" content="equals()">
<meta name="keywords" content="computeHashCode()">
<meta name="keywords" content="formatTo()">
<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="../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-3.6.0.min.js"></script>
<script type="text/javascript" src="../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var pathtoroot = "../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top"><button id="navbar-toggle-button" aria-controls="navbar-top" aria-expanded="false" aria-label="Toggle navigation links"><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span><span class="nav-bar-toggle-icon">&nbsp;</span></button>
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/DefaultCoordinateSystemAxis.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#class">Help</a></li>
</ul>
<ul class="sub-nav-list-small">
<li>
<p>Summary:</p>
<ul>
<li>Nested</li>
<li><a href="#field-summary">Field</a></li>
<li><a href="#constructor-summary">Constr</a></li>
<li><a href="#method-summary">Method</a></li>
</ul>
</li>
<li>
<p>Detail:</p>
<ul>
<li><a href="#field-detail">Field</a></li>
<li><a href="#constructor-detail">Constr</a></li>
<li><a href="#method-detail">Method</a></li>
</ul>
</li>
</ul>
</div>
<div class="sub-nav">
<div id="navbar-sub-list">
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li><a href="#constructor-detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><a href="../../../../../search.html">SEARCH</a>
<input type="text" id="search-input" disabled placeholder="Search">
<input type="reset" id="reset-button" disabled value="reset">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.referencing.cs</a></div>
<h1 title="Class DefaultCoordinateSystemAxis" class="title">Class DefaultCoordinateSystemAxis</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
<div class="inheritance"><a href="../../io/wkt/FormattableObject.html" title="class in org.apache.sis.io.wkt">FormattableObject</a>
<div class="inheritance"><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">AbstractIdentifiedObject</a>
<div class="inheritance">DefaultCoordinateSystemAxis</div>
</div>
</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/io/Serializable.html" title="class or interface in java.io" class="external-link">Serializable</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Formattable.html" title="class or interface in java.util" class="external-link">Formattable</a></code>, <code><a href="../../util/Deprecable.html" title="interface in org.apache.sis.util">Deprecable</a></code>, <code><a href="../../util/LenientComparable.html" title="interface in org.apache.sis.util">Lenient­Comparable</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code>, <code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link">Identified­Object</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">DefaultCoordinateSystemAxis</span>
<span class="extends-implements">extends <a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">AbstractIdentifiedObject</a>
implements <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">CoordinateSystemAxis</a></span></div>
<div class="block">Coordinate system axis name, direction, unit and range of values.

 <h2>Axis names</h2>
 In some case, the axis name is constrained by ISO 19111 depending on the
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/crs/CoordinateReferenceSystem.html" title="class or interface in org.opengis.referencing.crs" class="external-link">coordinate reference system</a> type.
 This constraint works in two directions. For example, the names <cite>"geodetic latitude"</cite> and
 <cite>"geodetic longitude"</cite> shall be used to designate the coordinate axis names associated
 with a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/crs/GeographicCRS.html" title="class or interface in org.opengis.referencing.crs" class="external-link"><code>Geographic­CRS</code></a>. Conversely, these names shall not be used
 in any other context. See the GeoAPI <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>Coordinate­System­Axis</code></a> javadoc for more information.

 <h2>Immutability and thread safety</h2>
 This class is immutable and thus thread-safe if the property <em>values</em> (not necessarily the map itself)
 given to the constructor are also immutable. Unless otherwise noted in the javadoc, this condition holds if all
 components were created using only SIS factories and static constants.</div>
<dl class="notes">
<dt>Since:</dt>
<dd>0.4</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="AbstractCS.html" title="class in org.apache.sis.referencing.cs"><code>Abstract­CS</code></a></li>
<li><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link"><code>Unit</code></a></li>
<li><a href="../../../../../serialized-form.html#org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis">Serialized Form</a></li>
</ul>
</dd>

<p><font size="-1">Defined in the <code>sis-referencing</code> module</font></p>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#MAXIMUM_VALUE_KEY" class="member-name-link">MAXIMUM_VALUE_KEY</a></code></div>
<div class="col-last even-row-color">
<div class="block">Key for the <code>"maximum­Value"</code> property to be given to the constructor.</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#MINIMUM_VALUE_KEY" class="member-name-link">MINIMUM_VALUE_KEY</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Key for the <code>"minimum­Value"</code> property to be given to the constructor.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#RANGE_MEANING_KEY" class="member-name-link">RANGE_MEANING_KEY</a></code></div>
<div class="col-last even-row-color">
<div class="block">Key for the <code>"range­Meaning"</code> property to be given to the constructor.</div>
</div>
</div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-AbstractIdentifiedObject">Fields inherited from class&nbsp;<a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">AbstractIdentifiedObject</a></h3>
<code><a href="../AbstractIdentifiedObject.html#DEPRECATED_KEY">DEPRECATED_KEY</a>, <a href="../AbstractIdentifiedObject.html#LOCALE_KEY">LOCALE_KEY</a></code></div>
<div class="inherited-list">
<h3 id="fields-inherited-from-class-IdentifiedObject">Fields inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link">IdentifiedObject</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#ALIAS_KEY" title="class or interface in org.opengis.referencing" class="external-link">ALIAS_KEY</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#IDENTIFIERS_KEY" title="class or interface in org.opengis.referencing" class="external-link">IDENTIFIERS_KEY</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#NAME_KEY" title="class or interface in org.opengis.referencing" class="external-link">NAME_KEY</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#REMARKS_KEY" title="class or interface in org.opengis.referencing" class="external-link">REMARKS_KEY</a></code></div>
</section>
</li>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<li>
<section class="constructor-summary" id="constructor-summary">
<h2>Constructor Summary</h2>
<div class="caption"><span>Constructors</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier</div>
<div class="table-header col-second">Constructor</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>&nbsp;</code></div>
<div class="col-constructor-name even-row-color"><code><a href="#%3Cinit%3E(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)" class="member-name-link">Default­Coordinate­System­Axis</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>?&gt;&nbsp;properties,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;abbreviation,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Axis­Direction</a>&nbsp;direction,
 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit)</code></div>
<div class="col-last even-row-color">
<div class="block">Constructs an axis from a set of properties.</div>
</div>
<div class="col-first odd-row-color"><code>protected </code></div>
<div class="col-constructor-name odd-row-color"><code><a href="#%3Cinit%3E(org.opengis.referencing.cs.CoordinateSystemAxis)" class="member-name-link">Default­Coordinate­System­Axis</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a>&nbsp;axis)</code></div>
<div class="col-last odd-row-color">
<div class="block">Creates a new coordinate system axis with the same values than the specified one.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="DefaultCoordinateSystemAxis.html" title="class in org.apache.sis.referencing.cs">Default­Coordinate­System­Axis</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#castOrCopy(org.opengis.referencing.cs.CoordinateSystemAxis)" class="member-name-link">cast­Or­Copy</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a>&nbsp;object)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a SIS axis implementation with the same values than the given arbitrary implementation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#computeHashCode()" class="member-name-link">compute­Hash­Code</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Invoked by <code>hash­Code()</code> for computing the hash code when first needed.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#equals(java.lang.Object,org.apache.sis.util.ComparisonMode)" class="member-name-link">equals</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;object,
 <a href="../../util/ComparisonMode.html" title="enum class in org.apache.sis.util">Comparison­Mode</a>&nbsp;mode)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Compares the specified object with this axis for equality.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>protected <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#formatTo(org.apache.sis.io.wkt.Formatter)" class="member-name-link">format­To</a><wbr>(<a href="../../io/wkt/Formatter.html" title="class in org.apache.sis.io.wkt">Formatter</a>&nbsp;formatter)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Formats this axis as a <cite>Well Known Text</cite> <code>Axis[…]</code> element.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getAbbreviation()" class="member-name-link">get­Abbreviation</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the abbreviation used for this coordinate system axes.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Axis­Direction</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getDirection()" class="member-name-link">get­Direction</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the direction of this coordinate system axis.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;? extends <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getInterface()" class="member-name-link">get­Interface</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the GeoAPI interface implemented by this class.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMaximumValue()" class="member-name-link">get­Maximum­Value</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the maximum value normally allowed for this axis, in the <a href="#getUnit()">unit of measure for the axis</a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMinimumValue()" class="member-name-link">get­Minimum­Value</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the minimum value normally allowed for this axis, in the <a href="#getUnit()">unit of measure for the axis</a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/RangeMeaning.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Range­Meaning</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getRangeMeaning()" class="member-name-link">get­Range­Meaning</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the meaning of axis value range specified by the <a href="#getMinimumValue()">minimum</a>
 and <a href="#getMaximumValue()">maximum</a> values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getUnit()" class="member-name-link">get­Unit</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the unit of measure used for this coordinate system axis.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isHeuristicMatchForName(java.lang.String)" class="member-name-link">is­Heuristic­Match­For­Name</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns <code>true</code> if either the <a href="../AbstractIdentifiedObject.html#getName()">primary name</a> or at least
 one <a href="../AbstractIdentifiedObject.html#getAlias()">alias</a> matches the given string according heuristic rules.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-AbstractIdentifiedObject">Methods inherited from class&nbsp;<a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">AbstractIdentifiedObject</a></h3>
<code><a href="../AbstractIdentifiedObject.html#castOrCopy(org.opengis.referencing.IdentifiedObject)">cast­Or­Copy</a>, <a href="../AbstractIdentifiedObject.html#equals(java.lang.Object)">equals</a>, <a href="../AbstractIdentifiedObject.html#formatTo(java.util.Formatter,int,int,int)">format­To</a>, <a href="../AbstractIdentifiedObject.html#getAlias()">get­Alias</a>, <a href="../AbstractIdentifiedObject.html#getDescription()">get­Description</a>, <a href="../AbstractIdentifiedObject.html#getIdentifiers()">get­Identifiers</a>, <a href="../AbstractIdentifiedObject.html#getName()">get­Name</a>, <a href="../AbstractIdentifiedObject.html#getRemarks()">get­Remarks</a>, <a href="../AbstractIdentifiedObject.html#hashCode()">hash­Code</a>, <a href="../AbstractIdentifiedObject.html#isDeprecated()">is­Deprecated</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-FormattableObject">Methods inherited from class&nbsp;<a href="../../io/wkt/FormattableObject.html" title="class in org.apache.sis.io.wkt">FormattableObject</a></h3>
<code><a href="../../io/wkt/FormattableObject.html#print()">print</a>, <a href="../../io/wkt/FormattableObject.html#toString()">to­String</a>, <a href="../../io/wkt/FormattableObject.html#toString(org.apache.sis.io.wkt.Convention)">to­String</a>, <a href="../../io/wkt/FormattableObject.html#toWKT()">to­WKT</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-Object">Methods inherited from class&nbsp;<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">get­Class</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notify­All</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-IdentifiedObject">Methods inherited from interface&nbsp;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html" title="class or interface in org.opengis.referencing" class="external-link">IdentifiedObject</a></h3>
<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#getAlias()" title="class or interface in org.opengis.referencing" class="external-link">get­Alias</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#getIdentifiers()" title="class or interface in org.opengis.referencing" class="external-link">get­Identifiers</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#getName()" title="class or interface in org.opengis.referencing" class="external-link">get­Name</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#getRemarks()" title="class or interface in org.opengis.referencing" class="external-link">get­Remarks</a>, <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#toWKT()" title="class or interface in org.opengis.referencing" class="external-link">to­WKT</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="MINIMUM_VALUE_KEY">
<h3>MINIMUM_VALUE_KEY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">MINIMUM_VALUE_KEY</span></div>
<div class="block">Key for the <code>"minimum­Value"</code> property to be given to the constructor.
 This is used for setting the value to be returned by <a href="#getMinimumValue()"><code>get­Minimum­Value()</code></a>.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis.MINIMUM_VALUE_KEY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="MAXIMUM_VALUE_KEY">
<h3>MAXIMUM_VALUE_KEY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">MAXIMUM_VALUE_KEY</span></div>
<div class="block">Key for the <code>"maximum­Value"</code> property to be given to the constructor.
 This is used for setting the value to be returned by <a href="#getMaximumValue()"><code>get­Maximum­Value()</code></a>.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis.MAXIMUM_VALUE_KEY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="RANGE_MEANING_KEY">
<h3>RANGE_MEANING_KEY</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">RANGE_MEANING_KEY</span></div>
<div class="block">Key for the <code>"range­Meaning"</code> property to be given to the constructor.
 This is used for setting the value to be returned by <a href="#getRangeMeaning()"><code>get­Range­Meaning()</code></a>.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../../constant-values.html#org.apache.sis.referencing.cs.DefaultCoordinateSystemAxis.RANGE_MEANING_KEY">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<li>
<section class="constructor-details" id="constructor-detail">
<h2>Constructor Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="&lt;init&gt;(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)">
<h3>DefaultCoordinateSystemAxis</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="element-name">DefaultCoordinateSystemAxis</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>?&gt;&nbsp;properties,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;abbreviation,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html" title="class or interface in org.opengis.referencing.cs" class="external-link">AxisDirection</a>&nbsp;direction,
 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;&nbsp;unit)</span></div>
<div class="block">Constructs an axis from a set of properties. The properties given in argument follow the same rules
 than for the <a href="../AbstractIdentifiedObject.html#%3Cinit%3E(java.util.Map)">super-class constructor</a>.
 Additionally, the following properties are understood by this constructor:

 <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="#MINIMUM_VALUE_KEY">"minimumValue"</a></td>
     <td><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link"><code>Number</code></a></td>
     <td><a href="#getMinimumValue()"><code>getMinimumValue()</code></a></td>
   </tr>
   <tr>
     <td><a href="#MAXIMUM_VALUE_KEY">"maximumValue"</a></td>
     <td><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Number.html" title="class or interface in java.lang" class="external-link"><code>Number</code></a></td>
     <td><a href="#getMaximumValue()"><code>getMaximumValue()</code></a></td>
   </tr>
   <tr>
     <td><a href="#RANGE_MEANING_KEY">"rangeMeaning"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/RangeMeaning.html" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>RangeMeaning</code></a></td>
     <td><a href="#getRangeMeaning()"><code>getRangeMeaning()</code></a></td>
   </tr>
   <tr>
     <th colspan="3" class="hsep">Defined in parent class (reminder)</th>
   </tr>
   <tr>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/IdentifiedObject.html#NAME_KEY" title="class or interface in org.opengis.referencing" class="external-link">"name"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceIdentifier.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceIdentifier</code></a> or <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link"><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.geoapi/org/opengis/referencing/IdentifiedObject.html#ALIAS_KEY" title="class or interface in org.opengis.referencing" class="external-link">"alias"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/GenericName.html" title="class or interface in org.opengis.util" class="external-link"><code>GenericName</code></a> or <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/CharSequence.html" title="class or interface in java.lang" class="external-link"><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.geoapi/org/opengis/referencing/IdentifiedObject.html#IDENTIFIERS_KEY" title="class or interface in org.opengis.referencing" class="external-link">"identifiers"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/ReferenceIdentifier.html" title="class or interface in org.opengis.referencing" class="external-link"><code>ReferenceIdentifier</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.geoapi/org/opengis/referencing/IdentifiedObject.html#REMARKS_KEY" title="class or interface in org.opengis.referencing" class="external-link">"remarks"</a></td>
     <td><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/util/InternationalString.html" title="class or interface in org.opengis.util" class="external-link"><code>InternationalString</code></a> or <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link"><code>String</code></a></td>
     <td><a href="../AbstractIdentifiedObject.html#getRemarks()"><code>AbstractIdentifiedObject.getRemarks()</code></a></td>
   </tr>
 </table>

 Generally speaking, information provided in the <code>properties</code> map are considered ignorable metadata
 (except the axis name) while information provided as explicit arguments may have an impact on coordinate
 transformation results. Exceptions to this rule are the <code>minimum­Value</code> and <code>maximum­Value</code> in
 the particular case where <code>range­Meaning</code> is <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/RangeMeaning.html#WRAPAROUND" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>Range­Meaning​.WRAPAROUND</code></a>.

 <p>If no minimum, maximum and range meaning are specified, then this constructor will infer them
 from the axis unit and direction.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>properties</code> - the properties to be given to the identified object.</dd>
<dd><code>abbreviation</code> - the <a href="#getAbbreviation()">abbreviation</a> used for this coordinate system axis.</dd>
<dd><code>direction</code> - the <a href="#getDirection()">direction</a> of this coordinate system axis.</dd>
<dd><code>unit</code> - the <a href="#getUnit()">unit of measure</a> used for this coordinate system axis.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../factory/GeodeticObjectFactory.html#createCoordinateSystemAxis(java.util.Map,java.lang.String,org.opengis.referencing.cs.AxisDirection,javax.measure.Unit)"><code>Geodetic­Object­Factory​.create­Coordinate­System­Axis(Map, String, Axis­Direction, Unit)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="&lt;init&gt;(org.opengis.referencing.cs.CoordinateSystemAxis)">
<h3>DefaultCoordinateSystemAxis</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="element-name">DefaultCoordinateSystemAxis</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">CoordinateSystemAxis</a>&nbsp;axis)</span></div>
<div class="block">Creates a new coordinate system axis with the same values than the specified one.
 This copy constructor provides a way to convert an arbitrary implementation into a SIS one
 or a user-defined one (as a subclass), usually in order to leverage some implementation-specific API.

 <p>This constructor performs a shallow copy, i.e. the properties are not cloned.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>axis</code> - the coordinate system axis to copy.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="#castOrCopy(org.opengis.referencing.cs.CoordinateSystemAxis)"><code>cast­Or­Copy(Coordinate­System­Axis)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="castOrCopy(org.opengis.referencing.cs.CoordinateSystemAxis)">
<h3>castOrCopy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="DefaultCoordinateSystemAxis.html" title="class in org.apache.sis.referencing.cs">DefaultCoordinateSystemAxis</a></span>&nbsp;<span class="element-name">castOrCopy</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">CoordinateSystemAxis</a>&nbsp;object)</span></div>
<div class="block">Returns a SIS axis implementation with the same values than the given arbitrary implementation.
 If the given object is <code>null</code>, then this method returns <code>null</code>. Otherwise if the
 given object is already a SIS implementation, then the given object is returned unchanged.
 Otherwise a new SIS implementation is created and initialized to the values of the given object.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>object</code> - the object to get as a SIS implementation, or <code>null</code> if none.</dd>
<dt>Returns:</dt>
<dd>a SIS implementation containing the values of the given object (may be the
         given object itself), or <code>null</code> if the argument was null.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getInterface()">
<h3>getInterface</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;? extends <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">CoordinateSystemAxis</a>&gt;</span>&nbsp;<span class="element-name">getInterface</span>()</div>
<div class="block">Returns the GeoAPI interface implemented by this class.
 The SIS implementation returns <code>Coordinate­System­Axis​.class</code>.

 <div class="note"><b>Note for implementers:</b>
 Subclasses usually do not need to override this method since GeoAPI does not define <code>Coordinate­System­Axis</code>
 sub-interface. Overriding possibility is left mostly for implementers who wish to extend GeoAPI with their own
 set of interfaces.</div></div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="../AbstractIdentifiedObject.html#getInterface()">get­Interface</a></code>&nbsp;in class&nbsp;<code><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">Abstract­Identified­Object</a></code></dd>
<dt>Returns:</dt>
<dd><code>Coordinate­System­Axis​.class</code> or a user-defined sub-interface.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDirection()">
<h3>getDirection</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html" title="class or interface in org.opengis.referencing.cs" class="external-link">AxisDirection</a></span>&nbsp;<span class="element-name">getDirection</span>()</div>
<div class="block">Returns the direction of this coordinate system axis.
 This direction is often approximate and intended to provide a human interpretable meaning to the axis.
 A <a href="AbstractCS.html" title="class in org.apache.sis.referencing.cs">coordinate system</a> cannot contain two axes having the same direction or
 opposite directions.

 <p>Examples:
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#NORTH" title="class or interface in org.opengis.referencing.cs" class="external-link">north</a> or <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#SOUTH" title="class or interface in org.opengis.referencing.cs" class="external-link">south</a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#EAST" title="class or interface in org.opengis.referencing.cs" class="external-link">east</a>  or <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#WEST" title="class or interface in org.opengis.referencing.cs" class="external-link">west</a>,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#UP" title="class or interface in org.opengis.referencing.cs" class="external-link">up</a>    or <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/AxisDirection.html#DOWN" title="class or interface in org.opengis.referencing.cs" class="external-link">down</a>.</p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getDirection()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Direction</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the direction of this coordinate system axis.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getAbbreviation()">
<h3>getAbbreviation</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getAbbreviation</span>()</div>
<div class="block">Returns the abbreviation used for this coordinate system axes.
 Examples are <cite>"X"</cite> and <cite>"Y"</cite>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getAbbreviation()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Abbreviation</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the coordinate system axis abbreviation.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getUnit()">
<h3>getUnit</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html" title="class or interface in javax.measure" class="external-link">Unit</a>&lt;?&gt;</span>&nbsp;<span class="element-name">getUnit</span>()</div>
<div class="block">Returns the unit of measure used for this coordinate system axis. If this <code>Coordinate­System­Axis</code> was
 given by <code><a href="AbstractCS.html#getAxis(int)"><code>Coordinate­System​.get­Axis</code></a>(i)</code>, then all coordinate
 values at dimension <var>i</var> in a coordinate tuple shall be recorded using this unit of measure.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getUnit()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Unit</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the unit of measure used for coordinate values along this coordinate system axis.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMinimumValue()">
<h3>getMinimumValue</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getMinimumValue</span>()</div>
<div class="block">Returns the minimum value normally allowed for this axis, in the <a href="#getUnit()">unit of measure for the axis</a>. If there is no minimum value, then this method returns
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Double.html#NEGATIVE_INFINITY" title="class or interface in java.lang" class="external-link">negative infinity</a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getMinimumValue()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Minimum­Value</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the minimum value normally allowed for this axis.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMaximumValue()">
<h3>getMaximumValue</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getMaximumValue</span>()</div>
<div class="block">Returns the maximum value normally allowed for this axis, in the <a href="#getUnit()">unit of measure for the axis</a>. If there is no maximum value, then this method returns
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Double.html#POSITIVE_INFINITY" title="class or interface in java.lang" class="external-link">negative infinity</a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getMaximumValue()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Maximum­Value</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the maximum value normally allowed for this axis.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getRangeMeaning()">
<h3>getRangeMeaning</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/RangeMeaning.html" title="class or interface in org.opengis.referencing.cs" class="external-link">RangeMeaning</a></span>&nbsp;<span class="element-name">getRangeMeaning</span>()</div>
<div class="block">Returns the meaning of axis value range specified by the <a href="#getMinimumValue()">minimum</a>
 and <a href="#getMaximumValue()">maximum</a> values. If there is no minimum and maximum values
 (i.e. if those values are <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Double.html#NEGATIVE_INFINITY" title="class or interface in java.lang" class="external-link">negative infinity</a> and
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Double.html#POSITIVE_INFINITY" title="class or interface in java.lang" class="external-link">positive infinity</a> respectively), then this method returns <code>null</code>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html#getRangeMeaning()" title="class or interface in org.opengis.referencing.cs" class="external-link">get­Range­Meaning</a></code>&nbsp;in interface&nbsp;<code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link">Coordinate­System­Axis</a></code></dd>
<dt>Returns:</dt>
<dd>the meaning of axis value range, or <code>null</code> if unspecified.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isHeuristicMatchForName(java.lang.String)">
<h3>isHeuristicMatchForName</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isHeuristicMatchForName</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Returns <code>true</code> if either the <a href="../AbstractIdentifiedObject.html#getName()">primary name</a> or at least
 one <a href="../AbstractIdentifiedObject.html#getAlias()">alias</a> matches the given string according heuristic rules.
 This method performs the comparison documented in the
 <a href="../AbstractIdentifiedObject.html#isHeuristicMatchForName(java.lang.String)"><code>super-class</code></a>,
 with an additional flexibility for latitudes and longitudes:

 <ul>
   <li><code>"Lat"</code>, <code>"Latitude"</code>  and <code>"Geodetic latitude"</code>  are considered equivalent.</li>
   <li><code>"Lon"</code>, <code>"Longitude"</code> and <code>"Geodetic longitude"</code> are considered equivalent.</li>
 </ul>

 The above special cases are needed in order to workaround a conflict in specifications:
 ISO 19111 states explicitly that the latitude and longitude axis names shall be
 <cite>"Geodetic latitude"</cite> and <cite>"Geodetic longitude"</cite>, while the legacy
 OGC 01-009 (where version 1 of the WKT format is defined) said that the default values shall be
 <cite>"Lat"</cite> and <cite>"Lon"</cite>.

 <h4>Future evolutions</h4>
 This method implements heuristic rules learned from experience while trying to provide inter-operability
 with different data producers. Those rules may be adjusted in any future SIS version according experience
 gained while working with more data producers.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="../AbstractIdentifiedObject.html#isHeuristicMatchForName(java.lang.String)">is­Heuristic­Match­For­Name</a></code>&nbsp;in class&nbsp;<code><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">Abstract­Identified­Object</a></code></dd>
<dt>Parameters:</dt>
<dd><code>name</code> - the name to compare.</dd>
<dt>Returns:</dt>
<dd><code>true</code> if the primary name of at least one alias matches the specified <code>name</code>.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../IdentifiedObjects.html#isHeuristicMatchForName(org.opengis.referencing.IdentifiedObject,java.lang.String)"><code>Identified­Objects​.is­Heuristic­Match­For­Name(Identified­Object, String)</code></a></li>
<li><a href="../../util/Characters.Filter.html#LETTERS_AND_DIGITS"><code>Characters​.Filter​.LETTERS_AND_DIGITS</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equals(java.lang.Object,org.apache.sis.util.ComparisonMode)">
<h3>equals</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equals</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;object,
 <a href="../../util/ComparisonMode.html" title="enum class in org.apache.sis.util">ComparisonMode</a>&nbsp;mode)</span></div>
<div class="block">Compares the specified object with this axis for equality.
 The strictness level is controlled by the second argument.
 This method compares the following properties in every cases:

 <ul>
   <li><a href="../AbstractIdentifiedObject.html#getName()"><code>Abstract­Identified­Object​.get­Name()</code></a></li>
   <li><a href="#getDirection()"><code>get­Direction()</code></a></li>
   <li><a href="#getUnit()"><code>get­Unit()</code></a></li>
 </ul>

 In the particular case where <a href="#getRangeMeaning()"><code>get­Range­Meaning()</code></a> is <code>WRAPAROUND</code>, then <a href="#getMinimumValue()"><code>get­Minimum­Value()</code></a>
 and <a href="#getMaximumValue()"><code>get­Maximum­Value()</code></a> are considered non-ignorable metadata and will be compared for every modes.
 All other properties are compared only for modes stricter than <a href="../../util/ComparisonMode.html#IGNORE_METADATA"><code>Comparison­Mode​.IGNORE_METADATA</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../../util/LenientComparable.html#equals(java.lang.Object,org.apache.sis.util.ComparisonMode)">equals</a></code>&nbsp;in interface&nbsp;<code><a href="../../util/LenientComparable.html" title="interface in org.apache.sis.util">Lenient­Comparable</a></code></dd>
<dt>Overrides:</dt>
<dd><code><a href="../AbstractIdentifiedObject.html#equals(java.lang.Object,org.apache.sis.util.ComparisonMode)">equals</a></code>&nbsp;in class&nbsp;<code><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">Abstract­Identified­Object</a></code></dd>
<dt>Parameters:</dt>
<dd><code>object</code> - the object to compare to <code>this</code>.</dd>
<dd><code>mode</code> - <a href="../../util/ComparisonMode.html#STRICT"><code>STRICT</code></a> for performing a strict comparison, or
                 <a href="../../util/ComparisonMode.html#IGNORE_METADATA"><code>IGNORE_METADATA</code></a> for comparing only
                 properties relevant to coordinate transformations.</dd>
<dt>Returns:</dt>
<dd><code>true</code> if both objects are equal.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../AbstractIdentifiedObject.html#computeHashCode()"><code>Abstract­Identified­Object​.compute­Hash­Code()</code></a></li>
<li><a href="../../util/Utilities.html#deepEquals(java.lang.Object,java.lang.Object,org.apache.sis.util.ComparisonMode)"><code>Utilities​.deep­Equals(Object, Object, Comparison­Mode)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="computeHashCode()">
<h3>computeHashCode</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">computeHashCode</span>()</div>
<div class="block">Invoked by <code>hash­Code()</code> for computing the hash code when first needed.
 See <a href="../AbstractIdentifiedObject.html#computeHashCode()"><code>Abstract­Identified­Object​.compute­Hash­Code()</code></a>
 for more information.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="../AbstractIdentifiedObject.html#computeHashCode()">compute­Hash­Code</a></code>&nbsp;in class&nbsp;<code><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">Abstract­Identified­Object</a></code></dd>
<dt>Returns:</dt>
<dd>the hash code value. This value may change in any future Apache SIS version.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="formatTo(org.apache.sis.io.wkt.Formatter)">
<h3>formatTo</h3>
<div class="member-signature"><span class="modifiers">protected</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">formatTo</span><wbr><span class="parameters">(<a href="../../io/wkt/Formatter.html" title="class in org.apache.sis.io.wkt">Formatter</a>&nbsp;formatter)</span></div>
<div class="block">Formats this axis as a <cite>Well Known Text</cite> <code>Axis[…]</code> element.

 <h4>Constraints for WKT validity</h4>
 The ISO 19162 specification puts many constraints on axis names, abbreviations and directions allowed in WKT.
 Most of those constraints are inherited from ISO 19111 — see <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/CoordinateSystemAxis.html" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>Coordinate­System­Axis</code></a> javadoc for some of
 those. The current Apache SIS implementation does not verify whether this axis name and abbreviation are
 compliant; we assume that the user created a valid axis.
 The only actions (derived from ISO 19162 rules) taken by this method (by default) are:

 <ul>
   <li>Replace <cite>“Geodetic latitude”</cite> and <cite>“Geodetic longitude”</cite> names (case insensitive)
       by <cite>“latitude”</cite> and <cite>“longitude”</cite> respectively.</li>
   <li>For latitude and longitude axes, replace “φ” and “λ” abbreviations by <var>“B”</var> and <var>“L”</var>
       respectively (from German “Breite” and “Länge”, used in academic texts worldwide).
       Note that <var>“L”</var> is also the transliteration of Greek letter “lambda” (λ).</li>
   <li>In <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/SphericalCS.html" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>Spherical­CS</code></a>, replace “φ” and “θ” abbreviations by <var>“U”</var> and <var>“V”</var> respectively.</li>
   <li>In <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/cs/PolarCS.html" title="class or interface in org.opengis.referencing.cs" class="external-link"><code>Polar­CS</code></a>, replace “θ” abbreviation by <var>“U”</var>.</li>
 </ul>

 The above-cited replacements of name and Greek letters can be controlled by a call to
 <a href="../../io/wkt/WKTFormat.html#setTransliterator(org.apache.sis.io.wkt.Transliterator)"><code>WKTFormat​.set­Transliterator(Transliterator)</code></a>.</div>
<dl class="notes">
<dt>Overrides:</dt>
<dd><code><a href="../AbstractIdentifiedObject.html#formatTo(org.apache.sis.io.wkt.Formatter)">format­To</a></code>&nbsp;in class&nbsp;<code><a href="../AbstractIdentifiedObject.html" title="class in org.apache.sis.referencing">Abstract­Identified­Object</a></code></dd>
<dt>Parameters:</dt>
<dd><code>formatter</code> - the formatter where to format the inner content of this WKT element.</dd>
<dt>Returns:</dt>
<dd><code>"Axis"</code>.</dd>
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="http://docs.opengeospatial.org/is/12-063r5/12-063r5.html#39">WKT 2 specification §7.5.3</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &#169; 2010&#x2013;2022 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
