<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (21) on Thu Oct 05 19:54:57 CEST 2023 -->
<title>MathTransforms (Apache SIS 1.4 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="dc.created" content="2023-10-05">
<meta name="description" content="declaration: module: org.apache.sis.referencing, package: org.apache.sis.referencing.operation.transform, class: MathTransforms">
<meta name="generator" content="javadoc/ClassWriterImpl">
<meta name="keywords" content="org.apache.sis.referencing.operation.transform.MathTransforms class">
<meta name="keywords" content="identity()">
<meta name="keywords" content="uniformTranslation()">
<meta name="keywords" content="translation()">
<meta name="keywords" content="scale()">
<meta name="keywords" content="linear()">
<meta name="keywords" content="tangent()">
<meta name="keywords" content="convert()">
<meta name="keywords" content="interpolate()">
<meta name="keywords" content="specialize()">
<meta name="keywords" content="passThrough()">
<meta name="keywords" content="compound()">
<meta name="keywords" content="concatenate()">
<meta name="keywords" content="bidimensional()">
<meta name="keywords" content="getSteps()">
<meta name="keywords" content="getMatrix()">
<meta name="keywords" content="getDomain()">
<meta name="keywords" content="derivativeAndTransform()">
<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">
<script type="text/javascript" src="../../../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../../../script-dir/jquery-3.6.1.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="../../../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</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>Field</li>
<li>Constr</li>
<li><a href="#method-summary">Method</a></li>
</ul>
</li>
<li>
<p>Detail:</p>
<ul>
<li>Field</li>
<li>Constr</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>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&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="module-label-in-type">Module</span>&nbsp;<a href="../../../../../../module-summary.html">org.apache.sis.referencing</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.referencing.operation.transform</a></div>
<h1 title="Class MathTransforms" class="title">Class MathTransforms</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/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="../../../../../../../org.apache.sis.util/org/apache/sis/util/Static.html" title="class in org.apache.sis.util">Static</a>
<div class="inheritance">MathTransforms</div>
</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">MathTransforms</span>
<span class="extends-implements">extends <a href="../../../../../../../org.apache.sis.util/org/apache/sis/util/Static.html" title="class in org.apache.sis.util">Static</a></span></div>
<div class="block">Utility methods creating or working on <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform</code></a> instances.
 This class centralizes in one place some of the most commonly used functions this package.
 The <code>Math­Transforms</code> class provides the following services:

 <ul>
   <li>Create various SIS implementations of <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform</code></a>.</li>
   <li>Perform non-standard operations on arbitrary instances.</li>
 </ul>

 The factory static methods are provided as convenient alternatives to the GeoAPI <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransformFactory.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform­Factory</code></a>
 interface. However, users seeking for more implementation neutrality are encouraged to limit themselves to the
 GeoAPI factory interfaces instead.</div>
<dl class="notes">
<dt>Since:</dt>
<dd>0.5</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list">
<li><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransformFactory.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform­Factory</code></a></li>
</ul>
</dd>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== 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-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><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated 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="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#bidimensional(org.opengis.referencing.operation.MathTransform)" class="member-name-link">bidimensional</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the given transform as a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> instance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#compound(org.opengis.referencing.operation.MathTransform...)" class="member-name-link">compound</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>...&nbsp;components)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Puts together a list of independent math transforms, each of them operating on a subset of coordinate values.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a>&nbsp;tr2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the given one-dimensional transforms.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a>&nbsp;tr3)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the three given one-dimensional transforms.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a>&nbsp;tr2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the given two-dimensional transforms.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform2D</a>&nbsp;tr3)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the three given two-dimensional transforms.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;tr2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the two given transforms.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)" class="member-name-link">concatenate</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;tr3)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Concatenates the three given transforms.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#convert(javax.measure.UnitConverter)" class="member-name-link">convert</a><wbr>(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html" title="class or interface in javax.measure" class="external-link">Unit­Converter</a>&nbsp;converter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts the given unit converter to a math transform.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#derivativeAndTransform(org.opengis.referencing.operation.MathTransform,double%5B%5D,int,double%5B%5D,int)" class="member-name-link">derivative­And­Transform</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform,
 double[]&nbsp;src­Pts,
 int&nbsp;src­Off,
 double[]&nbsp;dst­Pts,
 int&nbsp;dst­Off)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">A buckle method for calculating derivative and coordinate transformation in a single step.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a><wbr>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/Envelope.html" title="class or interface in org.opengis.geometry" class="external-link">Envelope</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDomain(org.opengis.referencing.operation.MathTransform)" class="member-name-link">get­Domain</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;evaluated)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns source coordinate values where the transform is mathematically and numerically applicable.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMatrix(org.opengis.referencing.operation.MathTransform)" class="member-name-link">get­Matrix</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">If the given transform is linear, returns its coefficients as a matrix.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getMatrix(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)" class="member-name-link">get­Matrix</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;to­Approximate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">Direct­Position</a>&nbsp;tangent­Point)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the coefficients of an affine transform in the vicinity of the given position.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a><wbr>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getSteps(org.opengis.referencing.operation.MathTransform)" class="member-name-link">get­Steps</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns all single components of the given (potentially concatenated) transform.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#identity(int)" class="member-name-link">identity</a><wbr>(int&nbsp;dimension)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an identity transform of the specified dimension.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform1D</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#interpolate(double%5B%5D,double%5B%5D)" class="member-name-link">interpolate</a><wbr>(double[]&nbsp;preimage,
 double[]&nbsp;values)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a transform for the <i>y=f(x)</i> function where <var>y</var> are computed by a linear interpolation.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#linear(double,double)" class="member-name-link">linear</a><wbr>(double&nbsp;scale,
 double&nbsp;offset)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a one-dimensional affine transform for the given coefficients.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#linear(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)" class="member-name-link">linear</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;transform,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">Direct­Position</a>&nbsp;position)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span>
