JTS Topology Suite version 1.13

## com.vividsolutions.jts.geom
Class Geometry

    java.lang.Object
      com.vividsolutions.jts.geom.Geometry

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable, java.lang.Comparable

Direct Known Subclasses:
  GeometryCollection, LineString, Point, Polygon

    public abstract class Geometry

extends java.lang.Object
implements java.lang.Cloneable, java.lang.Comparable, java.io.Serializable

A representation of a planar, linear vector geometry.

### Binary Predicates

Because it is not clear at this time what semantics for spatial analysis methods involving `GeometryCollection`s would be useful, `GeometryCollection`s are not supported as arguments to binary predicates or the `relate` method.

### Overlay Methods

The overlay methods return the most specific class possible to represent the result. If the result is homogeneous, a `Point`, `LineString`, or `Polygon` will be returned if the result contains a single element; otherwise, a `MultiPoint`, `MultiLineString`, or `MultiPolygon` will be returned. If the result is heterogeneous a `GeometryCollection` will be returned.

Because it is not clear at this time what semantics for set-theoretic methods involving `GeometryCollection`s would be useful, `GeometryCollections` are not supported as arguments to the set-theoretic methods.

#### Representation of Computed Geometries

The SFS states that the result of a set-theoretic method is the "point-set" result of the usual set-theoretic definition of the operation (SFS 3.2.21.1). However, there are sometimes many ways of representing a point set as a `Geometry`.

The SFS does not specify an unambiguous representation of a given point set returned from a spatial analysis method. One goal of JTS is to make this specification precise and unambiguous. JTS will use a canonical form for `Geometry`s returned from spatial analysis methods. The canonical form is a `Geometry` which is simple and noded:

- Simple means that the Geometry returned will be simple according to the JTS definition of `isSimple`.
- Noded applies only to overlays involving `LineString`s. It means that all intersection points on `LineString`s will be present as endpoints of `LineString`s in the result.

This definition implies that non-simple geometries which are arguments to spatial analysis methods must be subjected to a line-dissolve process to ensure that the results are simple.

#### Constructed Points And The Precision Model

The results computed by the set-theoretic methods may contain constructed points which are not present in the input `Geometry` s. These new points arise from intersections between line segments in the edges of the input `Geometry`s. In the general case it is not possible to represent constructed points exactly. This is due to the fact that the coordinates of an intersection point may contain twice as many bits of precision as the coordinates of the input line segments. In order to represent these constructed points explicitly, JTS must truncate them to fit the `PrecisionModel`.

Unfortunately, truncating coordinates moves them slightly. Line segments which would not be coincident in the exact result may become coincident in the truncated representation. This in turn leads to "topology collapses" -- situations where a computed element has a lower dimension than it would in the exact result.

When JTS detects topology collapses during the computation of spatial analysis methods, it will throw an exception. If possible the exception will report the location of the collapse.

### Geometry Equality

There are two ways of comparing geometries for equality: structural equality and topological equality.

#### Structural Equality

Structural Equality is provided by the `equalsExact(Geometry)` method. This implements a comparison based on exact, structural pointwise equality. The `equals(Object)` is a synonym for this method, to provide structural equality semantics for use in Java collections. It is important to note that structural pointwise equality is easily affected by things like ring order and component order. In many situations it will be desirable to normalize geometries before comparing them (using the `norm()` or `normalize()` methods). `equalsNorm(Geometry)` is provided as a convenience method to compute equality over normalized geometries, but it is expensive to use. Finally, `equalsExact(Geometry, double)` allows using a tolerance value for point comparison.

#### Topological Equality

Topological Equality is provided by the `equalsTopo(Geometry)` method. It implements the SFS definition of point-set equality defined in terms of the DE-9IM matrix. To support the SFS naming convention, the method `equals(Geometry)` is also provided as a synonym. However, due to the potential for confusion with `equals(Object)` its use is discouraged.

Since `equals(Object)` and `hashCode()` are overridden, Geometries can be used effectively in Java collections.

Version:
  1.7
See Also:
  Serialized Form

Field Summary
`protected Envelope` `envelope` The bounding box of this `Geometry`.
`protected GeometryFactory` `factory` The `GeometryFactory` used to create this Geometry
`protected int` `SRID` The ID of the Spatial Reference System used by this `Geometry`

Constructor Summary
`Geometry(GeometryFactory factory)` Creates a new `Geometry` via the specified GeometryFactory.

