<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>SpatialTypeFunctions (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.runtime, class: SpatialTypeFunctions">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.5.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 evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
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">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="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>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&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"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.runtime</a></div>
<h1 title="Class SpatialTypeFunctions" class="title">Class SpatialTypeFunctions</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.runtime.SpatialTypeFunctions</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">SpatialTypeFunctions</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Helper methods to implement spatial type (ST) functions in generated code.

 <p>Remaining tasks:

 <ul>
   <li>Determine type code for
   <a href="../sql/type/ExtraSqlTypes.html#GEOMETRY"><code>ExtraSqlTypes.GEOMETRY</code></a>
   <li>Should we create aliases for functions in upper-case?
   Without ST_ prefix?
   <li>Consider adding spatial literals, e.g. `GEOMETRY 'POINT (30 10)'`
   <li>Integer arguments, e.g. SELECT ST_MakePoint(1, 2, 1.5),
     ST_MakePoint(1, 2)
   <li>Are GEOMETRY values comparable? If so add ORDER BY test
   <li>We have to add 'Z' to create 3D objects. This is inconsistent with
   PostGIS. Who is right? At least document the difference.
   <li>Should add GeometryEngine.intersects; similar to disjoint etc.
   <li>Make <a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)"><code>ST_MakeLine(Geometry, Geometry)</code></a> varargs</li>
 </ul></div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SpatialTypeFunctions.Accum.html" class="type-name-link" title="class in org.apache.calcite.runtime">SpatialTypeFunctions.Accum</a></code></div>