<div class="deprecation-comment">This method duplicates <a href="#tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)"><code>tangent(Math­Transform, Direct­Position)</code></a>.</div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#linear(org.opengis.referencing.operation.Matrix)" class="member-name-link">linear</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a>&nbsp;matrix)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an arbitrary linear transform from the specified matrix.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#passThrough(int%5B%5D,org.opengis.referencing.operation.MathTransform,int)" class="member-name-link">pass­Through</a><wbr>(int[]&nbsp;modified­Coordinates,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;sub­Transform,
 int&nbsp;result­Dim)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a transform which passes through a subset of coordinates to another transform.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#passThrough(int,org.opengis.referencing.operation.MathTransform,int)" class="member-name-link">pass­Through</a><wbr>(int&nbsp;first­Affected­Coordinate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;sub­Transform,
 int&nbsp;num­Trailing­Coordinates)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a transform which passes through a subset of coordinates to another transform.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#scale(double...)" class="member-name-link">scale</a><wbr>(double...&nbsp;factors)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an affine transform which applies the given scale.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#specialize(org.opengis.referencing.operation.MathTransform,java.util.Map)" class="member-name-link">specialize</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;global,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/Envelope.html" title="class or interface in org.opengis.geometry" class="external-link">Envelope</a>,<wbr><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&gt;&nbsp;specializations)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a transform defined as one transform applied globally except in sub-areas where more accurate
 transforms are available.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)" class="member-name-link">tangent</a><wbr>(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Math­Transform</a>&nbsp;to­Approximate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">Direct­Position</a>&nbsp;tangent­Point)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a linear (usually affine) transform which approximates the given transform in the vicinity of the given position.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#translation(double...)" class="member-name-link">translation</a><wbr>(double...&nbsp;vector)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an affine transform which applies the given translation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">Linear­Transform</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#uniformTranslation(int,double)" class="member-name-link">uniform­Translation</a><wbr>(int&nbsp;dimension,
 double&nbsp;offset)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates an affine transform which applies the same translation for all dimensions.</div>
</div>
</div>
</div>
</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/11/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/11/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/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/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/11/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/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hash­Code</a>, <a href="https://docs.oracle.com/en/java/javase/11/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/11/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/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">to­String</a>, <a href="https://docs.oracle.com/en/java/javase/11/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/11/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/11/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>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="identity(int)">
<h3>identity</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">identity</span><wbr><span class="parameters">(int&nbsp;dimension)</span></div>
<div class="block">Returns an identity transform of the specified dimension.

 <p>Special cases:</p>
 <ul>
   <li>If <code>dimension == 1</code>, then the returned transform implements <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform1D</code></a>.</li>
   <li>If <code>dimension == 2</code>, then the returned transform implements <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a>.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dimension</code> - number of dimensions of the transform to be returned.</dd>
<dt>Returns:</dt>
<dd>an identity transform of the specified dimension.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="uniformTranslation(int,double)">
<h3>uniformTranslation</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">uniformTranslation</span><wbr><span class="parameters">(int&nbsp;dimension,
 double&nbsp;offset)</span></div>
