AbstractGeometry (RS Core TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.jts.geom.impl.AbstractGeometry

All Implemented Interfaces:

DataTypeProxy, Geometry, Serializable, Cloneable, Comparable<Object>

Direct Known Subclasses:

AbstractGeometryCollection, AbstractLineString, AbstractPoint, AbstractPolygon
```
public abstract class AbstractGeometry
extends Object
implements Geometry
```
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 GeometryCollections would be useful, GeometryCollections 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 GeometryCollections 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 uses a canonical form for Geometrys returned from overlay 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 LineStrings. It means that all intersection points on LineStrings will be present as endpoints of LineStrings 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 Point 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 Geometrys. 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 equals(2,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
- Fields inherited from interface com.revolsys.jts.geom.Geometry
  M, X, Y, Z

Constructor Summary

Constructors
Constructor and Description

AbstractGeometry()

Constructors
Constructor and Description
`AbstractGeometry()`

Method Summary

Methods
Modifier and Type	Method and Description
`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 geometry)` Throws an exception if `g`'s class is `GeometryCollection` .
`AbstractGeometry`	`clone()` Creates and returns a full copy of this `Geometry` object (including all coordinates contained by it).
`protected int`	`compare(Collection a, Collection b)` Returns the first non-zero result of `compareTo` encountered as the two `Collection`s are iterated over.
`int`	`compareTo(Object other)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry`.
`abstract int`	`compareToSameClass(Geometry o)` Returns whether this `Geometry` is greater than, equal to, or less than another `Geometry` having the same class.
`protected abstract BoundingBox`	`computeBoundingBox()` Returns the minimum and maximum x and y values in this `Geometry` , or a null `BoundingBoxDoubleGf` if this `Geometry` is empty.
`boolean`	`contains(Geometry g)` Tests whether this geometry contains the argument geometry.
`boolean`	`containsProperly(Geometry geometry)`
`<V extends Geometry> V`	`convert(GeometryFactory geometryFactory)` Convert the geometry to the requried geometry factory.
`<V extends Geometry> V`	`convert(GeometryFactory geometryFactory, int axisCount)`
`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.
`static int[]`	`createVertexId(int[] partId, int vertexIndex)`
`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 geometry)` Returns the minimum distance between this `Geometry` and another `Geometry`.
`protected abstract boolean`	`doEquals(int axisCount, Geometry geometry)`
`boolean`	`envelopeCovers(Geometry geometry)`
`boolean`	`envelopesIntersect(Geometry geometry)`
`boolean`	`equal(Point a, Point b, double tolerance)`
`boolean`	`equals(Geometry g)` Tests whether this geometry is topologically equal to the argument geometry.
`boolean`	`equals(int axisCount, Geometry geometry)`
`boolean`	`equals(Object other)` Tests whether this geometry is structurally and numerically equal to a given `Object`.
`boolean`	`equalsExact(Geometry geometry)`
`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.
`Iterable<Geometry>`	`geometries()`
`double`	`getArea()` Returns the area of this `Geometry`.
`int`	`getAxisCount()`
`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.
`BoundingBox`	`getBoundingBox()` Gets an `BoundingBoxDoubleGf` containing the minimum and maximum x and y values in this `Geometry`.
`Point`	`getCentroid()` Computes the centroid of this `Geometry`.
`int`	`getClassSortIndex()`
`CoordinateSystem`	`getCoordinateSystem()`
`DataType`	`getDataType()`
`abstract int`	`getDimension()` Returns the dimension of this geometry.
`Geometry`	`getEnvelope()` Gets a Geometry representing the boundingBox (bounding box) of this `Geometry`.
`<V extends Geometry> List<V>`	`getGeometries()`
`<V extends Geometry> List<V>`	`getGeometries(Class<V> geometryClass)`
`<V extends Geometry> V`	`getGeometry(int partIndex)` Returns an element `Geometry` from a `GeometryCollection` (or `this`, if the geometry is not a collection).
`<V extends Geometry> List<V>`	`getGeometryComponents(Class<V> geometryClass)` Differs from `Geometry.getGeometries(Class)` in that it will return matching `Polygon.rings()`
`int`	`getGeometryCount()` Returns the number of `Geometry`s in a `GeometryCollection` (or 1, if the geometry is not a collection).
`GeometryFactory`	`getGeometryFactory()` Gets the geometryFactory which contains the context in which this geometry was created.
`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`.
`protected GeometryFactory`	`getNonZeroGeometryFactory(GeometryFactory geometryFactory)`
`abstract Point`	`getPoint()` Returns a vertex of this `Geometry` (usually, but not necessarily, the first one).
`int`	`getSrid()` Returns the ID of the Spatial Reference System used by the `Geometry`.
`Object`	`getUserData()` Gets the user data object for this geometry, if any.
`static int`	`getVertexIndex(int[] index)`
`int`	`hashCode()` Gets a hash code for the Geometry.
`boolean`	`hasInvalidXyCoordinates()`
`protected static boolean`	`hasNonEmptyElements(Geometry... geometries)` Returns true if the array contains any non-empty `Geometry`s.
`protected static boolean`	`hasNullElements(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.
`protected boolean`	`isAnyTargetComponentInTest(Geometry testGeom)` Tests whether any representative of the target geometry intersects the test 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.
`abstract Geometry`	`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, 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`	`setUserData(Object userData)` A simple scheme for applications to add their own custom data to a Geometry.
`static int[]`	`setVertexIndex(int[] vertexId, int vertexIndex)`
`Geometry`	`symDifference(Geometry other)` Computes a 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`.
`<G extends Geometry> G`	`toClockwise()`
`<G extends Geometry> G`	`toCounterClockwise()`
`String`	`toString()`
`boolean`	`touches(Geometry g)` Tests whether this geometry touches the argument geometry.
`String`	`toWkt()` Returns the Extended Well-known Text representation of this `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

Methods inherited from interface com.revolsys.jts.geom.Geometry
appendVertex, copy, deleteVertex, getPointWithin, getSegment, getToVertex, getVertex, getVertexCount, insertVertex, intersects, move, moveVertex, prepare, segments, vertices

Constructor Detail
- AbstractGeometry
```
public AbstractGeometry()
```

Method Detail

createVertexId

public static int[] createVertexId(int[] partId,
                   int vertexIndex)

getVertexIndex

public static int getVertexIndex(int[] index)

hasNonEmptyElements
```
protected static boolean hasNonEmptyElements(Geometry... geometries)
```
Returns true if the array contains any non-empty Geometrys.

Parameters:
geometries - an array of Geometrys; no elements may be null

Returns:
true if any of the Geometrys isEmpty methods return false

hasNullElements
```
protected static boolean hasNullElements(Object[] array)
```
Returns true if the array contains any null elements.

Parameters:
array - an array to validate

Returns:
true if any of arrays elements are null

setVertexIndex

public static int[] setVertexIndex(int[] vertexId,
                   int vertexIndex)

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.

Specified by:

buffer in interface Geometry

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.

Specified by:

buffer in interface Geometry

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:
- Buffer.CAP_ROUND - (default) a semi-circle
- Buffer.CAP_BUTT - a straight line perpendicular to the end segment
- Buffer.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.
Specified by:

buffer in interface Geometry

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), Buffer

checkNotGeometryCollection
```
protected void checkNotGeometryCollection(Geometry geometry)
```
Throws an exception if g's class is GeometryCollection . (Its subclasses do not trigger an exception).

Parameters:
geometry - the Geometry to check

Throws:

IllegalArgumentException - if g is a GeometryCollection but not one of its subclasses

clone
```
public AbstractGeometry 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.

Specified by:

clone in interface Geometry

Overrides:

clone in class Object

Returns:
a clone of this instance

compare
```
protected int compare(Collection a,
          Collection b)
```
Returns the first non-zero result of compareTo encountered as the two Collections 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 Comparables
b - a Collection of Comparables

Returns:
the first non-zero compareTo result, if any; otherwise, zero

compareTo
```
public int compareTo(Object other)
```
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 Geometrys 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 Geometry

Specified by:

compareTo in interface Comparable<Object>

Parameters:
other - 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

compareToSameClass
```
public abstract int compareToSameClass(Geometry o)
```
Returns whether this Geometry is greater than, equal to, or less than another Geometry having the same class.

Specified by:

compareToSameClass in interface Geometry

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

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

Returns:
this Geometrys bounding box; if the Geometry is empty, BoundingBoxDoubleGf#isNull will return true

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.revolsys.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.revolsys.jts.geom.Geometry).
Specified by:

contains in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if this Geometry contains g
See Also:
Geometry.within(com.revolsys.jts.geom.Geometry), Geometry.covers(com.revolsys.jts.geom.Geometry)

containsProperly
```
public boolean containsProperly(Geometry geometry)
```
Specified by:

containsProperly in interface Geometry

convert
```
public <V extends Geometry> V convert(GeometryFactory geometryFactory)
```
Description copied from interface: Geometry

Convert the geometry to the requried geometry factory. Projecting to the required coordinate system and applying the precision model. If the geometry factory is the same as this geometries factory then the geometry will be returned.

Specified by:

convert in interface Geometry

Parameters:
geometryFactory - The geometry factory to convert the geometry to.

Returns:
The converted geometry

convert

public <V extends Geometry> V convert(GeometryFactory geometryFactory,
                             int axisCount)

Specified by:: convert in interface Geometry

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`

Specified by:: convexHull in interface Geometry
Returns:: the minimum-area convex polygon containing this Geometry' s points

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.revolsys.jts.geom.Geometry))
If either geometry is empty, the value of this predicate is false.
This predicate is similar to within(com.revolsys.jts.geom.Geometry), but is more inclusive (i.e. returns true for more cases).
Specified by:

coveredBy in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if this Geometry is covered by g
See Also:
Geometry.within(com.revolsys.jts.geom.Geometry), Geometry.covers(com.revolsys.jts.geom.Geometry)

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.revolsys.jts.geom.Geometry))
If either geometry is empty, the value of this predicate is false.
This predicate is similar to contains(com.revolsys.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.
Specified by:

covers in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if this Geometry covers g
See Also:
Geometry.contains(com.revolsys.jts.geom.Geometry), Geometry.coveredBy(com.revolsys.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.
Specified by:

crosses in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys cross.

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.

Specified by:

difference in interface Geometry

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

IllegalArgumentException - if either input is a non-empty GeometryCollection

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)
Specified by:

disjoint in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys are disjoint
See Also:
Geometry.intersects(com.revolsys.jts.geom.BoundingBox)

distance
```
public double distance(Geometry geometry)
```
Returns the minimum distance between this Geometry and another Geometry.

Specified by:

distance in interface Geometry

Parameters:
geometry - the Geometry from which to compute the distance

Returns:
the distance between the geometries

Throws:

IllegalArgumentException - if g is null

doEquals

protected abstract boolean doEquals(int axisCount,
               Geometry geometry)

envelopeCovers

public boolean envelopeCovers(Geometry geometry)

envelopesIntersect

public boolean envelopesIntersect(Geometry geometry)

equal

public boolean equal(Point a,
            Point b,
            double tolerance)

Specified by:: equal in interface Geometry

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.

Specified by:

equals in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys are topologically equal
See Also:
equalsTopo(Geometry)

equals

public boolean equals(int axisCount,
             Geometry geometry)

Specified by:: equals in interface Geometry

equals
```
public boolean equals(Object other)
```
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 equals(2,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 Geometrys 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).

Specified by:

equals in interface Geometry

Overrides:

equals in class Object

Parameters:
other - the Object to compare

Returns:
true if this geometry is exactly equal to the argument
See Also:
equals(2,Geometry), hashCode(), #norm(), normalize()

equalsExact
```
public boolean equalsExact(Geometry geometry)
```
Specified by:

equalsExact in interface Geometry

equalsExact
```
public abstract boolean equalsExact(Geometry other,
                  double tolerance)
```
Returns true if the two Geometrys 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.
Specified by:

equalsExact in interface Geometry

Parameters:
other - the Geometry with which to compare this Geometry
tolerance - distance at or below which two Coordinates are considered equal

Returns:
true if this and the other Geometry have identical structure and point values, up to the distance tolerance.
See Also:
equals(2,Geometry), 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 equals(2,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.

Specified by:

equalsNorm in interface Geometry

Parameters:
g - a Geometry

Returns:
true if the input geometries are exactly equal in their normalized form

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 equals(2,Geometry).
Specified by:

equalsTopo in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys are topologically equal
See Also:
equals(2,Geometry)

geometries
```
public Iterable<Geometry> geometries()
```
Specified by:

geometries in interface Geometry

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

Specified by:

getArea in interface Geometry

Returns:
the area of the Geometry

getAxisCount
```
public int getAxisCount()
```
Specified by:

getAxisCount in interface 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."

Specified by:

getBoundary in interface Geometry

Returns:
the closure of the combinatorial boundary of this Geometry

getBoundaryDimension
```
public abstract int getBoundaryDimension()
```
Returns the dimension of this Geometrys inherent boundary.

Specified by:

getBoundaryDimension in interface Geometry

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.

getBoundingBox
```
public BoundingBox getBoundingBox()
```
Gets an BoundingBoxDoubleGf containing the minimum and maximum x and y values in this Geometry. If the geometry is empty, an empty BoundingBoxDoubleGf is returned.
The returned object is a copy of the one maintained internally, to avoid aliasing issues. For best performance, clients which access this boundingBox frequently should cache the return value.

Specified by:

getBoundingBox in interface Geometry

Returns:
the boundingBox of this 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.

Specified by:

getCentroid in interface Geometry

Returns:
a Point which is the centroid of this Geometry

getClassSortIndex
```
public int getClassSortIndex()
```
Specified by:

getClassSortIndex in interface Geometry

getCoordinateSystem
```
public CoordinateSystem getCoordinateSystem()
```
Specified by:

getCoordinateSystem in interface Geometry

Returns:

getDataType
```
public DataType getDataType()
```
Specified by:

getDataType in interface DataTypeProxy

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 Coordinatess. 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).

Specified by:

getDimension in interface Geometry

Returns:
the topological dimension of this geometry.

getEnvelope
```
public Geometry getEnvelope()
```
Gets a Geometry representing the boundingBox (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).
Specified by:

getEnvelope in interface Geometry

Returns:
a Geometry representing the boundingBox of this Geometry
See Also:
GeometryFactory#toLineString(BoundingBoxDoubleGf)

getGeometries
```
public <V extends Geometry> List<V> getGeometries()
```
Specified by:

getGeometries in interface Geometry

getGeometries

public <V extends Geometry> List<V> getGeometries(Class<V> geometryClass)

Specified by:: getGeometries in interface Geometry

getGeometry
```
public <V extends Geometry> V getGeometry(int partIndex)
```
Returns an element Geometry from a GeometryCollection (or this, if the geometry is not a collection).

Specified by:

getGeometry in interface Geometry

Parameters:
partIndex - the index of the geometry element

Returns:
the n'th geometry contained in this geometry

getGeometryComponents
```
public <V extends Geometry> List<V> getGeometryComponents(Class<V> geometryClass)
```
Description copied from interface: Geometry

Differs from Geometry.getGeometries(Class) in that it will return matching Polygon.rings()

Specified by:

getGeometryComponents in interface Geometry

Returns:

getGeometryCount
```
public int getGeometryCount()
```
Returns the number of Geometrys in a GeometryCollection (or 1, if the geometry is not a collection).

Specified by:

getGeometryCount in interface Geometry

Returns:
the number of geometries contained in this geometry

getGeometryFactory
```
public GeometryFactory getGeometryFactory()
```
Description copied from interface: Geometry

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

Specified by:

getGeometryFactory in interface Geometry

Returns:

getGeometryType
```
public String getGeometryType()
```
Returns the name of this Geometry's actual class.

Specified by:

getGeometryType in interface Geometry

Returns:
the name of this Geometrys actual class

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.

Specified by:

getInteriorPoint in interface Geometry

Returns:
a Point which is in the interior of this 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

Specified by:

getLength in interface Geometry

Returns:
the length of the Geometry

getNonZeroGeometryFactory

protected GeometryFactory getNonZeroGeometryFactory(GeometryFactory geometryFactory)

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

Specified by:

getPoint in interface Geometry

Returns:
a Coordinates which is a vertex of this Geometry.

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.

Specified by:

getSrid in interface Geometry

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

getUserData
```
public Object getUserData()
```
Gets the user data object for this geometry, if any.

Specified by:

getUserData in interface Geometry

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

hashCode
```
public int hashCode()
```
Gets a hash code for the Geometry.

Specified by:

hashCode in interface Geometry

Overrides:

hashCode in class Object

Returns:
an integer value suitable for use as a hashcode

hasInvalidXyCoordinates
```
public boolean hasInvalidXyCoordinates()
```
Specified by:

hasInvalidXyCoordinates in interface 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 GeometryCollections is supported only for homogeneous collection types.
Non-empty heterogeneous GeometryCollection arguments are not supported.

Specified by:

intersection in interface Geometry

Parameters:
other - the Geometry with which to compute the intersection

Returns:
a Geometry representing the point-set common to the two Geometrys

Throws:

TopologyException - if a robustness error occurs

IllegalArgumentException - if the argument is a non-empty heterogeneous GeometryCollection

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)
Specified by:

intersects in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys intersect
See Also:
Geometry.disjoint(com.revolsys.jts.geom.Geometry)

isAnyTargetComponentInTest
```
protected boolean isAnyTargetComponentInTest(Geometry testGeom)
```
Tests whether any representative of the target geometry intersects the test geometry. This is useful in A/A, A/L, A/P, L/P, and P/P cases.

Parameters:
geom - the test geometry
repPts - the representative points of the target geometry

Returns:
true if any component intersects the areal test geometry

isEmpty
```
public abstract boolean isEmpty()
```
Tests whether the set of points covered by this Geometry is empty.

Specified by:

isEmpty in interface Geometry

Returns:
true if this Geometry does not cover any points

isEquivalentClass
```
protected boolean isEquivalentClass(Geometry other)
```
Returns whether the two Geometrys 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.

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

isRectangle
```
public boolean isRectangle()
```
Specified by:

isRectangle in interface 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 Geometrys are always simple.
Specified by:

isSimple in interface Geometry

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.

Specified by:

isValid in interface Geometry

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

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.

Specified by:

isWithinDistance in interface Geometry

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.

normalize
```
public abstract Geometry 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 Geometrys 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.

Specified by:

normalize in interface Geometry

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

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. This predicate is symmetric.
Specified by:

overlaps in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys overlap.

relate
```
public IntersectionMatrix relate(Geometry g)
```
Returns the DE-9IM IntersectionMatrix for the two Geometrys.

Specified by:

relate in interface Geometry

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 Geometrys

relate
```
public boolean relate(Geometry g,
             String intersectionPattern)
