public abstract class Geometry extends Object implements Cloneable, Comparable, Serializable
GeometryCollection
s would be useful,
GeometryCollection
s are not supported as arguments to binary
predicates or the relate
method.
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 settheoretic
methods involving GeometryCollection
s would be useful,
GeometryCollections
are not supported as arguments to the settheoretic methods.
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
Geometry
s returned from overlay methods. The canonical
form is a Geometry
which is simple and noded:
isSimple
.
LineString
s. It
means that all intersection points on LineString
s will be
present as endpoints of LineString
s in the result.
Geometry
s. These new points arise from intersections between line segments in the
edges of the input Geometry
s. In the general case it is not
possible to represent constructed points exactly. This is due to the fact
that the coordinates of an intersection point may contain twice as many bits
of precision as the coordinates of the input line segments. In order to
represent these constructed points explicitly, JTS must truncate them to fit
the PrecisionModel
. Unfortunately, truncating coordinates moves them slightly. Line segments which would not be coincident in the exact result may become coincident in the truncated representation. This in turn leads to "topology collapses"  situations where a computed element has a lower dimension than it would in the exact result.
When JTS detects topology collapses during the computation of spatial analysis methods, it will throw an exception. If possible the exception will report the location of the collapse.
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.
equalsTopo(Geometry)
method.
It implements the SFS definition of pointset equality
defined in terms of the DE9IM 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.
Modifier and Type  Field and Description 

static String 
TYPENAME_GEOMETRYCOLLECTION 
static String 
TYPENAME_LINEARRING 
static String 
TYPENAME_LINESTRING 
static String 
TYPENAME_MULTILINESTRING 
static String 
TYPENAME_MULTIPOINT 
static String 
TYPENAME_MULTIPOLYGON 
static String 
TYPENAME_POINT 
static String 
TYPENAME_POLYGON 
Constructor and Description 

Geometry(GeometryFactory factory)
Creates a new
Geometry via the specified GeometryFactory. 
Modifier and Type  Method and Description 

abstract void 
apply(CoordinateFilter filter)
Performs an operation with or on this
Geometry 's
coordinates. 
abstract void 
apply(CoordinateSequenceFilter filter)
Performs an operation on the coordinates in this
Geometry 's
CoordinateSequence s. 
abstract void 
apply(GeometryComponentFilter filter)
Performs an operation with or on this Geometry and its
component Geometry's.

abstract void 
apply(GeometryFilter filter)
Performs an operation with or on this
Geometry and its
subelement Geometry s (if any). 
Geometry 
buffer(double distance)
Computes a buffer area around this geometry having the given width.

Geometry 
buffer(double distance,
int quadrantSegments)
Computes a buffer area around this geometry having the given width and with
a specified accuracy of approximation for circular arcs.

Geometry 
buffer(double distance,
int quadrantSegments,
int endCapStyle)
Computes a buffer area around this geometry having the given
width and with a specified accuracy of approximation for circular arcs,
and using a specified end cap style.

Object 
clone()
Deprecated.

int 
compareTo(Object o)
Returns whether this
Geometry is greater than, equal to,
or less than another Geometry . 
int 
compareTo(Object o,
CoordinateSequenceComparator comp)
Returns whether this
Geometry is greater than, equal to,
or less than another Geometry ,
using the given CoordinateSequenceComparator . 
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 . 
Geometry 
copy()
Creates a deep copy of this
Geometry object. 
boolean 
coveredBy(Geometry g)
Tests whether this geometry is covered by the
argument geometry.

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

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

Geometry 
difference(Geometry other)
Computes a
Geometry representing the closure of the pointset
of the points contained in this Geometry that are not contained in
the other Geometry. 
boolean 
disjoint(Geometry g)
Tests whether this geometry is disjoint from the argument geometry.

double 
distance(Geometry g)
Returns the minimum distance between this
Geometry
and another Geometry . 
boolean 
equals(Geometry g)
Tests whether this geometry is
topologically equal to the argument geometry.

boolean 
equals(Object o)
Tests whether this geometry is structurally and numerically equal
to a given
Object . 
boolean 
equalsExact(Geometry other)
Returns true if the two
Geometry s are exactly equal. 
abstract boolean 
equalsExact(Geometry other,
double tolerance)
Returns true if the two
Geometry s are exactly equal,
up to a specified distance tolerance. 
boolean 
equalsNorm(Geometry g)
Tests whether two geometries are exactly equal
in their normalized forms.