<div class="block">Creates an affine transform which applies the same translation for all dimensions.
 For each dimension, input values <var>x</var> are converted into output values <var>y</var>
 using the following equation:

 <blockquote><var>y</var> = <var>x</var> + <code>offset</code></blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dimension</code> - number of input and output dimensions.</dd>
<dd><code>offset</code> - the <code>offset</code> term in the linear equation.</dd>
<dt>Returns:</dt>
<dd>an affine transform applying the specified translation.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="translation(double...)">
<h3>translation</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">translation</span><wbr><span class="parameters">(double...&nbsp;vector)</span></div>
<div class="block">Creates an affine transform which applies the given translation.
 The source and target dimensions of the transform are the length of the given vector.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>vector</code> - the translation vector.</dd>
<dt>Returns:</dt>
<dd>an affine transform applying the specified translation.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="scale(double...)">
<h3>scale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">scale</span><wbr><span class="parameters">(double...&nbsp;factors)</span></div>
<div class="block">Creates an affine transform which applies the given scale.
 The source and target dimensions of the transform are the length of the given vector.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>factors</code> - the scale factors.</dd>
<dt>Returns:</dt>
<dd>an affine transform applying the specified scales.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="linear(double,double)">
<h3>linear</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">linear</span><wbr><span class="parameters">(double&nbsp;scale,
 double&nbsp;offset)</span></div>
<div class="block">Creates a one-dimensional affine transform for the given coefficients.
 Input values <var>x</var> will be converted into output values <var>y</var> using the following equation:

 <blockquote><var>y</var>  =  <var>x</var> ⋅ <code>scale</code> + <code>offset</code></blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>scale</code> - the <code>scale</code>  term in the linear equation.</dd>
<dd><code>offset</code> - the <code>offset</code> term in the linear equation.</dd>
<dt>Returns:</dt>
<dd>the linear transform for the given scale and offset.</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="../../../../../../../org.apache.sis.util/org/apache/sis/measure/Units.html#converter(java.lang.Number,java.lang.Number)"><code>Units​.converter(Number, Number)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="linear(org.opengis.referencing.operation.Matrix)">
<h3>linear</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">linear</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a>&nbsp;matrix)</span></div>
<div class="block">Creates an arbitrary linear transform from the specified matrix. Usually the matrix
 <a href="../matrix/MatrixSIS.html#isAffine()">is affine</a>,
 but this is not mandatory. Non-affine matrix will define a projective transform.

 <p>If the transform input dimension is <code>M</code>, and output dimension is <code>N</code>,
 then the given matrix shall have size <code>[N+1][M+1]</code>.
 The +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation.
 The <code>[M][j]</code> element of the matrix will be the <var>j</var>'th coordinate of the moved origin.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>matrix</code> - the matrix used to define the linear transform.</dd>
<dt>Returns:</dt>
<dd>the linear (usually affine) transform.</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="#getMatrix(org.opengis.referencing.operation.MathTransform)"><code>get­Matrix(Math­Transform)</code></a></li>
<li><a href="DefaultMathTransformFactory.html#createAffineTransform(org.opengis.referencing.operation.Matrix)"><code>Default­Math­Transform­Factory​.create­Affine­Transform(Matrix)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="linear(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)">
<h3>linear</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html#since()" title="class or interface in java.lang" class="external-link">since</a>="1.4",
            <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Deprecated.html#forRemoval()" title="class or interface in java.lang" class="external-link">forRemoval</a>=true)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">linear</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">DirectPosition</a>&nbsp;position)</span>
                              throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">TransformException</a></span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span>
<div class="deprecation-comment">This method duplicates <a href="#tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)"><code>tangent(Math­Transform, Direct­Position)</code></a>.</div>
</div>
<div class="block">Returns a linear (usually affine) transform which approximates the given transform in the vicinity of the given position.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform to approximate by an affine transform.</dd>
<dd><code>position</code> - position in source CRS around which to get the an affine transform approximation.</dd>
<dt>Returns:</dt>
<dd>a transform approximating the given transform around the given position.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Transform­Exception</a></code> - if an error occurred while transforming the given position
         or computing the derivative at that position.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)">
<h3>tangent</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform">LinearTransform</a></span>&nbsp;<span class="element-name">tangent</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;toApproximate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">DirectPosition</a>&nbsp;tangentPoint)</span>
                               throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">TransformException</a></span></div>