Method Summary
`abstract void` `apply(CoordinateFilter filter)` Performs an operation with or on this `Geometry`'s coordinates.
`abstract void` `apply(CoordinateSequenceFilter filter)` Performs an operation on the coordinates in this `Geometry`'s `CoordinateSequence`s.
`abstract void` `apply(GeometryComponentFilter filter)` Performs an operation with or on this Geometry and its component Geometry's.
`abstract void` `apply(GeometryFilter filter)` Performs an operation with or on this `Geometry` and its subelement `Geometry`s (if any).
`Geometry` `buffer(double distance)` Computes a buffer area around this geometry having the given width.
`Geometry` `buffer(double distance, int quadrantSegments)` Computes a buffer area around this geometry having the given width and with a specified accuracy of approximation for circular arcs.
`Geometry` `buffer(double distance, int quadrantSegments, int endCapStyle)` Computes a buffer area around this geometry having the given width and with a specified accuracy of approximation for circular arcs, and using a specified end cap style.
`protected void` `checkNotGeometryCollection(Geometry g)` Throws an exception if `g`'s class is `GeometryCollection` .
`java.lang.Object` `clone()` Creates and returns a full copy of this `Geometry` object (including all coordinates contained by it).
`protected int` `compare(java.util.Collection a, java.util.Collection b)` Returns the first non-zero result of `compareTo` encountered as the two `Collection`s are iterated over.
`int` `compareTo(java.lang.Object o)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`.
`int` `compareTo(java.lang.Object o, CoordinateSequenceComparator comp)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`, using the given `CoordinateSequenceComparator`.
`protected abstract int` `compareToSameClass(java.lang.Object o)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.
`protected abstract int` `compareToSameClass(java.lang.Object o, CoordinateSequenceComparator comp)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` of the same class.
`protected abstract Envelope` `computeEnvelopeInternal()` Returns the minimum and maximum x and y values in this `Geometry` , or a null `Envelope` if this `Geometry` is empty.
`boolean` `contains(Geometry g)` Tests whether this geometry contains the argument geometry.
`Geometry` `convexHull()` Computes the smallest convex `Polygon` that contains all the points in the `Geometry`.
`boolean` `coveredBy(Geometry g)` Tests whether this geometry is covered by the argument geometry.
`boolean` `covers(Geometry g)` Tests whether this geometry covers the argument geometry.
`boolean` `crosses(Geometry g)` Tests whether this geometry crosses the argument geometry.
`Geometry` `difference(Geometry other)` Computes a `Geometry` representing the closure of the point-set of the points contained in this `Geometry` that are not contained in the `other` Geometry.
`boolean` `disjoint(Geometry g)` Tests whether this geometry is disjoint from the argument geometry.
`double` `distance(Geometry g)` Returns the minimum distance between this `Geometry` and another `Geometry`.
`protected boolean` `equal(Coordinate a, Coordinate b, double tolerance)`
`boolean` `equals(Geometry g)` Tests whether this geometry is topologically equal to the argument geometry.
`boolean` `equals(java.lang.Object o)` Tests whether this geometry is structurally and numerically equal to a given `Object`.
`boolean` `equalsExact(Geometry other)` Returns true if the two `Geometry`s are exactly equal.
`abstract boolean` `equalsExact(Geometry other, double tolerance)` Returns true if the two `Geometry`s are exactly equal, up to a specified distance tolerance.
`boolean` `equalsNorm(Geometry g)` Tests whether two geometries are exactly equal in their normalized forms.
`boolean` `equalsTopo(Geometry g)` Tests whether this geometry is topologically equal to the argument geometry as defined by the SFS `equals` predicate.
`void` `geometryChanged()` Notifies this geometry that its coordinates have been changed by an external party (for example, via a `CoordinateFilter`).
`protected void` `geometryChangedAction()` Notifies this Geometry that its Coordinates have been changed by an external party.
`double` `getArea()` Returns the area of this `Geometry`.
`abstract Geometry` `getBoundary()` Returns the boundary, or an empty geometry of appropriate dimension if this `Geometry` is empty.
`abstract int` `getBoundaryDimension()` Returns the dimension of this `Geometry`s inherent boundary.
`Point` `getCentroid()` Computes the centroid of this `Geometry`.
`abstract Coordinate` `getCoordinate()` Returns a vertex of this `Geometry` (usually, but not necessarily, the first one).
`abstract Coordinate[]` `getCoordinates()` Returns an array containing the values of all the vertices for this geometry.
`abstract int` `getDimension()` Returns the dimension of this geometry.
`Geometry` `getEnvelope()` Gets a Geometry representing the envelope (bounding box) of this `Geometry`.
`Envelope` `getEnvelopeInternal()` Gets an `Envelope` containing the minimum and maximum x and y values in this `Geometry`.
`GeometryFactory` `getFactory()` Gets the factory which contains the context in which this geometry was created.
`Geometry` `getGeometryN(int n)` Returns an element `Geometry` from a `GeometryCollection` (or `this`, if the geometry is not a collection).
`abstract java.lang.String` `getGeometryType()` Returns the name of this Geometry's actual class.
`Point` `getInteriorPoint()` Computes an interior point of this `Geometry`.
`double` `getLength()` Returns the length of this `Geometry`.
`int` `getNumGeometries()` Returns the number of `Geometry`s in a `GeometryCollection` (or 1, if the geometry is not a collection).
`abstract int` `getNumPoints()` Returns the count of this `Geometry`s vertices.
`PrecisionModel` `getPrecisionModel()` Returns the `PrecisionModel` used by the `Geometry`.
`int` `getSRID()` Returns the ID of the Spatial Reference System used by the `Geometry`.
`java.lang.Object` `getUserData()` Gets the user data object for this geometry, if any.
`int` `hashCode()` Gets a hash code for the Geometry.
`protected static boolean` `hasNonEmptyElements(Geometry[] geometries)` Returns true if the array contains any non-empty `Geometry`s.
`protected static boolean` `hasNullElements(java.lang.Object[] array)` Returns true if the array contains any `null` elements.
`Geometry` `intersection(Geometry other)` Computes a `Geometry` representing the point-set which is common to both this `Geometry` and the `other` Geometry.
`boolean` `intersects(Geometry g)` Tests whether this geometry intersects the argument geometry.
`abstract boolean` `isEmpty()` Tests whether the set of points covered by this `Geometry` is empty.
`protected boolean` `isEquivalentClass(Geometry other)` Returns whether the two `Geometry`s are equal, from the point of view of the `equalsExact` method.
`protected boolean` `isGeometryCollection()` Tests whether this is an instance of a general `GeometryCollection`, rather than a homogeneous subclass.
`boolean` `isRectangle()`
`boolean` `isSimple()` Tests whether this `Geometry` is simple.
`boolean` `isValid()` Tests whether this `Geometry` is topologically valid, according to the OGC SFS specification.
`boolean` `isWithinDistance(Geometry geom, double distance)` Tests whether the distance from this `Geometry` to another is less than or equal to a specified value.
`Geometry` `norm()` Creates a new Geometry which is a normalized copy of this Geometry.
`abstract void` `normalize()` Converts this `Geometry` to normal form (or canonical form ).
`boolean` `overlaps(Geometry g)` Tests whether this geometry overlaps the specified geometry.
`IntersectionMatrix` `relate(Geometry g)` Returns the DE-9IM `IntersectionMatrix` for the two `Geometry`s.
`boolean` `relate(Geometry g, java.lang.String intersectionPattern)` Tests whether the elements in the DE-9IM `IntersectionMatrix` for the two `Geometry`s match the elements in `intersectionPattern`.
`abstract Geometry` `reverse()` Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.
`void` `setSRID(int SRID)` Sets the ID of the Spatial Reference System used by the `Geometry`.
`void` `setUserData(java.lang.Object userData)` A simple scheme for applications to add their own custom data to a Geometry.
`Geometry` `symDifference(Geometry other)` Computes a <coe>Geometry representing the closure of the point-set which is the union of the points in this `Geometry` which are not contained in the `other` Geometry, with the points in the `other` Geometry not contained in this `Geometry`.
`java.lang.String` `toString()`
`java.lang.String` `toText()` Returns the Well-known Text representation of this `Geometry`.
`boolean` `touches(Geometry g)` Tests whether this geometry touches the argument geometry.
`Geometry` `union()` Computes the union of all the elements of this geometry.
`Geometry` `union(Geometry other)` Computes a `Geometry` representing the point-set which is contained in both this `Geometry` and the `other` Geometry.
`boolean` `within(Geometry g)` Tests whether this geometry is within the specified geometry.

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### envelope

    protected Envelope envelope

  The bounding box of this `Geometry`.

### factory

    protected final GeometryFactory factory

  The `GeometryFactory` used to create this Geometry

### SRID

    protected int SRID

  The ID of the Spatial Reference System used by this `Geometry`

Constructor Detail

### Geometry

    public Geometry(GeometryFactory factory)

  Creates a new `Geometry` via the specified GeometryFactory.

  Parameters:
    `factory` -

Method Detail

### getGeometryType

    public abstract java.lang.String getGeometryType()

  Returns the name of this Geometry's actual class.

  Returns:
    the name of this `Geometry`s actual class

### hasNonEmptyElements

    protected static boolean hasNonEmptyElements(Geometry[] geometries)

  Returns true if the array contains any non-empty `Geometry`s.

  Parameters:
    `geometries` - an array of `Geometry`s; no elements may be `null`
  Returns:
    `true` if any of the `Geometry`s `isEmpty` methods return `false`

### hasNullElements

    protected static boolean hasNullElements(java.lang.Object[] array)

  Returns true if the array contains any `null` elements.

  Parameters:
    `array` - an array to validate
  Returns:
    `true` if any of `array`s elements are `null`

### getSRID

    public int getSRID()

  Returns the ID of the Spatial Reference System used by the `Geometry`.

  JTS supports Spatial Reference System information in the simple way defined in the SFS. A Spatial Reference System ID (SRID) is present in each `Geometry` object. `Geometry` provides basic accessor operations for this field, but no others. The SRID is represented as an integer.

  Returns:
    the ID of the coordinate space in which the `Geometry` is defined.

### setSRID

    public void setSRID(int SRID)

  Sets the ID of the Spatial Reference System used by the `Geometry`.

  NOTE: This method should only be used for exceptional circumstances or for backwards compatibility. Normally the SRID should be set on the `GeometryFactory` used to create the geometry. SRIDs set using this method will not be propagated to geometries returned by constructive methods.

  See Also:
    `GeometryFactory`

### getFactory

    public GeometryFactory getFactory()

  Gets the factory which contains the context in which this geometry was created.

  Returns:
    the factory for this geometry

### getUserData

    public java.lang.Object getUserData()

  Gets the user data object for this geometry, if any.

  Returns:
    the user data object, or `null` if none set

### getNumGeometries

    public int getNumGeometries()

  Returns the number of `Geometry`s in a `GeometryCollection` (or 1, if the geometry is not a collection).

  Returns:
    the number of geometries contained in this geometry

### getGeometryN

    public Geometry getGeometryN(int n)

  Returns an element `Geometry` from a `GeometryCollection` (or `this`, if the geometry is not a collection).

  Parameters:
    `n` - the index of the geometry element
  Returns:
    the n'th geometry contained in this geometry

### setUserData

    public void setUserData(java.lang.Object userData)

  A simple scheme for applications to add their own custom data to a Geometry. An example use might be to add an object representing a Coordinate Reference System.

  Note that user data objects are not present in geometries created by construction methods.

  Parameters:
    `userData` - an object, the semantics for which are defined by the application using this Geometry

### getPrecisionModel

    public PrecisionModel getPrecisionModel()

  Returns the `PrecisionModel` used by the `Geometry`.

  Returns:
    the specification of the grid of allowable points, for this `Geometry` and all other `Geometry`s

### getCoordinate

    public abstract Coordinate getCoordinate()

  Returns a vertex of this `Geometry` (usually, but not necessarily, the first one). The returned coordinate should not be assumed to be an actual Coordinate object used in the internal representation.

  Returns:
    a `Coordinate` which is a vertex of this `Geometry`.

### getCoordinates

    public abstract Coordinate[] getCoordinates()

  Returns an array containing the values of all the vertices for this geometry. If the geometry is a composite, the array will contain all the vertices for the components, in the order in which the components occur in the geometry.

  In general, the array cannot be assumed to be the actual internal storage for the vertices. Thus modifying the array may not modify the geometry itself. Use the `CoordinateSequence.setOrdinate(int, int, double)` method (possibly on the components) to modify the underlying data. If the coordinates are modified, `geometryChanged()` must be called afterwards.

  Returns:
    the vertices of this `Geometry`
  See Also:
    `geometryChanged()`, `CoordinateSequence.setOrdinate(int, int, double)`

### getNumPoints

    public abstract int getNumPoints()

  Returns the count of this `Geometry`s vertices. The `Geometry` s contained by composite `Geometry`s must be Geometry's; that is, they must implement `getNumPoints`

  Returns:
    the number of vertices in this `Geometry`

### isSimple

    public boolean isSimple()

  Tests whether this `Geometry` is simple. The SFS definition of simplicity follows the general rule that a Geometry is simple if it has no points of self-tangency, self-intersection or other anomalous points.

  Simplicity is defined for each `Geometry` subclass as follows:

  - Valid polygonal geometries are simple, since their rings must not self-intersect. `isSimple` tests for this condition and reports `false` if it is not met. (This is a looser test than checking for validity).
  - Linear rings have the same semantics.
  - Linear geometries are simple iff they do not self-intersect at points other than boundary points.
  - Zero-dimensional geometries (points) are simple iff they have no repeated points.
  - Empty `Geometry`s are always simple.

  Returns:
    `true` if this `Geometry` is simple
  See Also:
    `isValid()`

### isValid

    public boolean isValid()

  Tests whether this `Geometry` is topologically valid, according to the OGC SFS specification.

  For validity rules see the Javadoc for the specific Geometry subclass.

  Returns:
    `true` if this `Geometry` is valid
  See Also:
    `IsValidOp`

### isEmpty

    public abstract boolean isEmpty()

  Tests whether the set of points covered by this `Geometry` is empty.

  Returns:
    `true` if this `Geometry` does not cover any points

### distance

    public double distance(Geometry g)

  Returns the minimum distance between this `Geometry` and another `Geometry`.

  Parameters:
    `g` - the `Geometry` from which to compute the distance
  Returns:
    the distance between the geometries
  Throws:
    `java.lang.IllegalArgumentException` - if g is null

### isWithinDistance

    public boolean isWithinDistance(Geometry geom,
                                    double distance)

  Tests whether the distance from this `Geometry` to another is less than or equal to a specified value.

  Parameters:
    `geom` - the Geometry to check the distance to
    `distance` - the distance value to compare
  Returns:
    `true` if the geometries are less than `distance` apart.

### isRectangle

    public boolean isRectangle()

### getArea

    public double getArea()

  Returns the area of this `Geometry`. Areal Geometries have a non-zero area. They override this function to compute the area. Others return 0.0

  Returns:
    the area of the Geometry

### getLength

    public double getLength()

  Returns the length of this `Geometry`. Linear geometries return their length. Areal geometries return their perimeter. They override this function to compute the area. Others return 0.0

  Returns:
    the length of the Geometry

### getCentroid

    public Point getCentroid()

  Computes the centroid of this `Geometry`. The centroid is equal to the centroid of the set of component Geometries of highest dimension (since the lower-dimension geometries contribute zero "weight" to the centroid).

  The centroid of an empty geometry is `POINT EMPTY`.

  Returns:
    a `Point` which is the centroid of this Geometry

### getInteriorPoint

    public Point getInteriorPoint()

  Computes an interior point of this `Geometry`. An interior point is guaranteed to lie in the interior of the Geometry, if it possible to calculate such a point exactly. Otherwise, the point may lie on the boundary of the geometry.

  The interior point of an empty geometry is `POINT EMPTY`.

  Returns:
    a `Point` which is in the interior of this Geometry

### getDimension

    public abstract int getDimension()

  Returns the dimension of this geometry. The dimension of a geometry is is the topological dimension of its embedding in the 2-D Euclidean plane. In the JTS spatial model, dimension values are in the set {0,1,2}.

  Note that this is a different concept to the dimension of the vertex `Coordinate`s. The geometry dimension can never be greater than the coordinate dimension. For example, a 0-dimensional geometry (e.g. a Point) may have a coordinate dimension of 3 (X,Y,Z).

  Returns:
    the topological dimension of this geometry.

### getBoundary

    public abstract Geometry getBoundary()

  Returns the boundary, or an empty geometry of appropriate dimension if this `Geometry` is empty. (In the case of zero-dimensional geometries, ' an empty GeometryCollection is returned.) For a discussion of this function, see the OpenGIS Simple Features Specification. As stated in SFS Section 2.1.13.1, "the boundary of a Geometry is a set of Geometries of the next lower dimension."

  Returns:
    the closure of the combinatorial boundary of this `Geometry`

### getBoundaryDimension

    public abstract int getBoundaryDimension()

  Returns the dimension of this `Geometry`s inherent boundary.

  Returns:
    the dimension of the boundary of the class implementing this interface, whether or not this object is the empty geometry. Returns `Dimension.FALSE` if the boundary is the empty geometry.

### getEnvelope

    public Geometry getEnvelope()

  Gets a Geometry representing the envelope (bounding box) of this `Geometry`.

  If this `Geometry` is:

  - empty, returns an empty `Point`.
  - a point, returns a `Point`.
  - a line parallel to an axis, a two-vertex `LineString`
  - otherwise, returns a `Polygon` whose vertices are (minx miny, maxx miny, maxx maxy, minx maxy, minx miny).

  Returns:
    a Geometry representing the envelope of this Geometry
  See Also:
    `GeometryFactory.toGeometry(Envelope)`

### getEnvelopeInternal

    public Envelope getEnvelopeInternal()

  Gets an `Envelope` containing the minimum and maximum x and y values in this `Geometry`. If the geometry is empty, an empty `Envelope` is returned.

  The returned object is a copy of the one maintained internally, to avoid aliasing issues. For best performance, clients which access this envelope frequently should cache the return value.

  Returns:
    the envelope of this `Geometry`.

### geometryChanged

    public void geometryChanged()

  Notifies this geometry that its coordinates have been changed by an external party (for example, via a `CoordinateFilter`). When this method is called the geometry will flush and/or update any derived information it has cached (such as its `Envelope` ). The operation is applied to all component Geometries.

### geometryChangedAction

    protected void geometryChangedAction()

  Notifies this Geometry that its Coordinates have been changed by an external party. When #geometryChanged is called, this method will be called for this Geometry and its component Geometries.

  See Also:
    `apply(GeometryComponentFilter)`

### disjoint

    public boolean disjoint(Geometry g)

  Tests whether this geometry is disjoint from the argument geometry.

  The `disjoint` predicate has the following equivalent definitions:

  - The two geometries have no point in common
  - The DE-9IM Intersection Matrix for the two geometries matches `[FF*FF****]`
  - `! g.intersects(this) = true`
    (`disjoint` is the inverse of `intersects`)

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s are disjoint
  See Also:
    `intersects(com.vividsolutions.jts.geom.Geometry)`

### touches

    public boolean touches(Geometry g)

  Tests whether this geometry touches the argument geometry.

  The `touches` predicate has the following equivalent definitions:

  - The geometries have at least one point in common, but their interiors do not intersect.
  - The DE-9IM Intersection Matrix for the two geometries matches at least one of the following patterns
    - `[FT*******]`
    - `[F**T*****]`
    - `[F***T****]`
  If both geometries have dimension 0, this predicate returns `false`.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s touch; Returns `false` if both `Geometry`s are points

### intersects

    public boolean intersects(Geometry g)

  Tests whether this geometry intersects the argument geometry.

  The `intersects` predicate has the following equivalent definitions:

  - The two geometries have at least one point in common
  - The DE-9IM Intersection Matrix for the two geometries matches at least one of the patterns
    - `[T********]`
    - `[*T*******]`
    - `[***T*****]`
    - `[****T****]`
  - `! g.disjoint(this) = true`
    (`intersects` is the inverse of `disjoint`)

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s intersect
  See Also:
    `disjoint(com.vividsolutions.jts.geom.Geometry)`

### crosses

    public boolean crosses(Geometry g)

  Tests whether this geometry crosses the argument geometry.

  The `crosses` predicate has the following equivalent definitions:

  - The geometries have some but not all interior points in common.
  - The DE-9IM Intersection Matrix for the two geometries matches one of the following patterns:
    - `[T*T******]` (for P/L, P/A, and L/A situations)
    - `[T*****T**]` (for L/P, A/P, and A/L situations)
    - `[0********]` (for L/L situations)
  For any other combination of dimensions this predicate returns `false`.

  The SFS defined this predicate only for P/L, P/A, L/L, and L/A situations. In order to make the relation symmetric, JTS extends the definition to apply to L/P, A/P and A/L situations as well.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s cross.

### within

    public boolean within(Geometry g)

  Tests whether this geometry is within the specified geometry.

  The `within` predicate has the following equivalent definitions:

  - Every point of this geometry is a point of the other geometry, and the interiors of the two geometries have at least one point in common.
  - The DE-9IM Intersection Matrix for the two geometries matches `[T*F**F***]`
  - `g.contains(this) = true`
    (`within` is the converse of `contains(com.vividsolutions.jts.geom.Geometry)`)
  An implication of the definition is that "The boundary of a Geometry is not within the Geometry". In other words, if a geometry A is a subset of the points in the boundary of a geomtry B, `A.within(B) = false` (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.) For a predicate with similar behaviour but avoiding this subtle limitation, see `coveredBy(com.vividsolutions.jts.geom.Geometry)`.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this `Geometry` is within `g`
  See Also:
    `contains(com.vividsolutions.jts.geom.Geometry)`, `coveredBy(com.vividsolutions.jts.geom.Geometry)`

### contains

    public boolean contains(Geometry g)

  Tests whether this geometry contains the argument geometry.

  The `contains` predicate has the following equivalent definitions:

  - Every point of the other geometry is a point of this geometry, and the interiors of the two geometries have at least one point in common.
  - The DE-9IM Intersection Matrix for the two geometries matches the pattern `[T*****FF*]`
  - `g.within(this) = true`
    (`contains` is the converse of `within(com.vividsolutions.jts.geom.Geometry)` )
  An implication of the definition is that "Geometries do not contain their boundary". In other words, if a geometry A is a subset of the points in the boundary of a geometry B, `B.contains(A) = false`. (As a concrete example, take A to be a LineString which lies in the boundary of a Polygon B.) For a predicate with similar behaviour but avoiding this subtle limitation, see `covers(com.vividsolutions.jts.geom.Geometry)`.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this `Geometry` contains `g`
  See Also:
    `within(com.vividsolutions.jts.geom.Geometry)`, `covers(com.vividsolutions.jts.geom.Geometry)`

### overlaps

    public boolean overlaps(Geometry g)

  Tests whether this geometry overlaps the specified geometry.

  The `overlaps` predicate has the following equivalent definitions:

  - The geometries have at least one point each not shared by the other (or equivalently neither covers the other), they have the same dimension, and the intersection of the interiors of the two geometries has the same dimension as the geometries themselves.
  - The DE-9IM Intersection Matrix for the two geometries matches `[T*T***T**]` (for two points or two surfaces) or `[1*T***T**]` (for two curves)
  If the geometries are of different dimension this predicate returns `false`.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s overlap.

### covers

    public boolean covers(Geometry g)

  Tests whether this geometry covers the argument geometry.

  The `covers` predicate has the following equivalent definitions:

  - Every point of the other geometry is a point of this geometry.
  - The DE-9IM Intersection Matrix for the two geometries matches at least one of the following patterns:
    - `[T*****FF*]`
    - `[*T****FF*]`
    - `[***T**FF*]`
    - `[****T*FF*]`
  - `g.coveredBy(this) = true`
    (`covers` is the converse of `coveredBy(com.vividsolutions.jts.geom.Geometry)`)
  If either geometry is empty, the value of this predicate is `false`.

  This predicate is similar to `contains(com.vividsolutions.jts.geom.Geometry)`, but is more inclusive (i.e. returns `true` for more cases). In particular, unlike `contains` it does not distinguish between points in the boundary and in the interior of geometries. For most situations, `covers` should be used in preference to `contains`. As an added benefit, `covers` is more amenable to optimization, and hence should be more performant.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this `Geometry` covers `g`
  See Also:
    `contains(com.vividsolutions.jts.geom.Geometry)`, `coveredBy(com.vividsolutions.jts.geom.Geometry)`

### coveredBy

    public boolean coveredBy(Geometry g)

  Tests whether this geometry is covered by the argument geometry.

  The `coveredBy` predicate has the following equivalent definitions:

  - Every point of this geometry is a point of the other geometry.
  - The DE-9IM Intersection Matrix for the two geometries matches at least one of the following patterns:
    - `[T*F**F***]`
    - `[*TF**F***]`
    - `[**FT*F***]`
    - `[**F*TF***]`
  - `g.covers(this) = true`
    (`coveredBy` is the converse of `covers(com.vividsolutions.jts.geom.Geometry)`)
  If either geometry is empty, the value of this predicate is `false`.

  This predicate is similar to `within(com.vividsolutions.jts.geom.Geometry)`, but is more inclusive (i.e. returns `true` for more cases).

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this `Geometry` is covered by `g`
  See Also:
    `within(com.vividsolutions.jts.geom.Geometry)`, `covers(com.vividsolutions.jts.geom.Geometry)`

### relate

    public boolean relate(Geometry g,
                          java.lang.String intersectionPattern)

  Tests whether the elements in the DE-9IM `IntersectionMatrix` for the two `Geometry`s match the elements in `intersectionPattern`. The pattern is a 9-character string, with symbols drawn from the following set:
  - 0 (dimension 0)
  - 1 (dimension 1)
  - 2 (dimension 2)
  - T ( matches 0, 1 or 2)
  - F ( matches FALSE)
  - * ( matches any value)
  For more information on the DE-9IM, see the OpenGIS Simple Features Specification.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
    `intersectionPattern` - the pattern against which to check the intersection matrix for the two `Geometry`s
  Returns:
    `true` if the DE-9IM intersection matrix for the two `Geometry`s match `intersectionPattern`
  See Also:
    `IntersectionMatrix`

### relate

    public IntersectionMatrix relate(Geometry g)

  Returns the DE-9IM `IntersectionMatrix` for the two `Geometry`s.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    an `IntersectionMatrix` describing the intersections of the interiors, boundaries and exteriors of the two `Geometry`s

### equals

    public boolean equals(Geometry g)

  Tests whether this geometry is topologically equal to the argument geometry.

  This method is included for backward compatibility reasons. It has been superseded by the `equalsTopo(Geometry)` method, which has been named to clearly denote its functionality.

  This method should NOT be confused with the method `equals(Object)`, which implements an exact equality comparison.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    true if the two `Geometry`s are topologically equal
  See Also:
    `equalsTopo(Geometry)`

### equalsTopo

    public boolean equalsTopo(Geometry g)

  Tests whether this geometry is topologically equal to the argument geometry as defined by the SFS `equals` predicate.

  The SFS `equals` predicate has the following equivalent definitions:

  - The two geometries have at least one point in common, and no point of either geometry lies in the exterior of the other geometry.
  - The DE-9IM Intersection Matrix for the two geometries matches the pattern `T*F**FFF*`

         T*F
         **F
         FF*

  Note that this method computes topologically equality. For structural equality, see `equalsExact(Geometry)`.

  Parameters:
    `g` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if the two `Geometry`s are topologically equal
  See Also:
    `equalsExact(Geometry)`

### equals

    public boolean equals(java.lang.Object o)

  Tests whether this geometry is structurally and numerically equal to a given `Object`. If the argument `Object` is not a `Geometry`, the result is `false`. Otherwise, the result is computed using `equalsExact(Geometry)`.

  This method is provided to fulfill the Java contract for value-based object equality. In conjunction with `hashCode()` it provides semantics which are most useful for using `Geometry`s as keys and values in Java collections.

  Note that to produce the expected result the input geometries should be in normal form. It is the caller's responsibility to perform this where required (using Geometry#norm() or {@link #normalize()} as appropriate).

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `o` - the Object to compare
  Returns:
    true if this geometry is exactly equal to the argument
  See Also:
    `equalsExact(Geometry)`, `hashCode()`, `norm()`, `normalize()`

### hashCode

    public int hashCode()

  Gets a hash code for the Geometry.

  Overrides:
    `hashCode` in class `java.lang.Object`
  Returns:
    an integer value suitable for use as a hashcode

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

### toText

    public java.lang.String toText()

  Returns the Well-known Text representation of this `Geometry`. For a definition of the Well-known Text format, see the OpenGIS Simple Features Specification.

  Returns:
    the Well-known Text representation of this `Geometry`

### buffer

    public Geometry buffer(double distance)

  Computes a buffer area around this geometry having the given width. The buffer of a Geometry is the Minkowski sum or difference of the geometry with a disc of radius `abs(distance)`.

  Mathematically-exact buffer area boundaries can contain circular arcs. To represent these arcs using linear geometry they must be approximated with line segments. The buffer geometry is constructed using 8 segments per quadrant to approximate the circular arcs. The end cap style is `CAP_ROUND`.

  The buffer operation always returns a polygonal result. The negative or zero-distance buffer of lines and points is always an empty `Polygon`. This is also the result for the buffers of degenerate (zero-area) polygons.

  Parameters:
    `distance` - the width of the buffer (may be positive, negative or 0)
  Returns:
    a polygonal geometry representing the buffer region (which may be empty)
  Throws:
    `TopologyException` - if a robustness error occurs
  See Also:
    `buffer(double, int)`, `buffer(double, int, int)`

### buffer

    public Geometry buffer(double distance,
                           int quadrantSegments)

  Computes a buffer area around this geometry having the given width and with a specified accuracy of approximation for circular arcs.

  Mathematically-exact buffer area boundaries can contain circular arcs. To represent these arcs using linear geometry they must be approximated with line segments. The `quadrantSegments` argument allows controlling the accuracy of the approximation by specifying the number of line segments used to represent a quadrant of a circle

  The buffer operation always returns a polygonal result. The negative or zero-distance buffer of lines and points is always an empty `Polygon`. This is also the result for the buffers of degenerate (zero-area) polygons.

  Parameters:
    `distance` - the width of the buffer (may be positive, negative or 0)
    `quadrantSegments` - the number of line segments used to represent a quadrant of a circle
  Returns:
    a polygonal geometry representing the buffer region (which may be empty)
  Throws:
    `TopologyException` - if a robustness error occurs
  See Also:
    `buffer(double)`, `buffer(double, int, int)`

### buffer

    public Geometry buffer(double distance,
                           int quadrantSegments,
                           int endCapStyle)

  Computes a buffer area around this geometry having the given width and with a specified accuracy of approximation for circular arcs, and using a specified end cap style.

  Mathematically-exact buffer area boundaries can contain circular arcs. To represent these arcs using linear geometry they must be approximated with line segments. The `quadrantSegments` argument allows controlling the accuracy of the approximation by specifying the number of line segments used to represent a quadrant of a circle

  The end cap style specifies the buffer geometry that will be created at the ends of linestrings. The styles provided are:

  - `BufferOp.CAP_ROUND` - (default) a semi-circle
  - `BufferOp.CAP_BUTT` - a straight line perpendicular to the end segment
  - `BufferOp.CAP_SQUARE` - a half-square

  The buffer operation always returns a polygonal result. The negative or zero-distance buffer of lines and points is always an empty `Polygon`. This is also the result for the buffers of degenerate (zero-area) polygons.

  Parameters:
    `distance` - the width of the buffer (may be positive, negative or 0)
    `quadrantSegments` - the number of line segments used to represent a quadrant of a circle
    `endCapStyle` - the end cap style to use
  Returns:
    a polygonal geometry representing the buffer region (which may be empty)
  Throws:
    `TopologyException` - if a robustness error occurs
  See Also:
    `buffer(double)`, `buffer(double, int)`, `BufferOp`

### convexHull

    public Geometry convexHull()

  Computes the smallest convex `Polygon` that contains all the points in the `Geometry`. This obviously applies only to `Geometry` s which contain 3 or more points; the results for degenerate cases are specified as follows:

  Number of `Point`s in argument `Geometry` | `Geometry` class of result
  --- | ---
  0 | empty `GeometryCollection`
  1 | `Point`
  2 | `LineString`
  3 or more | `Polygon`

  Returns:
    the minimum-area convex polygon containing this `Geometry`' s points

### reverse

    public abstract Geometry reverse()

  Computes a new geometry which has all component coordinate sequences in reverse order (opposite orientation) to this one.

  Returns:
    a reversed geometry

### intersection

    public Geometry intersection(Geometry other)

  Computes a `Geometry` representing the point-set which is common to both this `Geometry` and the `other` Geometry.

  The intersection of two geometries of different dimension produces a result geometry of dimension less than or equal to the minimum dimension of the input geometries. The result geometry may be a heterogenous `GeometryCollection`. If the result is empty, it is an atomic geometry with the dimension of the lowest input dimension.

  Intersection of `GeometryCollection`s is supported only for homogeneous collection types.

  Non-empty heterogeneous `GeometryCollection` arguments are not supported.

  Parameters:
    `other` - the `Geometry` with which to compute the intersection
  Returns:
    a Geometry representing the point-set common to the two `Geometry`s
  Throws:
    `TopologyException` - if a robustness error occurs
    `java.lang.IllegalArgumentException` - if the argument is a non-empty heterogeneous `GeometryCollection`

### union

    public Geometry union(Geometry other)

  Computes a `Geometry` representing the point-set which is contained in both this `Geometry` and the `other` Geometry.

  The union of two geometries of different dimension produces a result geometry of dimension equal to the maximum dimension of the input geometries. The result geometry may be a heterogenous `GeometryCollection`. If the result is empty, it is an atomic geometry with the dimension of the highest input dimension.

  Unioning `LineString`s has the effect of noding and dissolving the input linework. In this context "noding" means that there will be a node or endpoint in the result for every endpoint or line segment crossing in the input. "Dissolving" means that any duplicate (i.e. coincident) line segments or portions of line segments will be reduced to a single line segment in the result. If merged linework is required, the `LineMerger` class can be used.

  Non-empty `GeometryCollection` arguments are not supported.

  Parameters:
    `other` - the `Geometry` with which to compute the union
  Returns:
    a point-set combining the points of this `Geometry` and the points of `other`
  Throws:
    `TopologyException` - if a robustness error occurs
    `java.lang.IllegalArgumentException` - if either input is a non-empty GeometryCollection
  See Also:
    `LineMerger`

### difference

    public Geometry difference(Geometry other)

  Computes a `Geometry` representing the closure of the point-set of the points contained in this `Geometry` that are not contained in the `other` Geometry.

  If the result is empty, it is an atomic geometry with the dimension of the left-hand input.

  Non-empty `GeometryCollection` arguments are not supported.

  Parameters:
    `other` - the `Geometry` with which to compute the difference
  Returns:
    a Geometry representing the point-set difference of this `Geometry` with `other`
  Throws:
    `TopologyException` - if a robustness error occurs
    `java.lang.IllegalArgumentException` - if either input is a non-empty GeometryCollection

### symDifference

    public Geometry symDifference(Geometry other)

  Computes a <coe>Geometry representing the closure of the point-set which is the union of the points in this `Geometry` which are not contained in the `other` Geometry, with the points in the `other` Geometry not contained in this `Geometry`. If the result is empty, it is an atomic geometry with the dimension of the highest input dimension.

  Non-empty `GeometryCollection` arguments are not supported.

  Parameters:
    `other` - the `Geometry` with which to compute the symmetric difference
  Returns:
    a Geometry representing the point-set symmetric difference of this `Geometry` with `other`
  Throws:
    `TopologyException` - if a robustness error occurs
    `java.lang.IllegalArgumentException` - if either input is a non-empty GeometryCollection

### union

    public Geometry union()

  Computes the union of all the elements of this geometry.

  `union()` supports `GeometryCollection`s (which the other overlay operations currently do not).

  The result obeys the following contract:

  - Unioning a set of `LineString`s has the effect of fully noding and dissolving the linework.
  - Unioning a set of `Polygon`s will always return a `Polygonal` geometry (unlike `union(Geometry)`, which may return geometrys of lower dimension if a topology collapse occurred.

  Returns:
    the union geometry
  Throws:
    `TopologyException` - if a robustness error occurs
  See Also:
    `UnaryUnionOp`

### equalsExact

    public abstract boolean equalsExact(Geometry other,
                                        double tolerance)

  Returns true if the two `Geometry`s are exactly equal, up to a specified distance tolerance. Two Geometries are exactly equal within a distance tolerance if and only if:
  - they have the same structure
  - they have the same values for their vertices, within the given tolerance distance, in exactly the same order.
  This method does not test the values of the `GeometryFactory`, the `SRID`, or the `userData` fields.

  To properly test equality between different geometries, it is usually necessary to `normalize()` them first.

  Parameters:
    `other` - the `Geometry` with which to compare this `Geometry`
    `tolerance` - distance at or below which two `Coordinate`s are considered equal
  Returns:
    `true` if this and the other `Geometry` have identical structure and point values, up to the distance tolerance.
  See Also:
    `equalsExact(Geometry)`, `normalize()`, `norm()`

### equalsExact

    public boolean equalsExact(Geometry other)

  Returns true if the two `Geometry`s are exactly equal. Two Geometries are exactly equal iff:
  - they have the same structure
  - they have the same values for their vertices, in exactly the same order.
  This provides a stricter test of equality than `equalsTopo(Geometry)`, which is more useful in certain situations (such as using geometries as keys in collections).

  This method does not test the values of the `GeometryFactory`, the `SRID`, or the `userData` fields.

  To properly test equality between different geometries, it is usually necessary to `normalize()` them first.

  Parameters:
    `other` - the `Geometry` with which to compare this `Geometry`
  Returns:
    `true` if this and the other `Geometry` have identical structure and point values.
  See Also:
    `equalsExact(Geometry, double)`, `normalize()`, `norm()`

### equalsNorm

    public boolean equalsNorm(Geometry g)

  Tests whether two geometries are exactly equal in their normalized forms. This is a convenience method which creates normalized versions of both geometries before computing `equalsExact(Geometry)`.

  This method is relatively expensive to compute. For maximum performance, the client should instead perform normalization on the individual geometries at an appropriate point during processing.

  Parameters:
    `g` - a Geometry
  Returns:
    true if the input geometries are exactly equal in their normalized form

### apply

    public abstract void apply(CoordinateFilter filter)

  Performs an operation with or on this `Geometry`'s coordinates. If this method modifies any coordinate values, `geometryChanged()` must be called to update the geometry state. Note that you cannot use this method to modify this Geometry if its underlying CoordinateSequence's #get method returns a copy of the Coordinate, rather than the actual Coordinate stored (if it even stores Coordinate objects at all).

  Parameters:
    `filter` - the filter to apply to this `Geometry`'s coordinates

### apply

    public abstract void apply(CoordinateSequenceFilter filter)

  Performs an operation on the coordinates in this `Geometry`'s `CoordinateSequence`s. If the filter reports that a coordinate value has been changed, `geometryChanged()` will be called automatically.

  Parameters:
    `filter` - the filter to apply

### apply

    public abstract void apply(GeometryFilter filter)

  Performs an operation with or on this `Geometry` and its subelement `Geometry`s (if any). Only GeometryCollections and subclasses have subelement Geometry's.

  Parameters:
    `filter` - the filter to apply to this `Geometry` (and its children, if it is a `GeometryCollection`).

### apply

    public abstract void apply(GeometryComponentFilter filter)

  Performs an operation with or on this Geometry and its component Geometry's. Only GeometryCollections and Polygons have component Geometry's; for Polygons they are the LinearRings of the shell and holes.

  Parameters:
    `filter` - the filter to apply to this `Geometry`.

### clone

    public java.lang.Object clone()

  Creates and returns a full copy of this `Geometry` object (including all coordinates contained by it). Subclasses are responsible for overriding this method and copying their internal data. Overrides should call this method first.

  Overrides:
    `clone` in class `java.lang.Object`
  Returns:
    a clone of this instance

### normalize

    public abstract void normalize()

  Converts this `Geometry` to normal form (or canonical form ). Normal form is a unique representation for `Geometry` s. It can be used to test whether two `Geometry`s are equal in a way that is independent of the ordering of the coordinates within them. Normal form equality is a stronger condition than topological equality, but weaker than pointwise equality. The definitions for normal form use the standard lexicographical ordering for coordinates. "Sorted in order of coordinates" means the obvious extension of this ordering to sequences of coordinates.

  NOTE that this method mutates the value of this geometry in-place. If this is not safe and/or wanted, the geometry should be cloned prior to normalization.

### norm

    public Geometry norm()

  Creates a new Geometry which is a normalized copy of this Geometry.

  Returns:
    a normalized copy of this geometry.
  See Also:
    `normalize()`

### compareTo

    public int compareTo(java.lang.Object o)

  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`.

  If their classes are different, they are compared using the following ordering:

  - Point (lowest)
  - MultiPoint
  - LineString
  - LinearRing
  - MultiLineString
  - Polygon
  - MultiPolygon
  - GeometryCollection (highest)
  If the two `Geometry`s have the same class, their first elements are compared. If those are the same, the second elements are compared, etc.

  Specified by:
    `compareTo` in interface `java.lang.Comparable`
  Parameters:
    `o` - a `Geometry` with which to compare this `Geometry`
  Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications

