JTS Topology Suite version 1.12

com.vividsolutions.jts.geom
Class Geometry

java.lang.Object
  extended by 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 GeometryCollections would be useful, GeometryCollections are not supported as arguments to binary predicates (other than convexHull) 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 will use a canonical form for Geometrys returned from spatial analysis methods. The canonical form is a Geometry which is simple and noded:

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

JTS provides 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 implements the SFS definition of point-set equality defined in terms of the DE-9IM matrix. It is is provided by the equalsTopo(Geometry) method. 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(Geometry) 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 CoordinateSequences.
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 Geometrys (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 Collections 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 points making up this Geometry that do not make up other.
 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 the Geometry g
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 Geometrys are exactly equal.
abstract  boolean equalsExact(Geometry other, double tolerance)
          Returns true if the two Geometrys 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 Geometrys 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()
          Returns this Geometrys bounding box.
 Envelope getEnvelopeInternal()
          Returns the minimum and maximum x and y values in this Geometry , or a null Envelope if this Geometry is empty.
 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 object's com.vivid.jts.geom interface.
 Point getInteriorPoint()
          Computes an interior point of this Geometry.
 double getLength()
          Returns the length of this Geometry.
 int getNumGeometries()
          Returns the number of Geometrys in a GeometryCollection (or 1, if the geometry is not a collection).
abstract  int getNumPoints()
          Returns the count of this Geometrys 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()
           
protected static boolean hasNonEmptyElements(Geometry[] geometries)
          Returns true if the array contains any non-empty Geometrys.
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 points shared by this Geometry and other.
 boolean intersects(Geometry g)
          Tests whether this geometry intersects the argument geometry.
abstract  boolean isEmpty()
          Returns whether or not the set of points in this Geometry is empty.
protected  boolean isEquivalentClass(Geometry other)
          Returns whether the two Geometrys are equal, from the point of view of the equalsExact method.
protected  boolean isGeometryCollection(Geometry g)
           
 boolean isRectangle()
           
 boolean isSimple()
          Tests whether this Geometry is simple.
 boolean isValid()
          Tests the validity of this Geometry.
 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 Geometrys.
 boolean relate(Geometry g, java.lang.String intersectionPattern)
          Tests whether the elements in the DE-9IM IntersectionMatrix for the two Geometrys 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)
          Returns a set combining the points in this Geometry not in other, and the points in other not 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 all the points in this Geometry and other.
 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 object's com.vivid.jts.geom interface.

Returns:
the name of this Geometrys most specific com.vividsolutions.jts.geom interface

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(java.lang.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

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 Geometrys 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 Geometrys

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 Geometrys vertices. The Geometry s contained by composite Geometrys 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. In general, the SFS specification of simplicity follows the rule: Simplicity is defined for each Geometry subclass as follows:

isValid

public boolean isValid()
Tests the validity of this Geometry. Subclasses provide their own definition of "valid".

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

isEmpty

public abstract boolean isEmpty()
Returns whether or not the set of points in this Geometry is empty.

Returns:
true if this Geometry equals the empty geometry

distance

public double distance(Geometry g)
Returns the minimum distance between this Geometry and the Geometry g

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)

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.

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 Coordinates. 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 Geometrys 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()
Returns this Geometrys bounding box. If this Geometry is the empty geometry, returns an empty Point. If the Geometry is a point, returns a non-empty Point. Otherwise, returns a Polygon whose points are (minx, miny), (maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny).

Returns:
an empty Point (for empty Geometrys), a Point (for Points) or a Polygon (in all other cases)

getEnvelopeInternal

public Envelope getEnvelopeInternal()
Returns the minimum and maximum x and y values in this Geometry , or a null Envelope if this Geometry is empty.

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

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


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:

Parameters:
g - the Geometry with which to compare this Geometry
Returns:
true if the two Geometrys 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:

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 Geometrys touch; Returns false if both Geometrys are points

intersects

public boolean intersects(Geometry g)
Tests whether this geometry intersects the argument geometry.

The intersects predicate has the following equivalent definitions:

Parameters:
g - the Geometry with which to compare this Geometry
Returns:
true if the two Geometrys 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:

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 Geometrys cross.

within

public boolean within(Geometry g)
Tests whether this geometry is within the specified geometry.

The within predicate has the following equivalent definitions:

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:

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:

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 Geometrys overlap.

covers

public boolean covers(Geometry g)
Tests whether this geometry covers the argument geometry.

The covers predicate has the following equivalent definitions:

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:

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 Geometrys match the elements in intersectionPattern. The pattern is a 9-character string, with symbols drawn from the following set: 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 Geometrys
Returns:
true if the DE-9IM intersection matrix for the two Geometrys match intersectionPattern
See Also:
IntersectionMatrix

relate

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

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

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 Geometrys 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:

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

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()
Overrides:
hashCode in class java.lang.Object

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:

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 Points 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 points shared by this Geometry and other.

Intersection of GeometryCollections is supported only for homogeneous collection types. The result is a GeometryCollection of the intersection of each element of the target with the argument.

The intersection of two geometries of different dimension produces a result geometry of dimension equal to the minimum dimension of the input geometries. The result geometry is always a homogeneous GeometryCollection.

Parameters:
other - the Geometry with which to compute the intersection
Returns:
the point-set common to the two Geometrys
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 all the points in this Geometry and other.

The method may be used on arguments of different dimension, but it does not support GeometryCollection arguments.

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.

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.

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 points making up this Geometry that do not make up other. This method returns the closure of the resultant Geometry.

Parameters:
other - the Geometry with which to compute the difference
Returns:
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)
Returns a set combining the points in this Geometry not in other, and the points in other not in this Geometry. This method returns the closure of the resultant Geometry.

Parameters:
other - the Geometry with which to compute the symmetric difference
Returns:
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 GeometryCollections (which the other overlay operations currently do not).

The result obeys the following contract:

Returns:
the union geometry
See Also:
UnaryUnionOp

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: 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 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:
equalsExact(Geometry), normalize(), norm()

equalsExact

public boolean equalsExact(Geometry other)
Returns true if the two Geometrys are exactly equal. Two Geometries are exactly equal iff: 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 itself at an appropriate point during execution.

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 CoordinateSequences. 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 Geometrys (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 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.

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:

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

If the two Geometrys 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 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.

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(Geometry g)

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 Geometrys 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 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

equal

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

JTS Topology Suite version 1.12