<div class="block">Returns a linear (usually affine) transform which approximates the given transform in the vicinity of the given position.
 If the given transform is already an instance of <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform"><code>Linear­Transform</code></a>, then it is returned as-is.
 Otherwise an approximation for the given position is created using the
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html#derivative(org.opengis.geometry.DirectPosition)" title="class or interface in org.opengis.referencing.operation" class="external-link">transform derivative</a> at that given position.
 The returned transform has the same number of source and target dimensions than the given transform.

 <p>If the given transform is a one-dimensional curve, then this method computes the tangent line at the given position.
 The same computation is generalized to any number of dimensions (tangent plane if the given transform is two-dimensional,
 <i>etc.</i>).</p>

 <h4 id="invariant-heading">Invariant</h4>
 Transforming the given <code>position</code> using the given <code>transform</code> produces the same result
 (ignoring rounding error) than transforming the same <code>position</code> using the returned transform.
 This invariant holds only for that particular position; the transformation of any other positions
 may produce different results.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>to­Approximate</code> - the potentially non-linear transform to approximate by a linear transform.</dd>
<dd><code>tangent­Point</code> - position in source CRS around which to get the an line approximation.</dd>
<dt>Returns:</dt>
<dd>a transform approximating the given transform around the given position.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Transform­Exception</a></code> - if an error occurred while transforming the given position
         or computing the derivative at that position.</dd>
<dt>Since:</dt>
<dd>1.1</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="#getMatrix(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)"><code>get­Matrix(Math­Transform, Direct­Position)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="convert(javax.measure.UnitConverter)">
<h3>convert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a></span>&nbsp;<span class="element-name">convert</span><wbr><span class="parameters">(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html" title="class or interface in javax.measure" class="external-link">UnitConverter</a>&nbsp;converter)</span></div>
<div class="block">Converts the given unit converter to a math transform.
 This is a bridge between Unit API and referencing API.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>converter</code> - the unit converter.</dd>
<dt>Returns:</dt>
<dd>a transform doing the same computation than the given unit converter.</dd>
<dt>Since:</dt>
<dd>1.4</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="interpolate(double[],double[])">
<h3>interpolate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a></span>&nbsp;<span class="element-name">interpolate</span><wbr><span class="parameters">(double[]&nbsp;preimage,
 double[]&nbsp;values)</span></div>
<div class="block">Creates a transform for the <i>y=f(x)</i> function where <var>y</var> are computed by a linear interpolation.
 Both <code>preimage</code> (the <var>x</var>) and <code>values</code> (the <var>y</var>) arguments can be null:

 <ul>
   <li>If both <code>preimage</code> and <code>values</code> arrays are non-null, then they must have the same length.</li>
   <li>If both <code>preimage</code> and <code>values</code> arrays are null, then this method returns the identity transform.</li>
   <li>If only <code>preimage</code> is null, then the <var>x</var> values are taken as {0, 1, 2, …, <code>values​.length</code> - 1}.</li>
   <li>If only <code>values</code> is null, then the <var>y</var> values are taken as {0, 1, 2, …, <code>preimage​.length</code> - 1}.</li>
 </ul>

 All <code>preimage</code> elements shall be real numbers (not NaN) sorted in increasing or decreasing order.
 Elements in the <code>values</code> array do not need to be ordered, but the returned transform will be invertible
 only if all values are real numbers sorted in increasing or decreasing order.
 Furthermore, the returned transform is affine (i.e. implement the <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform"><code>Linear­Transform</code></a> interface)
 if the interval between each <code>preimage</code> and <code>values</code> element is constant.

 <p>The current implementation uses linear interpolation. This may be changed in a future SIS version.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>preimage</code> - the input values (<var>x</var>) in the function domain, or <code>null</code>.</dd>
<dd><code>values</code> - the output values (<var>y</var>) in the function range, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>the <i>y=f(x)</i> function.</dd>
<dt>Since:</dt>
<dd>0.7</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="specialize(org.opengis.referencing.operation.MathTransform,java.util.Map)">
<h3>specialize</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">specialize</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;global,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/Envelope.html" title="class or interface in org.opengis.geometry" class="external-link">Envelope</a>,<wbr><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&gt;&nbsp;specializations)</span></div>
<div class="block">Creates a transform defined as one transform applied globally except in sub-areas where more accurate
 transforms are available. Such constructs appear in some datum shift files. The result of transforming
 a point by the returned <code>Math­Transform</code> is as if iterating over all given <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/Envelope.html" title="class or interface in org.opengis.geometry" class="external-link"><code>Envelope</code></a>s in
 no particular order, find the smallest one containing the point to transform (envelope border considered
 inclusive), then use the associated <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform</code></a> for transforming the point.
 If the point is not found in any envelope, then the global transform is applied.

 <p>The following constraints apply:</p>
 <ul>
   <li>The global transform must be a reasonable approximation of the specialized transforms
       (this is required for calculating the inverse transform).</li>
   <li>All transforms in the <code>specializations</code> map must have the same number of source and target
       dimensions than the <code>global</code> transform.</li>
   <li>All envelopes in the <code>specializations</code> map must have the same number of dimensions
       than the global transform <em>source</em> dimensions.</li>
   <li>In current implementation, each envelope must either be fully included in another envelope,
       or not overlap any other envelope.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>global</code> - the transform to use globally where there is no suitable specialization.</dd>
<dd><code>specializations</code> - more accurate transforms available in some sub-areas.</dd>
<dt>Returns:</dt>
<dd>a transform applying the given global transform except in sub-areas where specializations are available.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">Illegal­Argument­Exception</a></code> - if a constraint is not met.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="passThrough(int,org.opengis.referencing.operation.MathTransform,int)">
<h3>passThrough</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">passThrough</span><wbr><span class="parameters">(int&nbsp;firstAffectedCoordinate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;subTransform,
 int&nbsp;numTrailingCoordinates)</span></div>