### compareTo

    public int compareTo(java.lang.Object o,
                         CoordinateSequenceComparator comp)

  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`, using the given `CoordinateSequenceComparator`.

  If their classes are different, they are compared using the following ordering:

  - Point (lowest)
  - MultiPoint
  - LineString
  - LinearRing
  - MultiLineString
  - Polygon
  - MultiPolygon
  - GeometryCollection (highest)
  If the two `Geometry`s have the same class, their first elements are compared. If those are the same, the second elements are compared, etc.

  Parameters:
    `o` - a `Geometry` with which to compare this `Geometry`
    `comp` - a `CoordinateSequenceComparator`
  Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications

### isEquivalentClass

    protected boolean isEquivalentClass(Geometry other)

  Returns whether the two `Geometry`s are equal, from the point of view of the `equalsExact` method. Called by `equalsExact` . In general, two `Geometry` classes are considered to be "equivalent" only if they are the same class. An exception is `LineString` , which is considered to be equivalent to its subclasses.

  Parameters:
    `other` - the `Geometry` with which to compare this `Geometry` for equality
  Returns:
    `true` if the classes of the two `Geometry` s are considered to be equal by the `equalsExact` method.

### checkNotGeometryCollection

    protected void checkNotGeometryCollection(Geometry g)

  Throws an exception if `g`'s class is `GeometryCollection` . (Its subclasses do not trigger an exception).

  Parameters:
    `g` - the `Geometry` to check
  Throws:
    `java.lang.IllegalArgumentException` - if `g` is a `GeometryCollection` but not one of its subclasses

### isGeometryCollection

    protected boolean isGeometryCollection()

  Tests whether this is an instance of a general `GeometryCollection`, rather than a homogeneous subclass.

  Returns:
    true if this is a hetereogeneous GeometryCollection

### computeEnvelopeInternal

    protected abstract Envelope computeEnvelopeInternal()

  Returns the minimum and maximum x and y values in this `Geometry` , or a null `Envelope` if this `Geometry` is empty. Unlike `getEnvelopeInternal`, this method calculates the `Envelope` each time it is called; `getEnvelopeInternal` caches the result of this method.

  Returns:
    this `Geometry`s bounding box; if the `Geometry` is empty, `Envelope#isNull` will return `true`