boolean 
equalsTopo(Geometry g)
Tests whether this geometry is topologically equal to the argument geometry
as defined by the SFS
equals predicate. 
void 
geometryChanged()
Notifies this geometry that its coordinates have been changed by an external
party (for example, via a
CoordinateFilter ). 
double 
getArea()
Returns the area of this
Geometry . 
abstract Geometry 
getBoundary()
Returns the boundary, or an empty geometry of appropriate dimension
if this
Geometry is empty. 
abstract int 
getBoundaryDimension()
Returns the dimension of this
Geometry s inherent boundary. 
Point 
getCentroid()
Computes the centroid of this
Geometry . 
abstract Coordinate 
getCoordinate()
Returns a vertex of this
Geometry
(usually, but not necessarily, the first one). 
abstract Coordinate[] 
getCoordinates()
Returns an array containing the values of all the vertices for
this geometry.

abstract int 
getDimension()
Returns the dimension of this geometry.

Geometry 
getEnvelope()
Gets a Geometry representing the envelope (bounding box) of
this
Geometry . 
Envelope 
getEnvelopeInternal()
Gets an
Envelope containing
the minimum and maximum x and y values in this Geometry . 
GeometryFactory 
getFactory()
Gets the factory which contains the context in which this geometry was created.

Geometry 
getGeometryN(int n)
Returns an element
Geometry from a GeometryCollection
(or this , if the geometry is not a collection). 
abstract String 
getGeometryType()
Returns the name of this Geometry's actual class.

Point 
getInteriorPoint()
Computes an interior point of this
Geometry . 
double 
getLength()
Returns the length of this
Geometry . 
int 
getNumGeometries()
Returns the number of
Geometry s in a GeometryCollection
(or 1, if the geometry is not a collection). 
abstract int 
getNumPoints()
Returns the count of this
Geometry s vertices. 
PrecisionModel 
getPrecisionModel()
Returns the
PrecisionModel used by the Geometry . 
int 
getSRID()
Returns the ID of the Spatial Reference System used by the
Geometry . 
Object 
getUserData()
Gets the user data object for this geometry, if any.

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

Geometry 
intersection(Geometry other)
Computes a
Geometry representing the pointset which is
common to both this Geometry and the other Geometry. 
boolean 
intersects(Geometry g)
Tests whether this geometry intersects the argument geometry.

abstract boolean 
isEmpty()
Tests whether the set of points covered by this
Geometry is
empty. 
boolean 
isRectangle()
Tests whether this is a rectangular
Polygon . 
boolean 
isSimple()
Tests whether this
Geometry is simple. 
boolean 
isValid()
Tests whether this
Geometry
is topologically valid, according to the OGC SFS specification. 
boolean 
isWithinDistance(Geometry geom,
double distance)
Tests whether the distance from this
Geometry
to another is less than or equal to a specified value. 
Geometry 
norm()
Creates a new Geometry which is a normalized
copy of this Geometry.

abstract void 
normalize()
Converts this
Geometry to normal form (or
canonical form ). 
boolean 
overlaps(Geometry g)
Tests whether this geometry overlaps the
specified geometry.

IntersectionMatrix 
relate(Geometry g)
Returns the DE9IM
IntersectionMatrix for the two Geometry s. 
boolean 
relate(Geometry g,
String intersectionPattern)
Tests whether the elements in the DE9IM
IntersectionMatrix for the two Geometry s match the elements in intersectionPattern . 
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(Object userData)
A simple scheme for applications to add their own custom data to a Geometry.

Geometry 
symDifference(Geometry other)
Computes a
Geometry representing the closure of the pointset
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 . 
String 
toString() 
String 
toText()
Returns the Wellknown Text representation of this
Geometry . 
boolean 
touches(Geometry g)
Tests whether this geometry touches the
argument geometry.

Geometry 
union()
Computes the union of all the elements of this geometry.

Geometry 
union(Geometry other)
Computes a
Geometry representing the pointset
which is contained in both this
Geometry and the other Geometry. 
boolean 
within(Geometry g)
Tests whether this geometry is within the
specified geometry.