<div class="block">Creates a transform which passes through a subset of coordinates to another transform.
 This method returns a transform having the following dimensions:

 
<div class="snippet-container"><button class="copy snippet-copy" aria-label="Copy snippet" onclick="copySnippet(this)"><span data-copied="Copied!">Copy</span><img src="../../../../../../../copy.svg" alt="Copy snippet"></button>
<pre class="snippet"><code class="language-java">int sourceDim = firstAffectedCoordinate + subTransform.getSourceDimensions() + numTrailingCoordinates;
int targetDim = firstAffectedCoordinate + subTransform.getTargetDimensions() + numTrailingCoordinates;
</code></pre>
</div>


 Affected coordinates will range from <code>first­Affected­Coordinate</code> inclusive to
 <code>dim­Target - num­Trailing­Coordinates</code> exclusive.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>first­Affected­Coordinate</code> - index of the first affected coordinate.</dd>
<dd><code>sub­Transform</code> - the sub-transform to apply on modified coordinates.</dd>
<dd><code>num­Trailing­Coordinates</code> - number of trailing coordinates to pass through.</dd>
<dt>Returns:</dt>
<dd>a pass-through transform, potentially as a <a href="PassThroughTransform.html" title="class in org.apache.sis.referencing.operation.transform"><code>Pass­Through­Transform</code></a> instance but not necessarily.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="passThrough(int[],org.opengis.referencing.operation.MathTransform,int)">
<h3>passThrough</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">passThrough</span><wbr><span class="parameters">(int[]&nbsp;modifiedCoordinates,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;subTransform,
 int&nbsp;resultDim)</span></div>
<div class="block">Creates a transform which passes through a subset of coordinates to another transform.
 The list of modified coordinates is specified by the <code>modified­Coordinates</code> argument.
 The array length must be equal to the number of source dimensions of <code>sub­Transform</code>
 and all array elements must be in strictly increasing order.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>modified­Coordinates</code> - positions in a source coordinate tuple of the coordinates affected by the transform.</dd>
<dd><code>sub­Transform</code> - the sub-transform to apply on modified coordinates.</dd>
<dd><code>result­Dim</code> - total number of source dimensions of the pass-through transform to return.</dd>
<dt>Returns:</dt>
<dd>a pass-through transform for the given set of modified coordinates.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the <code>modified­Coordinates</code> array length
         is not equal to the number of source dimensions in <code>sub­Transform</code>.</dd>