### compareToSameClass

    protected abstract int compareToSameClass(java.lang.Object o)

  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.

  Parameters:
    `o` - a `Geometry` having the same class as this `Geometry`
  Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications

### compareToSameClass

    protected abstract int compareToSameClass(java.lang.Object o,
                                              CoordinateSequenceComparator comp)

  Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` of the same class. using the given `CoordinateSequenceComparator`.

  Parameters:
    `o` - a `Geometry` having the same class as this `Geometry`
    `comp` - a `CoordinateSequenceComparator`
  Returns:
    a positive number, 0, or a negative number, depending on whether this object is greater than, equal to, or less than `o`, as defined in "Normal Form For Geometry" in the JTS Technical Specifications

### compare

    protected int compare(java.util.Collection a,
                          java.util.Collection b)

  Returns the first non-zero result of `compareTo` encountered as the two `Collection`s are iterated over. If, by the time one of the iterations is complete, no non-zero result has been encountered, returns 0 if the other iteration is also complete. If `b` completes before `a`, a positive number is returned; if a before b, a negative number.

  Parameters:
    `a` - a `Collection` of `Comparable`s
    `b` - a `Collection` of `Comparable`s
  Returns:
    the first non-zero `compareTo` result, if any; otherwise, zero

### equal

    protected boolean equal(Coordinate a,
                            Coordinate b,
                            double tolerance)

JTS Topology Suite version 1.13