public static final String TYPENAME_POINT
public static final String TYPENAME_MULTIPOINT
public static final String TYPENAME_LINESTRING
public static final String TYPENAME_LINEARRING
public static final String TYPENAME_MULTILINESTRING
public static final String TYPENAME_POLYGON
public static final String TYPENAME_MULTIPOLYGON
public static final String TYPENAME_GEOMETRYCOLLECTION
public Geometry(GeometryFactory factory)
Geometry
via the specified GeometryFactory.factory
 public abstract String getGeometryType()
Geometry
s actual classpublic int getSRID()
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.
Geometry
is defined.public void setSRID(int SRID)
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.
GeometryFactory
public GeometryFactory getFactory()
public Object getUserData()
null
if none setpublic int getNumGeometries()
Geometry
s in a GeometryCollection
(or 1, if the geometry is not a collection).public Geometry getGeometryN(int n)
Geometry
from a GeometryCollection
(or this
, if the geometry is not a collection).n
 the index of the geometry elementpublic void setUserData(Object userData)
Note that user data objects are not present in geometries created by construction methods.
userData
 an object, the semantics for which are defined by the
application using this Geometrypublic PrecisionModel getPrecisionModel()
PrecisionModel
used by the Geometry
.Geometry
and all other Geometry
spublic abstract Coordinate getCoordinate()
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.Coordinate
which is a vertex of this Geometry
.public abstract Coordinate[] getCoordinates()
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.
Geometry
geometryChanged()
,
CoordinateSequence.setOrdinate(int, int, double)
public abstract int getNumPoints()
Geometry
s vertices. The Geometry
s contained by composite Geometry
s must be
Geometry's; that is, they must implement getNumPoints
Geometry
public boolean isSimple()
Geometry
is simple.
The SFS definition of simplicity
follows the general rule that a Geometry is simple if it has no points of
selftangency, selfintersection or other anomalous points.
Simplicity is defined for each Geometry
subclass as follows:
isSimple
tests for this condition and reports false
if it is not met.
(This is a looser test than checking for validity).
Geometry
s are always simple.
true
if this Geometry
is simpleisValid()
public boolean isValid()
Geometry
is topologically valid, according to the OGC SFS specification.
For validity rules see the Javadoc for the specific Geometry subclass.
true
if this Geometry
is validIsValidOp
public abstract boolean isEmpty()
Geometry
is
empty.true
if this Geometry
does not cover any pointspublic double distance(Geometry g)
Geometry
and another Geometry
.g
 the Geometry
from which to compute the distanceIllegalArgumentException
 if g is nullpublic boolean isWithinDistance(Geometry geom, double distance)
Geometry
to another is less than or equal to a specified value.geom
 the Geometry to check the distance todistance
 the distance value to comparetrue
if the geometries are less than distance
apart.public boolean isRectangle()
Polygon
.public double getArea()
Geometry
.
Areal Geometries have a nonzero area.
They override this function to compute the area.
Others return 0.0public double getLength()
Geometry
.
Linear geometries return their length.
Areal geometries return their perimeter.
They override this function to compute the area.
Others return 0.0public Point getCentroid()
Geometry
.
The centroid
is equal to the centroid of the set of component Geometries of highest
dimension (since the lowerdimension geometries contribute zero
"weight" to the centroid).
The centroid of an empty geometry is POINT EMPTY
.
Point
which is the centroid of this Geometrypublic Point getInteriorPoint()
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
.
Point
which is in the interior of this Geometrypublic abstract int getDimension()
Note that this is a different concept to the dimension of
the vertex Coordinate
s.
The geometry dimension can never be greater than the coordinate dimension.
For example, a 0dimensional geometry (e.g. a Point)
may have a coordinate dimension of 3 (X,Y,Z).
public abstract Geometry getBoundary()
Geometry
is empty.
(In the case of zerodimensional 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."Geometry
public abstract int getBoundaryDimension()
Geometry
s inherent boundary.Dimension.FALSE
if the boundary is the empty geometry.public Geometry getEnvelope()
Geometry
.
If this Geometry
is:
Point
.
Point
.
LineString
Polygon
whose vertices are (minx miny, minx maxy,
maxx maxy, maxx miny, minx miny).
GeometryFactory.toGeometry(Envelope)
public Envelope getEnvelopeInternal()
Envelope
containing
the minimum and maximum x and y values in this Geometry
.
If the geometry is empty, an empty Envelope
is returned.
The returned object is a copy of the one maintained internally, to avoid aliasing issues. For best performance, clients which access this envelope frequently should cache the return value.
Geometry
.public void geometryChanged()
CoordinateFilter
).
When this method is called the geometry will flush
and/or update any derived information it has cached (such as its Envelope
).
The operation is applied to all component Geometries.public boolean disjoint(Geometry g)
The disjoint
predicate has the following equivalent definitions:
[FF*FF****]
! g.intersects(this) = true
disjoint
is the inverse of intersects
)
g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s are
disjointintersects(org.locationtech.jts.geom.Geometry)
public boolean touches(Geometry g)
The touches
predicate has the following equivalent definitions:
[FT*******]
[F**T*****]
[F***T****]
false
,
since points have only interiors.
This predicate is symmetric.g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s touch;
Returns false
if both Geometry
s are pointspublic boolean intersects(Geometry g)
The intersects
predicate has the following equivalent definitions:
[T********]
[*T*******]
[***T*****]
[****T****]
! g.disjoint(this) = true
intersects
is the inverse of disjoint
)
g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s intersectdisjoint(org.locationtech.jts.geom.Geometry)
public boolean crosses(Geometry g)
The crosses
predicate has the following equivalent definitions:
[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)
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.
g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s cross.public boolean within(Geometry g)
The within
predicate has the following equivalent definitions:
[T*F**F***]
g.contains(this) = true
within
is the converse of contains(org.locationtech.jts.geom.Geometry)
)
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(org.locationtech.jts.geom.Geometry)
.g
 the Geometry