<dd><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link">Illegal­Argument­Exception</a></code> - if the index of a modified coordinates is invalid.</dd>
<dt>Since:</dt>
<dd>1.4</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="PassThroughTransform.html#create(java.util.BitSet,org.opengis.referencing.operation.MathTransform,int,org.opengis.referencing.operation.MathTransformFactory)"><code>Pass­Through­Transform​.create(Bit­Set, Math­Transform, int, Math­Transform­Factory)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="compound(org.opengis.referencing.operation.MathTransform...)">
<h3>compound</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">compound</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>...&nbsp;components)</span></div>
<div class="block">Puts together a list of independent math transforms, each of them operating on a subset of coordinate values.
 This method is often used for defining 4-dimensional (<var>x</var>,<var>y</var>,<var>z</var>,<var>t</var>)
 transform as an aggregation of 3 simpler transforms operating on (<var>x</var>,<var>y</var>), (<var>z</var>)
 and (<var>t</var>) values respectively.

 <p>Invariants:</p>
 <ul>
   <li>The <a href="AbstractMathTransform.html#getSourceDimensions()">source dimensions</a> of the returned transform
       is equal to the sum of the source dimensions of all given transforms.</li>
   <li>The <a href="AbstractMathTransform.html#getTargetDimensions()">target dimensions</a> of the returned transform
       is equal to the sum of the target dimensions of all given transforms.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>components</code> - the transforms to aggregate in a single transform, in the given order.</dd>
<dt>Returns:</dt>
<dd>the aggregation of all given transforms, or <code>null</code> if the given <code>components</code> array was empty.</dd>
<dt>Since:</dt>
<dd>0.6</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="PassThroughTransform.html" title="class in org.apache.sis.referencing.operation.transform"><code>Pass­Through­Transform</code></a></li>
<li><a href="../../CRS.html#compound(org.opengis.referencing.crs.CoordinateReferenceSystem...)"><code>CRS​.compound(Coordinate­Reference­System...)</code></a></li>
<li><a href="../../../geometry/Envelopes.html#compound(org.opengis.geometry.Envelope...)"><code>Envelopes​.compound(Envelope...)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;tr2)</span>
                                 throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the two given transforms. The returned transform will implement
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform1D</code></a> or <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> if the dimensions of the
 concatenated transform are equal to 1 or 2 respectively.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of the first transform
         does not match the input dimension of the second transform.</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="DefaultMathTransformFactory.html#createConcatenatedTransform(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)"><code>Default­Math­Transform­Factory​.create­Concatenated­Transform(Math­Transform, Math­Transform)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a>&nbsp;tr2)</span>
                                   throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the given one-dimensional transforms. This is a convenience methods
 delegating to <a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)"><code>concatenate(Math­Transform, Math­Transform)</code></a> and casting the
 result to a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform1D</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of the first transform
         does not match the input dimension of the second transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a>&nbsp;tr2)</span>
                                   throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the given two-dimensional transforms. This is a convenience methods
 delegating to <a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)"><code>concatenate(Math­Transform, Math­Transform)</code></a> and casting the
 result to a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of the first transform
         does not match the input dimension of the second transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;tr3)</span>
                                 throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the three given transforms. This is a convenience methods doing its job
 as two consecutive concatenations.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dd><code>tr3</code> - the third math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of a transform
         does not match the input dimension of next transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D,org.opengis.referencing.operation.MathTransform1D)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform1D</a>&nbsp;tr3)</span>
                                   throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the three given one-dimensional transforms. This is a convenience methods
 delegating to <a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)"><code>concatenate(Math­Transform, Math­Transform, Math­Transform)</code></a> and
 casting the result to a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform1D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform1D</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dd><code>tr3</code> - the third math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of a transform
         does not match the input dimension of next transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="concatenate(org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D,org.opengis.referencing.operation.MathTransform2D)">
<h3>concatenate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a></span>&nbsp;<span class="element-name">concatenate</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a>&nbsp;tr1,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a>&nbsp;tr2,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a>&nbsp;tr3)</span>
                                   throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">MismatchedDimensionException</a></span></div>
<div class="block">Concatenates the three given two-dimensional transforms. This is a convenience methods
 delegating to <a href="#concatenate(org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform,org.opengis.referencing.operation.MathTransform)"><code>concatenate(Math­Transform, Math­Transform, Math­Transform)</code></a> and
 casting the result to a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> instance.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tr1</code> - the first math transform.</dd>
<dd><code>tr2</code> - the second math transform.</dd>
<dd><code>tr3</code> - the third math transform.</dd>
<dt>Returns:</dt>
<dd>the concatenated transform.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the output dimension of a transform
         does not match the input dimension of next transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="bidimensional(org.opengis.referencing.operation.MathTransform)">