<div class="col-last even-row-color">
<div class="block">Used at run time by the ST_Accum function.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SpatialTypeFunctions.Collect.html" class="type-name-link" title="class in org.apache.calcite.runtime">SpatialTypeFunctions.Collect</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Used at run time by the ST_Collect function.</div>
</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="SpatialTypeFunctions.GridEnumerable.html" class="type-name-link" title="class in org.apache.calcite.runtime">SpatialTypeFunctions.GridEnumerable</a></code></div>
<div class="col-last even-row-color">
<div class="block">Used at run time by the <code>ST_MakeGrid(org.locationtech.jts.geom.Geometry, java.math.BigDecimal, java.math.BigDecimal)</code> and <code>ST_MakeGridPoints(org.locationtech.jts.geom.Geometry, java.math.BigDecimal, java.math.BigDecimal)</code> functions.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="SpatialTypeFunctions.Union.html" class="type-name-link" title="class in org.apache.calcite.runtime">SpatialTypeFunctions.Union</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Used at run time by the ST_Union function.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#hilbert(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">hilbert</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</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 position of a point on the Hilbert curve.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#hilbert(org.locationtech.jts.geom.Geometry)" class="member-name-link">hilbert</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the position of a point on the Hilbert curve, or null if it is not a 2-dimensional
 point.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Area(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Area</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 area of the <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsBinary(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsBinary</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsEWKB(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsEWKB</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsEWKT(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsEWKT</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsGeoJSON(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsGeoJSON</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsGML(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsGML</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsText(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsText</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.apache.calcite.avatica.util.ByteString</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsWKB(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsWKB</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_AsWKT(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_AsWKT</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Boundary(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Boundary</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the boundary of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_BoundingCircle(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_BoundingCircle</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 minimum bounding circle of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Buffer(org.locationtech.jts.geom.Geometry,double)" class="member-name-link">ST_Buffer</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes a buffer around <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Buffer(org.locationtech.jts.geom.Geometry,double,int)" class="member-name-link">ST_Buffer</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance,
 int&nbsp;quadSegs)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes a buffer around <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Buffer(org.locationtech.jts.geom.Geometry,double,int,int)" class="member-name-link">ST_Buffer</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance,
 int&nbsp;quadSegs,
 int&nbsp;endCapStyle)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes a buffer around <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Centroid(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Centroid</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 centroid of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ClosestCoordinate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ClosestCoordinate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the coordinate(s) of <code>geom</code> closest to <code>point</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ClosestPoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ClosestPoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</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 point of <code>geom1</code> closest to <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Contains(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Contains</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> contains <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ContainsProperly(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ContainsProperly</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> contains <code>geom2</code> but does not intersect its boundary.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ConvexHull(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ConvexHull</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the smallest convex POLYGON that contains all the points of geom.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_CoordDim(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_CoordDim</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 dimension of the coordinates of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_CoveredBy(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_CoveredBy</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether no point in <code>geom1</code> is outside <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Covers(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Covers</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether no point in <code>geom2</code> is outside <code>geom1</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Crosses(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Crosses</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> crosses <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Difference(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Difference</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the difference between geom1 and geom2.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Dimension(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Dimension</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the dimension of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Disjoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Disjoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> and <code>geom2</code> are disjoint.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Distance(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Distance</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the distance between <code>geom1</code> and <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_DWithin(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,double)" class="member-name-link">ST_DWithin</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 double&nbsp;distance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> and <code>geom2</code> are within <code>distance</code> of each other.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_EndPoint(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_EndPoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the first point of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Envelope(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Envelope</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 minimum bounding box of <code>geom</code> (which may be a GEOMETRYCOLLECTION).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_EnvelopesIntersect(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_EnvelopesIntersect</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether the envelope of <code>geom1</code> intersects the envelope of <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Equals(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Equals</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> equals <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Expand(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_Expand</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Expands <code>geom</code>'s envelope.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Expand(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Expand</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;deltaX,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;deltaY)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Expands <code>geom</code>'s envelope.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Extent(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Extent</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the minimum bounding box that encloses geom as a Geometry.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ExteriorRing(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ExteriorRing</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 exterior ring of <code>geom</code>, or null if <code>geom</code> is not a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Force2D(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Force2D</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Force3D(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Force3D</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_FurthestCoordinate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_FurthestCoordinate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the coordinate(s) of <code>geom</code> furthest from <code>point</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeometryN(org.locationtech.jts.geom.Geometry,int)" class="member-name-link">ST_GeometryN</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</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 nth geometry of a geometry collection.</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/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeometryType(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_GeometryType</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the type of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeometryTypeCode(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_GeometryTypeCode</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 OGC SFS type code of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromEWKB(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ST_GeomFromEWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;ewkb)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromEWKT(java.lang.String)" class="member-name-link">ST_GeomFromEWKT</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ewkt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromGeoJSON(java.lang.String)" class="member-name-link">ST_GeomFromGeoJSON</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;geojson)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromGML(java.lang.String)" class="member-name-link">ST_GeomFromGML</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;gml)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromGML(java.lang.String,int)" class="member-name-link">ST_GeomFromGML</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;gml,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromText(java.lang.String)" class="member-name-link">ST_GeomFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromText(java.lang.String,int)" class="member-name-link">ST_GeomFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromWKB(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ST_GeomFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromWKB(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">ST_GeomFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromWKT(java.lang.String)" class="member-name-link">ST_GeomFromWKT</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_GeomFromWKT(java.lang.String,int)" class="member-name-link">ST_GeomFromWKT</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_InteriorRing(org.locationtech.jts.geom.Geometry,int)" class="member-name-link">ST_InteriorRing</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</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 nth interior ring of <code>geom</code>, or null if <code>geom</code> is not a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Intersection(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Intersection</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the intersection between geom1 and geom2.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Intersects(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Intersects</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> intersects <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Is3D(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Is3D</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom</code> has at least one z-coordinate.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsClosed(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsClosed</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom</code> is a closed LINESTRING or MULTILINESTRING.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsEmpty(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsEmpty</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true if geom is empty.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsRectangle(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsRectangle</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true if geom is rectangle.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsRing(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsRing</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom</code> is a closed and simple linestring or multi-linestring.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsSimple(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsSimple</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true if geom is simple.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_IsValid(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_IsValid</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true if geom is valid.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Length(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Length</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 length of the <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LineFromText(java.lang.String)" class="member-name-link">ST_LineFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LineFromText(java.lang.String,int)" class="member-name-link">ST_LineFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LineFromWKB(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ST_LineFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LineFromWKB(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">ST_LineFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LineMerge(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_LineMerge</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Merges a collection of linear components to form a line-string of maximal length.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LocateAlong(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_LocateAlong</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;segmentLengthFraction,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;offsetDistance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a MULTIPOINT containing points along the line segments of <code>geom</code>
 at <code>segmentLengthFraction</code> and <code>offsetDistance</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_LongestLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_LongestLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the 2-dimensional longest line-string between the points
 of <code>geom1</code> and <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeEllipse(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_MakeEllipse</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;point,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;width,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;height)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes an ellipse.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeEnvelope(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_MakeEnvelope</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMax,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMax)</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 rectangular Polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeEnvelope(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,int)" class="member-name-link">ST_MakeEnvelope</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMax,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMax,
 int&nbsp;srid)</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 rectangular Polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</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 line-string from the given POINTs (or MULTIPOINTs).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4,
 org.locationtech.jts.geom.Geometry&nbsp;geom5)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4,
 org.locationtech.jts.geom.Geometry&nbsp;geom5,
 org.locationtech.jts.geom.Geometry&nbsp;geom6)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePoint(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_MakePoint</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Alias for <a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal)"><code>ST_Point(BigDecimal, BigDecimal)</code></a>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePoint(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_MakePoint</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;z)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Alias for <a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)"><code>ST_Point(BigDecimal, BigDecimal, BigDecimal)</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7,
 org.locationtech.jts.geom.Geometry&nbsp;hole8)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakePolygon</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7,
 org.locationtech.jts.geom.Geometry&nbsp;hole8,
 org.locationtech.jts.geom.Geometry&nbsp;hole9)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a polygon.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MakeValid(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MakeValid</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a valid geometry of a given invalid geometry.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MaxDistance(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MaxDistance</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the maximum distance between <code>geom1</code> and <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MinimumDiameter(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MinimumDiameter</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the minimum diameter of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MinimumRectangle(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_MinimumRectangle</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 minimum rectangle enclosing <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MLineFromText(java.lang.String)" class="member-name-link">ST_MLineFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MLineFromText(java.lang.String,int)" class="member-name-link">ST_MLineFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MPointFromText(java.lang.String)" class="member-name-link">ST_MPointFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MPointFromText(java.lang.String,int)" class="member-name-link">ST_MPointFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MPolyFromText(java.lang.String)" class="member-name-link">ST_MPolyFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_MPolyFromText(java.lang.String,int)" class="member-name-link">ST_MPolyFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_NPoints(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_NPoints</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the number of points in <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_NumGeometries(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_NumGeometries</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 number of geometries in <code>geom</code> (1 if it is not a GEOMETRYCOLLECTION).</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_NumInteriorRing(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_NumInteriorRing</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the number of interior rings of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_NumInteriorRings(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_NumInteriorRings</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 number of interior rings of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_NumPoints(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_NumPoints</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the number of points in <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_OctagonalEnvelope(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_OctagonalEnvelope</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 octagonal envelope of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_OrderingEquals(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_OrderingEquals</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> equals <code>geom2</code> and their coordinates and component
 Geometries are listed in the same order.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Overlaps(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Overlaps</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns <code>geom1</code> overlaps <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Perimeter(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Perimeter</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the length of the perimeter of *polygon* (which may be a MULTIPOLYGON).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Point</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Constructs a 2D point from coordinates.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Point</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;z)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Constructs a 3D point from coordinates.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointFromText(java.lang.String)" class="member-name-link">ST_PointFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointFromText(java.lang.String,int)" class="member-name-link">ST_PointFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointFromWKB(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ST_PointFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointFromWKB(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">ST_PointFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointN(org.locationtech.jts.geom.Geometry,int)" class="member-name-link">ST_PointN</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</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 nth point of a <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PointOnSurface(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_PointOnSurface</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an interior or boundary point of <code>geom</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PolyFromText(java.lang.String)" class="member-name-link">ST_PolyFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PolyFromText(java.lang.String,int)" class="member-name-link">ST_PolyFromText</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PolyFromWKB(org.apache.calcite.avatica.util.ByteString)" class="member-name-link">ST_PolyFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PolyFromWKB(org.apache.calcite.avatica.util.ByteString,int)" class="member-name-link">ST_PolyFromWKB</a><wbr>(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Polygonize(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Polygonize</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry)</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 multipolygon from the geometry.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_PrecisionReducer(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_PrecisionReducer</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geometry,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;decimal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Reduces the geometry's precision to n decimal places.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ProjectPoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ProjectPoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;lineString)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Projects <code>point</code> onto a <code>lineString</code> (which may be a MULTILINESTRING).</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/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Relate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Relate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the DE-9IM intersection matrix for geom1 and geom2.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Relate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,java.lang.String)" class="member-name-link">ST_Relate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iMatrix)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true if geom1 and geom2 are related by the intersection matrix specified by iMatrix.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_Rotate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Rotate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Rotate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle,
 org.locationtech.jts.geom.Geometry&nbsp;origin)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Scale(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Scale</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xFactor,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yFactor)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Scales geom Geometry by multiplying the ordinates by the indicated scale factors.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_SetSRID(org.locationtech.jts.geom.Geometry,int)" class="member-name-link">ST_SetSRID</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;srid)</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 copy of <code>geom</code> with a new SRID.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Simplify(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_Simplify</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Simplifies geom a geometry using the Douglas-Peuker algorithm.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_SimplifyPreserveTopology(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_SimplifyPreserveTopology</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Simplifies a geometry and preserves its topology.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Snap(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,java.math.BigDecimal)" class="member-name-link">ST_Snap</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;snapTolerance)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Snaps geom1 and geom2 together with the given snapTolerance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_SRID(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_SRID</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns SRID value or 0 if input Geometry does not have one.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_StartPoint(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_StartPoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 first point of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_SymDifference(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_SymDifference</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the symmetric difference between geom1 and geom2.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ToMultiLine(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ToMultiLine</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 a <code>geom</code> into a MULTILINESTRING.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ToMultiPoint(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ToMultiPoint</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts the coordinates of a <code>geom</code> into a MULTIPOINT.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ToMultiSegments(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ToMultiSegments</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a <code>geom</code> into a set of distinct segments stored in a MULTILINESTRING.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Touches(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Touches</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> touches <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Transform(org.locationtech.jts.geom.Geometry,int)" class="member-name-link">ST_Transform</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;srid)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Transforms <code>geom</code> from one coordinate reference system (CRS) to the CRS specified by
 <code>srid</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Translate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)" class="member-name-link">ST_Translate</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Translates geom by the vector (x, y).</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_UnaryUnion(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_UnaryUnion</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geomCollection)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the union of the geometries in <code>geomCollection</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static org.locationtech.jts.geom.Geometry</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_UnaryUnion(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_UnaryUnion</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes the union of <code>geom1</code> and <code>geom2</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Within(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Within</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether <code>geom1</code> is within <code>geom2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_X(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_X</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Return the X coordinate of the point, or NULL if not available.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_XMax(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_XMax</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 X maxima of a 2D or 3D bounding box or a geometry.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_XMin(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_XMin</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the X minima of a 2D or 3D bounding box or a geometry.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Y(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Y</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 y-value of the first coordinate of <code>geom</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_YMax(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_YMax</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the Y maxima of a 2D or 3D bounding box or a geometry.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static @Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_YMin(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_YMin</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 Y minima of a 2D or 3D bounding box or a geometry.</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_Z(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_Z</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the z-value of the first coordinate of <code>geom</code>.</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ZMax(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ZMax</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</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 maximum z-value of <code>geom</code>.</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#ST_ZMin(org.locationtech.jts.geom.Geometry)" class="member-name-link">ST_ZMin</a><wbr>(org.locationtech.jts.geom.Geometry&nbsp;geom)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the minimum z-value of <code>geom</code>.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/17/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/17/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/17/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/17/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/17/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/17/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/17/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/17/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/17/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/17/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="ST_AsBinary(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsBinary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">ST_AsBinary</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsEWKT(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsEWKT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_AsEWKT</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsGeoJSON(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsGeoJSON</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_AsGeoJSON</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsGML(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsGML</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_AsGML</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsText(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_AsText</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsEWKB(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsEWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">ST_AsEWKB</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsWKB(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.apache.calcite.avatica.util.ByteString</span>&nbsp;<span class="element-name">ST_AsWKB</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_AsWKT(org.locationtech.jts.geom.Geometry)">
<h3>ST_AsWKT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_AsWKT</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_Force2D(org.locationtech.jts.geom.Geometry)">
<h3>ST_Force2D</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Force2D</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromEWKB(org.apache.calcite.avatica.util.ByteString)">
<h3>ST_GeomFromEWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromEWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;ewkb)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromEWKT(java.lang.String)">
<h3>ST_GeomFromEWKT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromEWKT</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;ewkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromGeoJSON(java.lang.String)">
<h3>ST_GeomFromGeoJSON</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromGeoJSON</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;geojson)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromGML(java.lang.String)">
<h3>ST_GeomFromGML</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromGML</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;gml)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromGML(java.lang.String,int)">
<h3>ST_GeomFromGML</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromGML</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;gml,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromText(java.lang.String)">
<h3>ST_GeomFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromText(java.lang.String,int)">
<h3>ST_GeomFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromWKB(org.apache.calcite.avatica.util.ByteString)">
<h3>ST_GeomFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromWKB(org.apache.calcite.avatica.util.ByteString,int)">
<h3>ST_GeomFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromWKT(java.lang.String)">
<h3>ST_GeomFromWKT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromWKT</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_GeomFromWKT(java.lang.String,int)">
<h3>ST_GeomFromWKT</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeomFromWKT</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_LineFromText(java.lang.String)">
<h3>ST_LineFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LineFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_LineFromText(java.lang.String,int)">
<h3>ST_LineFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LineFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_LineFromWKB(org.apache.calcite.avatica.util.ByteString)">
<h3>ST_LineFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LineFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_LineFromWKB(org.apache.calcite.avatica.util.ByteString,int)">
<h3>ST_LineFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LineFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MLineFromText(java.lang.String)">
<h3>ST_MLineFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MLineFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MLineFromText(java.lang.String,int)">
<h3>ST_MLineFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MLineFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MPointFromText(java.lang.String)">
<h3>ST_MPointFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MPointFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MPointFromText(java.lang.String,int)">
<h3>ST_MPointFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MPointFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MPolyFromText(java.lang.String)">
<h3>ST_MPolyFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MPolyFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MPolyFromText(java.lang.String,int)">
<h3>ST_MPolyFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MPolyFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PointFromText(java.lang.String)">
<h3>ST_PointFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PointFromText(java.lang.String,int)">
<h3>ST_PointFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PointFromWKB(org.apache.calcite.avatica.util.ByteString)">
<h3>ST_PointFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PointFromWKB(org.apache.calcite.avatica.util.ByteString,int)">
<h3>ST_PointFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PolyFromText(java.lang.String)">
<h3>ST_PolyFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PolyFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PolyFromText(java.lang.String,int)">
<h3>ST_PolyFromText</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PolyFromText</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;wkt,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PolyFromWKB(org.apache.calcite.avatica.util.ByteString)">
<h3>ST_PolyFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PolyFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_PolyFromWKB(org.apache.calcite.avatica.util.ByteString,int)">
<h3>ST_PolyFromWKB</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PolyFromWKB</span><wbr><span class="parameters">(org.apache.calcite.avatica.util.ByteString&nbsp;wkb,
 int&nbsp;srid)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_ToMultiPoint(org.locationtech.jts.geom.Geometry)">
<h3>ST_ToMultiPoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ToMultiPoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Converts the coordinates of a <code>geom</code> into a MULTIPOINT.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ToMultiLine(org.locationtech.jts.geom.Geometry)">
<h3>ST_ToMultiLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ToMultiLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Converts the a <code>geom</code> into a MULTILINESTRING.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ToMultiSegments(org.locationtech.jts.geom.Geometry)">
<h3>ST_ToMultiSegments</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ToMultiSegments</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Converts a <code>geom</code> into a set of distinct segments stored in a MULTILINESTRING.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Force3D(org.locationtech.jts.geom.Geometry)">
<h3>ST_Force3D</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Force3D</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_BoundingCircle(org.locationtech.jts.geom.Geometry)">
<h3>ST_BoundingCircle</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_BoundingCircle</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum bounding circle of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Expand(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_Expand</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Expand</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</span></div>
<div class="block">Expands <code>geom</code>'s envelope.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeEllipse(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_MakeEllipse</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeEllipse</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;point,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;width,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;height)</span></div>
<div class="block">Makes an ellipse.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7,
 org.locationtech.jts.geom.Geometry&nbsp;hole8)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePolygon(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakePolygon</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePolygon</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;shell,
 org.locationtech.jts.geom.Geometry&nbsp;hole0,
 org.locationtech.jts.geom.Geometry&nbsp;hole1,
 org.locationtech.jts.geom.Geometry&nbsp;hole2,
 org.locationtech.jts.geom.Geometry&nbsp;hole3,
 org.locationtech.jts.geom.Geometry&nbsp;hole4,
 org.locationtech.jts.geom.Geometry&nbsp;hole5,
 org.locationtech.jts.geom.Geometry&nbsp;hole6,
 org.locationtech.jts.geom.Geometry&nbsp;hole7,
 org.locationtech.jts.geom.Geometry&nbsp;hole8,
 org.locationtech.jts.geom.Geometry&nbsp;hole9)</span></div>
<div class="block">Makes a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MinimumDiameter(org.locationtech.jts.geom.Geometry)">
<h3>ST_MinimumDiameter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MinimumDiameter</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum diameter of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MinimumRectangle(org.locationtech.jts.geom.Geometry)">
<h3>ST_MinimumRectangle</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MinimumRectangle</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum rectangle enclosing <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_OctagonalEnvelope(org.locationtech.jts.geom.Geometry)">
<h3>ST_OctagonalEnvelope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_OctagonalEnvelope</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the octagonal envelope of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Expand(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Expand</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Expand</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;deltaX,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;deltaY)</span></div>
<div class="block">Expands <code>geom</code>'s envelope.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeEnvelope(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,int)">
<h3>ST_MakeEnvelope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeEnvelope</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMax,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMax,
 int&nbsp;srid)</span></div>
<div class="block">Creates a rectangular Polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeEnvelope(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_MakeEnvelope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeEnvelope</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMin,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xMax,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yMax)</span></div>
<div class="block">Creates a rectangular Polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Creates a line-string from the given POINTs (or MULTIPOINTs).</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4,
 org.locationtech.jts.geom.Geometry&nbsp;geom5)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 org.locationtech.jts.geom.Geometry&nbsp;geom3,
 org.locationtech.jts.geom.Geometry&nbsp;geom4,
 org.locationtech.jts.geom.Geometry&nbsp;geom5,
 org.locationtech.jts.geom.Geometry&nbsp;geom6)</span></div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePoint(java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_MakePoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePoint</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</span></div>
<div class="block">Alias for <a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal)"><code>ST_Point(BigDecimal, BigDecimal)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakePoint(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_MakePoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakePoint</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;z)</span></div>
<div class="block">Alias for <a href="#ST_Point(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)"><code>ST_Point(BigDecimal, BigDecimal, BigDecimal)</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Point(java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Point</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Point</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</span></div>
<div class="block">Constructs a 2D point from coordinates.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Point(java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Point</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Point</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;z)</span></div>
<div class="block">Constructs a 3D point from coordinates.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Extent(org.locationtech.jts.geom.Geometry)">
<h3>ST_Extent</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Extent</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum bounding box that encloses geom as a Geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_GeometryN(org.locationtech.jts.geom.Geometry,int)">
<h3>ST_GeometryN</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_GeometryN</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</span></div>
<div class="block">Returns the nth geometry of a geometry collection.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ExteriorRing(org.locationtech.jts.geom.Geometry)">
<h3>ST_ExteriorRing</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ExteriorRing</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the exterior ring of <code>geom</code>, or null if <code>geom</code> is not a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_EndPoint(org.locationtech.jts.geom.Geometry)">
<h3>ST_EndPoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_EndPoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the first point of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_InteriorRing(org.locationtech.jts.geom.Geometry,int)">
<h3>ST_InteriorRing</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_InteriorRing</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</span></div>
<div class="block">Returns the nth interior ring of <code>geom</code>, or null if <code>geom</code> is not a polygon.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsClosed(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsClosed</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsClosed</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns whether <code>geom</code> is a closed LINESTRING or MULTILINESTRING.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Is3D(org.locationtech.jts.geom.Geometry)">
<h3>ST_Is3D</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Is3D</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns whether <code>geom</code> has at least one z-coordinate.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsEmpty(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsEmpty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsEmpty</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns true if geom is empty.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsRectangle(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsRectangle</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsRectangle</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns true if geom is rectangle.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsRing(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsRing</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsRing</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns whether <code>geom</code> is a closed and simple linestring or multi-linestring.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsSimple(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsSimple</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsSimple</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns true if geom is simple.</div>
</section>
</li>
<li>
<section class="detail" id="ST_IsValid(org.locationtech.jts.geom.Geometry)">
<h3>ST_IsValid</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_IsValid</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns true if geom is valid.</div>
</section>
</li>
<li>
<section class="detail" id="ST_NPoints(org.locationtech.jts.geom.Geometry)">
<h3>ST_NPoints</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_NPoints</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the number of points in <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_NumGeometries(org.locationtech.jts.geom.Geometry)">
<h3>ST_NumGeometries</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_NumGeometries</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the number of geometries in <code>geom</code> (1 if it is not a GEOMETRYCOLLECTION).</div>
</section>
</li>
<li>
<section class="detail" id="ST_NumInteriorRing(org.locationtech.jts.geom.Geometry)">
<h3>ST_NumInteriorRing</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_NumInteriorRing</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the number of interior rings of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_NumInteriorRings(org.locationtech.jts.geom.Geometry)">
<h3>ST_NumInteriorRings</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_NumInteriorRings</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the number of interior rings of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_NumPoints(org.locationtech.jts.geom.Geometry)">
<h3>ST_NumPoints</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_NumPoints</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the number of points in <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_PointN(org.locationtech.jts.geom.Geometry,int)">
<h3>ST_PointN</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointN</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;n)</span></div>
<div class="block">Returns the nth point of a <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_PointOnSurface(org.locationtech.jts.geom.Geometry)">
<h3>ST_PointOnSurface</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PointOnSurface</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns an interior or boundary point of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_SRID(org.locationtech.jts.geom.Geometry)">
<h3>ST_SRID</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_SRID</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns SRID value or 0 if input Geometry does not have one.</div>
</section>
</li>
<li>
<section class="detail" id="ST_StartPoint(org.locationtech.jts.geom.Geometry)">
<h3>ST_StartPoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_StartPoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the first point of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_X(org.locationtech.jts.geom.Geometry)">
<h3>ST_X</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_X</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Return the X coordinate of the point, or NULL if not available. Input must be a point..</div>
</section>
</li>
<li>
<section class="detail" id="ST_XMax(org.locationtech.jts.geom.Geometry)">
<h3>ST_XMax</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_XMax</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the X maxima of a 2D or 3D bounding box or a geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_XMin(org.locationtech.jts.geom.Geometry)">
<h3>ST_XMin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_XMin</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the X minima of a 2D or 3D bounding box or a geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Y(org.locationtech.jts.geom.Geometry)">
<h3>ST_Y</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_Y</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the y-value of the first coordinate of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_YMax(org.locationtech.jts.geom.Geometry)">
<h3>ST_YMax</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_YMax</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the Y maxima of a 2D or 3D bounding box or a geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_YMin(org.locationtech.jts.geom.Geometry)">
<h3>ST_YMin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_YMin</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the Y minima of a 2D or 3D bounding box or a geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Z(org.locationtech.jts.geom.Geometry)">
<h3>ST_Z</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_Z</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the z-value of the first coordinate of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ZMax(org.locationtech.jts.geom.Geometry)">
<h3>ST_ZMax</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_ZMax</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the maximum z-value of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ZMin(org.locationtech.jts.geom.Geometry)">
<h3>ST_ZMin</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/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_ZMin</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum z-value of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Boundary(org.locationtech.jts.geom.Geometry)">
<h3>ST_Boundary</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Boundary</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the boundary of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Centroid(org.locationtech.jts.geom.Geometry)">
<h3>ST_Centroid</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Centroid</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the centroid of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_CoordDim(org.locationtech.jts.geom.Geometry)">
<h3>ST_CoordDim</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_CoordDim</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the dimension of the coordinates of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Dimension(org.locationtech.jts.geom.Geometry)">
<h3>ST_Dimension</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_Dimension</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the dimension of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Distance(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Distance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">ST_Distance</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns the distance between <code>geom1</code> and <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_GeometryType(org.locationtech.jts.geom.Geometry)">
<h3>ST_GeometryType</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/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_GeometryType</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the type of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_GeometryTypeCode(org.locationtech.jts.geom.Geometry)">
<h3>ST_GeometryTypeCode</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">ST_GeometryTypeCode</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the OGC SFS type code of <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Envelope(org.locationtech.jts.geom.Geometry)">
<h3>ST_Envelope</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Envelope</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the minimum bounding box of <code>geom</code> (which may be a GEOMETRYCOLLECTION).</div>
</section>
</li>
<li>
<section class="detail" id="ST_Contains(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Contains</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Contains</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> contains <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ContainsProperly(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_ContainsProperly</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_ContainsProperly</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> contains <code>geom2</code> but does not intersect its boundary.</div>
</section>
</li>
<li>
<section class="detail" id="ST_CoveredBy(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_CoveredBy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_CoveredBy</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether no point in <code>geom1</code> is outside <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Covers(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Covers</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Covers</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether no point in <code>geom2</code> is outside <code>geom1</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Crosses(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Crosses</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Crosses</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> crosses <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Disjoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Disjoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Disjoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> and <code>geom2</code> are disjoint.</div>
</section>
</li>
<li>
<section class="detail" id="ST_EnvelopesIntersect(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_EnvelopesIntersect</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_EnvelopesIntersect</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether the envelope of <code>geom1</code> intersects the envelope of <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Equals(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Equals</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Equals</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> equals <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Intersects(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Intersects</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Intersects</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> intersects <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_OrderingEquals(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_OrderingEquals</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_OrderingEquals</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> equals <code>geom2</code> and their coordinates and component
 Geometries are listed in the same order.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Overlaps(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Overlaps</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Overlaps</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns <code>geom1</code> overlaps <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Touches(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Touches</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Touches</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> touches <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Within(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Within</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Within</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns whether <code>geom1</code> is within <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_DWithin(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,double)">
<h3>ST_DWithin</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_DWithin</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 double&nbsp;distance)</span></div>
<div class="block">Returns whether <code>geom1</code> and <code>geom2</code> are within <code>distance</code> of each other.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Buffer(org.locationtech.jts.geom.Geometry,double)">
<h3>ST_Buffer</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Buffer</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance)</span></div>
<div class="block">Computes a buffer around <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Buffer(org.locationtech.jts.geom.Geometry,double,int)">
<h3>ST_Buffer</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Buffer</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance,
 int&nbsp;quadSegs)</span></div>
<div class="block">Computes a buffer around <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Buffer(org.locationtech.jts.geom.Geometry,double,int,int)">
<h3>ST_Buffer</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Buffer</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 double&nbsp;distance,
 int&nbsp;quadSegs,
 int&nbsp;endCapStyle)</span></div>
<div class="block">Computes a buffer around <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ConvexHull(org.locationtech.jts.geom.Geometry)">
<h3>ST_ConvexHull</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ConvexHull</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Computes the smallest convex POLYGON that contains all the points of geom.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Difference(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Difference</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Difference</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Computes the difference between geom1 and geom2.</div>
</section>
</li>
<li>
<section class="detail" id="ST_SymDifference(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_SymDifference</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_SymDifference</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Computes the symmetric difference between geom1 and geom2.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Intersection(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Intersection</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Intersection</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Computes the intersection between geom1 and geom2.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Relate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_Relate</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/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">ST_Relate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns the DE-9IM intersection matrix for geom1 and geom2.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Relate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,java.lang.String)">
<h3>ST_Relate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">ST_Relate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;iMatrix)</span></div>
<div class="block">Returns true if geom1 and geom2 are related by the intersection matrix specified by iMatrix.</div>
</section>
</li>
<li>
<section class="detail" id="ST_UnaryUnion(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_UnaryUnion</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_UnaryUnion</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Computes the union of <code>geom1</code> and <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_UnaryUnion(org.locationtech.jts.geom.Geometry)">
<h3>ST_UnaryUnion</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_UnaryUnion</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geomCollection)</span></div>
<div class="block">Computes the union of the geometries in <code>geomCollection</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Transform(org.locationtech.jts.geom.Geometry,int)">
<h3>ST_Transform</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Transform</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;srid)</span></div>
<div class="block">Transforms <code>geom</code> from one coordinate reference system (CRS) to the CRS specified by
 <code>srid</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_SetSRID(org.locationtech.jts.geom.Geometry,int)">
<h3>ST_SetSRID</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_SetSRID</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 int&nbsp;srid)</span></div>
<div class="block">Returns a copy of <code>geom</code> with a new SRID.</div>
</section>
</li>
<li>
<section class="detail" id="ST_LineMerge(org.locationtech.jts.geom.Geometry)">
<h3>ST_LineMerge</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LineMerge</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Merges a collection of linear components to form a line-string of maximal length.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MakeValid(org.locationtech.jts.geom.Geometry)">
<h3>ST_MakeValid</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_MakeValid</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
<div class="block">Makes a valid geometry of a given invalid geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Polygonize(org.locationtech.jts.geom.Geometry)">
<h3>ST_Polygonize</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Polygonize</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry)</span></div>
<div class="block">Creates a multipolygon from the geometry.</div>
</section>
</li>
<li>
<section class="detail" id="ST_PrecisionReducer(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_PrecisionReducer</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_PrecisionReducer</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geometry,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;decimal)</span></div>
<div class="block">Reduces the geometry's precision to n decimal places.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Simplify(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_Simplify</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Simplify</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</span></div>
<div class="block">Simplifies geom a geometry using the Douglas-Peuker algorithm.</div>
</section>
</li>
<li>
<section class="detail" id="ST_SimplifyPreserveTopology(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_SimplifyPreserveTopology</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_SimplifyPreserveTopology</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;distance)</span></div>
<div class="block">Simplifies a geometry and preserves its topology.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Snap(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_Snap</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Snap</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;snapTolerance)</span></div>
<div class="block">Snaps geom1 and geom2 together with the given snapTolerance.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal)">
<h3>ST_Rotate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Rotate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle)</span></div>
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,org.locationtech.jts.geom.Geometry)">
<h3>ST_Rotate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Rotate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle,
 org.locationtech.jts.geom.Geometry&nbsp;origin)</span></div>
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Rotate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Rotate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Rotate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;angle,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</span></div>
<div class="block">Rotates geom counter-clockwise by angle (in radians) about the point origin.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Scale(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Scale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Scale</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;xFactor,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;yFactor)</span></div>
<div class="block">Scales geom Geometry by multiplying the ordinates by the indicated scale factors.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Translate(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_Translate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_Translate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</span></div>
<div class="block">Translates geom by the vector (x, y).</div>
</section>
</li>
<li>
<section class="detail" id="ST_Area(org.locationtech.jts.geom.Geometry)">
<h3>ST_Area</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_Area</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the area of the <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ClosestCoordinate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_ClosestCoordinate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ClosestCoordinate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the coordinate(s) of <code>geom</code> closest to <code>point</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_ClosestPoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_ClosestPoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ClosestPoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns the point of <code>geom1</code> closest to <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_FurthestCoordinate(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_FurthestCoordinate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_FurthestCoordinate</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the coordinate(s) of <code>geom</code> furthest from <code>point</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Length(org.locationtech.jts.geom.Geometry)">
<h3>ST_Length</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_Length</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the length of the <code>geom</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_LocateAlong(org.locationtech.jts.geom.Geometry,java.math.BigDecimal,java.math.BigDecimal)">
<h3>ST_LocateAlong</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LocateAlong</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;segmentLengthFraction,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;offsetDistance)</span></div>
<div class="block">Returns a MULTIPOINT containing points along the line segments of <code>geom</code>
 at <code>segmentLengthFraction</code> and <code>offsetDistance</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_LongestLine(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_LongestLine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_LongestLine</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Returns the 2-dimensional longest line-string between the points
 of <code>geom1</code> and <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_MaxDistance(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_MaxDistance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_MaxDistance</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom1,
 org.locationtech.jts.geom.Geometry&nbsp;geom2)</span></div>
<div class="block">Computes the maximum distance between <code>geom1</code> and <code>geom2</code>.</div>
</section>
</li>
<li>
<section class="detail" id="ST_Perimeter(org.locationtech.jts.geom.Geometry)">
<h3>ST_Perimeter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a></span>&nbsp;<span class="element-name">ST_Perimeter</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the length of the perimeter of *polygon* (which may be a MULTIPOLYGON).</div>
</section>
</li>
<li>
<section class="detail" id="ST_ProjectPoint(org.locationtech.jts.geom.Geometry,org.locationtech.jts.geom.Geometry)">
<h3>ST_ProjectPoint</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable org.locationtech.jts.geom.Geometry</span>&nbsp;<span class="element-name">ST_ProjectPoint</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;point,
 org.locationtech.jts.geom.Geometry&nbsp;lineString)</span></div>
<div class="block">Projects <code>point</code> onto a <code>lineString</code> (which may be a MULTILINESTRING).</div>
</section>
</li>
<li>
<section class="detail" id="hilbert(org.locationtech.jts.geom.Geometry)">
<h3>hilbert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">@Nullable <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a></span>&nbsp;<span class="element-name">hilbert</span><wbr><span class="parameters">(org.locationtech.jts.geom.Geometry&nbsp;geom)</span></div>
<div class="block">Returns the position of a point on the Hilbert curve, or null if it is not a 2-dimensional
 point.</div>
</section>
</li>
<li>
<section class="detail" id="hilbert(java.math.BigDecimal,java.math.BigDecimal)">
<h3>hilbert</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">hilbert</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;x,
 <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;y)</span></div>
<div class="block">Returns the position of a point on the Hilbert curve.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2023 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