```
Tests whether the elements in the DE-9IM IntersectionMatrix for the two Geometrys 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.
Specified by:

relate in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry
intersectionPattern - the pattern against which to check the intersection matrix for the two Geometrys

Returns:
true if the DE-9IM intersection matrix for the two Geometrys match intersectionPattern
See Also:
IntersectionMatrix

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

Specified by:

reverse in interface Geometry

Returns:
a reversed geometry

setUserData
```
public void setUserData(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 Point Reference System.
Note that user data objects are not present in geometries created by construction methods.

Specified by:

setUserData in interface Geometry

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

symDifference
```
public Geometry symDifference(Geometry other)
```
Computes a 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.

Specified by:

symDifference in interface Geometry

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

IllegalArgumentException - if either input is a non-empty GeometryCollection

toClockwise
```
public <G extends Geometry> G toClockwise()
```
Specified by:

toClockwise in interface Geometry

toCounterClockwise
```
public <G extends Geometry> G toCounterClockwise()
```
Specified by:

toCounterClockwise in interface Geometry

toString
```
public String toString()
```
Overrides:

toString in class Object

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, the predicate returns false, since points have only interiors. This predicate is symmetric.
Specified by:

touches in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if the two Geometrys touch; Returns false if both Geometrys are points

toWkt
```
public String toWkt()
```
Returns the Extended Well-known Text representation of this Geometry. For a definition of the Well-known Text format, see the OpenGIS Simple Features Specification.

Specified by:

toWkt in interface Geometry

Returns:
the Well-known Text representation of this Geometry

union
```
public Geometry union()
```
Computes the union of all the elements of this geometry.
This method supports GeometryCollections (which the other overlay operations currently do not).
The result obeys the following contract:
- Unioning a set of LineStrings has the effect of fully noding and dissolving the linework.
- Unioning a set of Polygons always returns a Polygonal geometry (unlike union(Geometry), which may return geometries of lower dimension if a topology collapse occurred).
Specified by:

union in interface Geometry

Returns:
the union geometry

Throws:

TopologyException - if a robustness error occurs
See Also:
UnaryUnionOp

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 LineStrings 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.

Specified by:

union in interface Geometry

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

IllegalArgumentException - if either input is a non-empty GeometryCollection
See Also:
LineMerger

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.revolsys.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.revolsys.jts.geom.Geometry).
Specified by:

within in interface Geometry

Parameters:
g - the Geometry with which to compare this Geometry

Returns:
true if this Geometry is within g
See Also:
Geometry.contains(com.revolsys.jts.geom.Geometry), Geometry.coveredBy(com.revolsys.jts.geom.Geometry)

Class AbstractGeometry

Binary Predicates

Overlay Methods

Representation of Computed Geometries

Constructed Point And The Precision Model

Geometry Equality

Structural Equality

Topological Equality

Field Summary

Fields inherited from interface com.revolsys.jts.geom.Geometry

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.revolsys.jts.geom.Geometry

Constructor Detail

AbstractGeometry

Method Detail

createVertexId

getVertexIndex

hasNonEmptyElements

hasNullElements

setVertexIndex

buffer

buffer

buffer

checkNotGeometryCollection

clone

compare

compareTo

compareToSameClass

computeBoundingBox

contains

containsProperly

convert

convert

convexHull

coveredBy

covers

crosses

difference

disjoint

distance

doEquals

envelopeCovers

envelopesIntersect

equal

equals

equals

equals

equalsExact

equalsExact

equalsNorm

equalsTopo

geometries

getArea

getAxisCount

getBoundary

getBoundaryDimension

getBoundingBox

getCentroid

getClassSortIndex

getCoordinateSystem

getDataType

getDimension

getEnvelope

getGeometries

getGeometries

getGeometry

getGeometryComponents

getGeometryCount

getGeometryFactory

getGeometryType

getInteriorPoint

getLength

getNonZeroGeometryFactory

getPoint

getSrid

getUserData

hashCode

hasInvalidXyCoordinates