<h3>bidimensional</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform2D</a></span>&nbsp;<span class="element-name">bidimensional</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform)</span></div>
<div class="block">Returns the given transform as a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> instance.
 If the given transform is <code>null</code> or already implements the <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> interface,
 then it is returned as-is. Otherwise the given transform is wrapped in an adapter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform to have as <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a> instance, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>the given transform as a <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform2D.html" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform2D</code></a>, or <code>null</code> if the argument was null.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/MismatchedDimensionException.html" title="class or interface in org.opengis.geometry" class="external-link">Mismatched­Dimension­Exception</a></code> - if the number of source and target dimensions is not 2.</dd>
<dt>Since:</dt>
<dd>1.1</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSteps(org.opengis.referencing.operation.MathTransform)">
<h3>getSteps</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&gt;</span>&nbsp;<span class="element-name">getSteps</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform)</span></div>
<div class="block">Returns all single components of the given (potentially concatenated) transform.
 This method makes the following choice:

 <ul>
   <li>If <code>transform</code> is <code>null</code>, returns an empty list.</li>
   <li>Otherwise if <code>transform</code> is the result of calls to <code>concatenate(…)</code> methods, returns
       all steps making the transformation chain. Nested concatenated transforms (if any) are flattened.
       Note that some steps may have have been merged together, resulting in a shorter list.</li>
   <li>Otherwise returns the given transform in a list of size 1.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform for which to get the components, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>all single math transforms performed by this concatenated transform.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMatrix(org.opengis.referencing.operation.MathTransform)">
<h3>getMatrix</h3>
<div class="member-signature"><span class="annotations"><a href="../../../../../../../org.apache.sis.util/org/apache/sis/util/OptionalCandidate.html" title="annotation interface in org.apache.sis.util">@OptionalCandidate</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></span>&nbsp;<span class="element-name">getMatrix</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform)</span></div>
<div class="block">If the given transform is linear, returns its coefficients as a matrix.
 More specifically:

 <ul>
   <li>If the given transform is an instance of <a href="LinearTransform.html" title="interface in org.apache.sis.referencing.operation.transform"><code>Linear­Transform</code></a>,
       returns <a href="LinearTransform.html#getMatrix()"><code>Linear­Transform​.get­Matrix()</code></a>.</li>
   <li>Otherwise if the given transform is an instance of <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/geom/AffineTransform.html" title="class or interface in java.awt.geom" class="external-link"><code>Affine­Transform</code></a>,
       returns its coefficients in a <a href="../matrix/Matrix3.html" title="class in org.apache.sis.referencing.operation.matrix"><code>Matrix3</code></a> instance.</li>
   <li>Otherwise returns <code>null</code>.</li>
 </ul></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform for which to get the matrix, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>the matrix of the given transform, or <code>null</code> if none.</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list">
<li><a href="#linear(org.opengis.referencing.operation.Matrix)"><code>linear(Matrix)</code></a></li>
<li><a href="LinearTransform.html#getMatrix()"><code>Linear­Transform​.get­Matrix()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMatrix(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)">
<h3>getMatrix</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></span>&nbsp;<span class="element-name">getMatrix</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;toApproximate,
 <a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/DirectPosition.html" title="class or interface in org.opengis.geometry" class="external-link">DirectPosition</a>&nbsp;tangentPoint)</span>
                        throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">TransformException</a></span></div>
<div class="block">Returns the coefficients of an affine transform in the vicinity of the given position.
 If the given transform is linear, then this method produces a result identical to <a href="#getMatrix(org.opengis.referencing.operation.MathTransform)"><code>get­Matrix(Math­Transform)</code></a>.
 Otherwise the returned matrix can be used for <a href="#linear(org.opengis.referencing.operation.Matrix)">building a linear transform</a> which can be
 used as an approximation of the given transform for short distances around the given position.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>to­Approximate</code> - the potentially non-linear transform to approximate by an affine transform.</dd>
<dd><code>tangent­Point</code> - position in source CRS around which to get the coefficients of an affine transform approximation.</dd>
<dt>Returns:</dt>
<dd>the matrix representation of the affine approximation of the given transform around the given position.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Transform­Exception</a></code> - if an error occurred while transforming the given position
         or computing the derivative at that position.</dd>
<dt>Since:</dt>
<dd>1.0</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="#tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)"><code>tangent(Math­Transform, Direct­Position)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDomain(org.opengis.referencing.operation.MathTransform)">
<h3>getDomain</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Optional.html" title="class or interface in java.util" class="external-link">Optional</a>&lt;<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/geometry/Envelope.html" title="class or interface in org.opengis.geometry" class="external-link">Envelope</a>&gt;</span>&nbsp;<span class="element-name">getDomain</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;evaluated)</span>
                                    throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">TransformException</a></span></div>