with which to compare this Geometry
true
if this Geometry
is within
g
contains(org.locationtech.jts.geom.Geometry)
,
coveredBy(org.locationtech.jts.geom.Geometry)
public boolean contains(Geometry g)
The contains
predicate has the following equivalent definitions:
[T*****FF*]
g.within(this) = true
contains
is the converse of within(org.locationtech.jts.geom.Geometry)
)
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(org.locationtech.jts.geom.Geometry)
.g
 the Geometry
with which to compare this Geometry
true
if this Geometry
contains g
within(org.locationtech.jts.geom.Geometry)
,
covers(org.locationtech.jts.geom.Geometry)
public boolean overlaps(Geometry g)
The overlaps
predicate has the following equivalent definitions:
[T*T***T**]
(for two points or two surfaces)
or [1*T***T**]
(for two curves)
false
.
This predicate is symmetric.g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s overlap.public boolean covers(Geometry g)
The covers
predicate has the following equivalent definitions:
[T*****FF*]
[*T****FF*]
[***T**FF*]
[****T*FF*]
g.coveredBy(this) = true
covers
is the converse of coveredBy(org.locationtech.jts.geom.Geometry)
)
false
.
This predicate is similar to contains(org.locationtech.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.
g
 the Geometry
with which to compare this Geometry
true
if this Geometry
covers g
contains(org.locationtech.jts.geom.Geometry)
,
coveredBy(org.locationtech.jts.geom.Geometry)
public boolean coveredBy(Geometry g)
The coveredBy
predicate has the following equivalent definitions:
[T*F**F***]
[*TF**F***]
[**FT*F***]
[**F*TF***]
g.covers(this) = true
coveredBy
is the converse of covers(org.locationtech.jts.geom.Geometry)
)
false
.
This predicate is similar to within(org.locationtech.jts.geom.Geometry)
,
but is more inclusive (i.e. returns true
for more cases).
g
 the Geometry
with which to compare this Geometry
true
if this Geometry
is covered by g
within(org.locationtech.jts.geom.Geometry)
,
covers(org.locationtech.jts.geom.Geometry)
public boolean relate(Geometry g, String intersectionPattern)
IntersectionMatrix
for the two Geometry
s match the elements in intersectionPattern
.
The pattern is a 9character string, with symbols drawn from the following set:
g
 the Geometry
with which to compare
this Geometry
intersectionPattern
 the pattern against which to check the
intersection matrix for the two Geometry
strue
if the DE9IM intersection
matrix for the two Geometry
s match intersectionPattern
IntersectionMatrix
public IntersectionMatrix relate(Geometry g)
IntersectionMatrix
for the two Geometry
s.g
 the Geometry
with which to compare this Geometry
IntersectionMatrix
describing the intersections of the interiors,
boundaries and exteriors of the two Geometry
spublic boolean equals(Geometry g)
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.
g
 the Geometry
