public interface RelatePredicate
RelateNG.| Modifier and Type | Method and Description |
|---|---|
static TopologyPredicate |
contains()
Creates a predicate to determine whether a geometry contains another geometry.
|
static TopologyPredicate |
coveredBy()
Creates a predicate to determine whether a geometry is covered by another geometry.
|
static TopologyPredicate |
covers()
Creates a predicate to determine whether a geometry covers another geometry.
|
static TopologyPredicate |
crosses()
Creates a predicate to determine whether a geometry crosses another geometry.
|
static TopologyPredicate |
disjoint()
Creates a predicate to determine whether two geometries are disjoint.
|
static TopologyPredicate |
equalsTopo()
Creates a predicate to determine whether two geometries are topologically equal.
|
static TopologyPredicate |
intersects()
Creates a predicate to determine whether two geometries intersect.
|
static TopologyPredicate |
matches(String imPattern)
Creates a predicate that matches a DE-9IM matrix pattern.
|
static TopologyPredicate |
overlaps()
Creates a predicate to determine whether a geometry overlaps another geometry.
|
static TopologyPredicate |
touches()
Creates a predicate to determine whether a geometry touches another geometry.
|
static TopologyPredicate |
within()
Creates a predicate to determine whether a geometry is within another geometry.
|
static TopologyPredicate intersects()
The intersects predicate has the following equivalent definitions:
[T********]
[*T*******]
[***T*****]
[****T****]
disjoint() = false
intersects is the inverse of disjoint)
disjoint()static TopologyPredicate disjoint()
The disjoint predicate has the following equivalent definitions:
[FF*FF****]
intersects() = false
disjoint is the inverse of intersects)
intersects()static TopologyPredicate contains()
The contains predicate has the following equivalent definitions:
[T*****FF*]
within(B, A) = true
contains is the converse of within() )
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 behavior but avoiding
this subtle limitation, see covers().within()static TopologyPredicate within()
The within predicate has the following equivalent definitions:
[T*F**F***]
contains(B, A) = true
within is the converse of contains())
within(B, 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 behavior but avoiding
this subtle limitation, see coveredBy().contains()static TopologyPredicate covers()
The covers predicate has the following equivalent definitions:
[T*****FF*]
[*T****FF*]
[***T**FF*]
[****T*FF*]
coveredBy(b, a) = true
covers is the converse of coveredBy())
false.
This predicate is similar to contains(),
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 cases, covers should be used in preference to contains.
As an added benefit, covers is more amenable to optimization,
and hence should be more performant.
coveredBy()static TopologyPredicate coveredBy()
The coveredBy predicate has the following equivalent definitions:
[T*F**F***]
[*TF**F***]
[**FT*F***]
[**F*TF***]
covers(B, A) = true
coveredBy is the converse of covers())
false.
This predicate is similar to within(),
but is more inclusive (i.e. returns true for more cases).
covers()static TopologyPredicate crosses()
The crosses predicate has the following equivalent definitions:
[T*T******] (for P/L, P/A, and L/A cases)
[T*****T**] (for L/P, A/P, and A/L cases)
[0********] (for L/L cases)
false.
The SFS defined this predicate only for P/L, P/A, L/L, and L/A cases. To make the relation symmetric JTS extends the definition to apply to L/P, A/P and A/L cases as well.
static TopologyPredicate equalsTopo()
The equals predicate has the following equivalent definitions:
T*F**FFF*
static TopologyPredicate overlaps()
The overlaps predicate has the following equivalent definitions:
[T*T***T**] (for P/P and A/A cases)
or [1*T***T**] (for L/L cases)
false.
This predicate is symmetric.static TopologyPredicate touches()
The touches predicate has the following equivalent definitions:
[FT*******]
[F**T*****]
[F***T****]
false,
since points have only interiors.
This predicate is symmetric.static TopologyPredicate matches(String imPattern)
imPattern - the pattern to matchIntersectionMatrixPatternCopyright © 2024. All rights reserved.