<div class="block">Returns source coordinate values where the transform is mathematically and numerically applicable.
 This is <em>not</em> the domain of validity for which a coordinate reference system has been defined,
 because this method ignores "real world" considerations such as datum and country boundaries.
 This method is for allowing callers to crop their data for removing areas that may cause numerical problems,
 for example latitudes too close to a pole before Mercator projection.

 <p>See <a href="AbstractMathTransform.html#getDomain(org.apache.sis.referencing.operation.transform.DomainDefinition)"><code>Abstract­Math­Transform​.get­Domain(Domain­Definition)</code></a> for more information.
 This static method delegates to above-cited method if possible, or returns an empty value otherwise.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>evaluated</code> - transform for which to evaluate a domain, or <code>null</code>.</dd>
<dt>Returns:</dt>
<dd>estimation of a domain where this transform is considered numerically applicable.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Transform­Exception</a></code> - if the domain cannot be estimated.</dd>
<dt>Since:</dt>
<dd>1.3</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="AbstractMathTransform.html#getDomain(org.apache.sis.referencing.operation.transform.DomainDefinition)"><code>Abstract­Math­Transform​.get­Domain(Domain­Definition)</code></a></li>
<li><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/CoordinateOperation.html#getDomainOfValidity()" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Coordinate­Operation​.get­Domain­Of­Validity()</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="derivativeAndTransform(org.opengis.referencing.operation.MathTransform,double[],int,double[],int)">
<h3>derivativeAndTransform</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/Matrix.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Matrix</a></span>&nbsp;<span class="element-name">derivativeAndTransform</span><wbr><span class="parameters">(<a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html" title="class or interface in org.opengis.referencing.operation" class="external-link">MathTransform</a>&nbsp;transform,
 double[]&nbsp;srcPts,
 int&nbsp;srcOff,
 double[]&nbsp;dstPts,
 int&nbsp;dstOff)</span>
                                     throws <span class="exceptions"><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">TransformException</a></span></div>
<div class="block">A buckle method for calculating derivative and coordinate transformation in a single step.
 The transform result is stored in the given destination array, and the derivative matrix
 is returned. Invoking this method is equivalent to the following code, except that it may
 execute faster with some <code>Math­Transform</code> implementations:

 
<div class="snippet-container"><button class="copy snippet-copy" aria-label="Copy snippet" onclick="copySnippet(this)"><span data-copied="Copied!">Copy</span><img src="../../../../../../../copy.svg" alt="Copy snippet"></button>
<pre class="snippet"><code class="language-java">DirectPosition ptSrc = ...;
DirectPosition ptDst = ...;
Matrix matrixDst = derivative(ptSrc);
ptDst = transform(ptSrc, ptDst);
</code></pre>
</div>
</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>transform</code> - the transform to use.</dd>
<dd><code>src­Pts</code> - the array containing the source coordinate.</dd>
<dd><code>src­Off</code> - the offset to the point to be transformed in the source array.</dd>
<dd><code>dst­Pts</code> - the array into which the transformed coordinate is returned.</dd>
<dd><code>dst­Off</code> - the offset to the location of the transformed point that is stored in the destination array.</dd>
<dt>Returns:</dt>
<dd>the matrix of the transform derivative at the given source position.</dd>
<dt>Throws:</dt>
<dd><code><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/TransformException.html" title="class or interface in org.opengis.referencing.operation" class="external-link">Transform­Exception</a></code> - if the point cannot be transformed
         or if a problem occurred while calculating the derivative.</dd>
<dt>See Also:</dt>
<dd>
<ul class="tag-list-long">
<li><a href="#tangent(org.opengis.referencing.operation.MathTransform,org.opengis.geometry.DirectPosition)"><code>tangent(Math­Transform, Direct­Position)</code></a></li>
<li><a href="http://www.geoapi.org/3.0/javadoc/org.opengis.geoapi/org/opengis/referencing/operation/MathTransform.html#derivative(org.opengis.geometry.DirectPosition)" title="class or interface in org.opengis.referencing.operation" class="external-link"><code>Math­Transform​.derivative(Direct­Position)</code></a></li>
<li><a href="../matrix/Matrices.html#createAffine(org.opengis.referencing.operation.Matrix,org.opengis.geometry.DirectPosition)"><code>Matrices​.create­Affine(Matrix, Direct­Position)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
</div>
</div>
</body>
</html>