with which to compare this Geometry
Geometry
s are topologically equalequalsTopo(Geometry)
public boolean equalsTopo(Geometry g)
equals
predicate.
The SFS equals
predicate has the following equivalent definitions:
T*F**FFF*
T*F **F FF*
equalsExact(Geometry)
.g
 the Geometry
with which to compare this Geometry
true
if the two Geometry
s are topologically equalequalsExact(Geometry)
public boolean equals(Object o)
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 valuebased object equality.
In conjunction with hashCode()
it provides semantics which are most useful
for using
Geometry
s as keys and values in Java collections.
Note that to produce the expected result the input geometries
should be in normal form. It is the caller's
responsibility to perform this where required
(using norm()
or normalize()
as appropriate).
equals
in class Object
o
 the Object to compareequalsExact(Geometry)
,
hashCode()
,
norm()
,
normalize()
public int hashCode()
public String toText()
Geometry
.
For a definition of the Wellknown Text format, see the OpenGIS Simple
Features Specification.Geometry
public Geometry buffer(double distance)
abs(distance)
.
Mathematicallyexact 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
zerodistance buffer of lines and points is always an empty Polygon
.
This is also the result for the buffers of degenerate (zeroarea) polygons.
distance
 the width of the buffer (may be positive, negative or 0)TopologyException
 if a robustness error occursbuffer(double, int)
,
buffer(double, int, int)
public Geometry buffer(double distance, int quadrantSegments)
Mathematicallyexact 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
zerodistance buffer of lines and points is always an empty Polygon
.
This is also the result for the buffers of degenerate (zeroarea) polygons.
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
circleTopologyException
 if a robustness error occursbuffer(double)
,
buffer(double, int, int)
public Geometry buffer(double distance, int quadrantSegments, int endCapStyle)
Mathematicallyexact buffer area boundaries can contain circular arcs.
To represent these arcs using linear geometry they must be approximated with line segments.
The quadrantSegments
argument allows controlling the
accuracy of the approximation
by specifying the number of line segments used to represent a quadrant of a circle
The end cap style specifies the buffer geometry that will be created at the ends of linestrings. The styles provided are:
BufferOp.CAP_ROUND
 (default) a semicircle
BufferOp.CAP_BUTT
 a straight line perpendicular to the end segment
BufferOp.CAP_SQUARE
 a halfsquare
The buffer operation always returns a polygonal result. The negative or
zerodistance buffer of lines and points is always an empty Polygon
.
This is also the result for the buffers of degenerate (zeroarea) polygons.
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 circleendCapStyle
 the end cap style to useTopologyException
 if a robustness error occursbuffer(double)
,
buffer(double, int)
,
BufferOp
public Geometry convexHull()
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 
Geometry
'
s pointspublic Geometry reverse()
public Geometry intersection(Geometry other)
Geometry
representing the pointset 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 heterogeneous GeometryCollection
.
If the result is empty, it is an atomic geometry
with the dimension of the lowest input dimension.
Intersection of GeometryCollection
s is supported
only for homogeneous collection types.
Nonempty heterogeneous GeometryCollection
arguments are not supported.
other
 the Geometry
with which to compute the intersectionGeometry
sTopologyException
 if a robustness error occursIllegalArgumentException
 if the argument is a nonempty heterogeneous GeometryCollection
public Geometry union(Geometry other)
Geometry
representing the pointset
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 heterogeneous
GeometryCollection
.
If the result is empty, it is an atomic geometry
with the dimension of the highest input dimension.
Unioning LineString
s has the effect of
noding and dissolving the input linework. In this context
"noding" means that there will be a node or endpoint in the result for
every endpoint or line segment crossing in the input. "Dissolving" means
that any duplicate (i.e. coincident) line segments or portions of line
segments will be reduced to a single line segment in the result.
If merged linework is required, the LineMerger
class can be used.
Nonempty GeometryCollection
arguments are not supported.
other
 the Geometry
with which to compute the unionGeometry
and the
points of other
TopologyException
 if a robustness error occursIllegalArgumentException
 if either input is a nonempty GeometryCollectionLineMerger
public Geometry difference(Geometry other)
Geometry
representing the closure of the pointset
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 lefthand input.
Nonempty GeometryCollection
arguments are not supported.
other
 the Geometry
with which to compute the
differenceGeometry
with
other
TopologyException
 if a robustness error occursIllegalArgumentException
 if either input is a nonempty GeometryCollectionpublic Geometry symDifference(Geometry other)
Geometry
representing the closure of the pointset
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.
Nonempty GeometryCollection
arguments are not supported.
other
 the Geometry
with which to compute the symmetric
differenceGeometry
with other
TopologyException
 if a robustness error occursIllegalArgumentException
 if either input is a nonempty GeometryCollectionpublic Geometry union()
This method supports
GeometryCollection
s
(which the other overlay operations currently do not).
The result obeys the following contract:
LineString
s has the effect of fully noding
and dissolving the linework.
Polygon
s always
returns a Polygonal
geometry (unlike union(Geometry)
,
which may return geometries of lower dimension if a topology collapse occurred).
TopologyException
 if a robustness error occursUnaryUnionOp
public abstract boolean equalsExact(Geometry other, double tolerance)
Geometry
s are exactly equal,
up to a specified distance tolerance.
Two Geometries are exactly equal within a distance tolerance
if and only if:
GeometryFactory
, the SRID
,
or the userData
fields.
To properly test equality between different geometries,
it is usually necessary to normalize()
them first.
other
 the Geometry
with which to compare this Geometry
tolerance
 distance at or below which two Coordinate
s
are considered equaltrue
if this and the other Geometry
have identical structure and point values, up to the distance tolerance.equalsExact(Geometry)
,
normalize()
,
norm()
public boolean equalsExact(Geometry other)
Geometry
s are exactly equal.
Two Geometries are exactly equal iff:
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.
other
 the Geometry
with which to compare this Geometry
true
if this and the other Geometry
have identical structure and point values.equalsExact(Geometry, double)
,
normalize()
,
norm()
public boolean equalsNorm(Geometry g)
equalsExact(Geometry)
.
This method is relatively expensive to compute. For maximum performance, the client should instead perform normalization on the individual geometries at an appropriate point during processing.
g
 a Geometrypublic abstract void apply(CoordinateFilter filter)
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).filter
 the filter to apply to this Geometry
's
coordinatespublic abstract void apply(CoordinateSequenceFilter filter)
Geometry
's
CoordinateSequence
s.
If the filter reports that a coordinate value has been changed,
geometryChanged()
will be called automatically.filter
 the filter to applypublic abstract void apply(GeometryFilter filter)
Geometry
and its
subelement Geometry
s (if any).
Only GeometryCollections and subclasses
have subelement Geometry's.filter
 the filter to apply to this Geometry
(and
its children, if it is a GeometryCollection
).public abstract void apply(GeometryComponentFilter filter)
filter
 the filter to apply to this Geometry
.public Object clone()
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.public Geometry copy()
Geometry
object.
Coordinate sequences contained in it are copied.
All instance fields are copied
(i.e. envelope
, SRID and userData).
NOTE: the userData object reference (if present) is copied, but the value itself is not copied. If a deep copy is required this must be performed by the caller.
public abstract void normalize()
Geometry
to normal form (or
canonical form ). Normal form is a unique representation for Geometry
s. It can be used to test whether two Geometry
s are equal
in a way that is independent of the ordering of the coordinates within
them. Normal form equality is a stronger condition than topological
equality, but weaker than pointwise equality. The definitions for normal
form use the standard lexicographical ordering for coordinates. "Sorted in
order of coordinates" means the obvious extension of this ordering to
sequences of coordinates.
NOTE that this method mutates the value of this geometry inplace. If this is not safe and/or wanted, the geometry should be cloned prior to normalization.
public Geometry norm()
normalize()
public int compareTo(Object o)
Geometry
is greater than, equal to,
or less than another Geometry
. If their classes are different, they are compared using the following ordering:
Geometry
s have the same class, their first
elements are compared. If those are the same, the second elements are
compared, etc.compareTo
in interface Comparable
o
 a Geometry
with which to compare this Geometry
o
, as
defined in "Normal Form For Geometry" in the JTS Technical
Specificationspublic int compareTo(Object o, CoordinateSequenceComparator comp)
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:
Geometry
s have the same class, their first
elements are compared. If those are the same, the second elements are
compared, etc.o
 a Geometry
with which to compare this Geometry
comp
 a CoordinateSequenceComparator
o
, as
defined in "Normal Form For Geometry" in the JTS Technical
SpecificationsCopyright © 2020. All rights reserved.