public class IntersectionMatrix extends Object implements Cloneable
Geometry
s.
This class can also represent matrix patterns (such as "T*T******")
which are used for matching instances of DE-9IM matrices.
DE-9IM matrices are 3x3 matrices with integer entries.
The matrix indices {0,1,2} represent the topological locations
that occur in a geometry (Interior, Boundary, Exterior).
These are provided by the constants
Location.INTERIOR
, Location.BOUNDARY
, and Location.EXTERIOR
.
When used to specify the topological relationship between two geometries,
the matrix entries represent the possible dimensions of each intersection:
Dimension.A
= 2, Dimension.L
= 1, Dimension.P
= 0 and Dimension.FALSE
= -1.
When used to represent a matrix pattern entries can have the additional values
Dimension.TRUE
{"T") and Dimension.DONTCARE
("*").
For a description of the DE-9IM and the spatial predicates derived from it, see the following references:
Methods are provided to:
Constructor and Description |
---|
IntersectionMatrix()
Creates an
IntersectionMatrix with FALSE
dimension values. |
IntersectionMatrix(IntersectionMatrix other)
Creates an
IntersectionMatrix with the same elements as
other . |
IntersectionMatrix(String elements)
Creates an
IntersectionMatrix with the given dimension
symbols. |
Modifier and Type | Method and Description |
---|---|
void |
add(IntersectionMatrix im)
Adds one matrix to another.
|
int |
get(int row,
int column)
Returns the value of one of this matrix
entries.
|
boolean |
isContains()
Tests whether this matrix matches [T*****FF*[.
|
boolean |
isCoveredBy()
Tests if this matrix matches
[T*F**F***]
or [*TF**F***]
or [**FT*F***]
or [**F*TF***] |
boolean |
isCovers()
Tests if this matrix matches
[T*****FF*]
or [*T****FF*]
or [***T**FF*]
or [****T*FF*] |
boolean |
isCrosses(int dimensionOfGeometryA,
int dimensionOfGeometryB)
Tests whether this geometry crosses the
specified geometry.
|
boolean |
isDisjoint()
Tests if this matrix matches
[FF*FF****] . |
boolean |
isEquals(int dimensionOfGeometryA,
int dimensionOfGeometryB)
Tests whether the argument dimensions are equal and
this matrix matches the pattern [T*F**FFF*].
|
boolean |
isIntersects()
Tests if
isDisjoint returns false. |
boolean |
isOverlaps(int dimensionOfGeometryA,
int dimensionOfGeometryB)
Tests if this matrix matches
[T*T***T**] (for two points or two surfaces)
[1*T***T**] (for two curves)
.
|
boolean |
isTouches(int dimensionOfGeometryA,
int dimensionOfGeometryB)
Tests if this matrix matches
[FT*******] , [F**T*****] or [F***T****] . |
static boolean |
isTrue(int actualDimensionValue)
Tests if the dimension value matches TRUE
(i.e.
|
boolean |
isWithin()
Tests whether this matrix matches
[T*F**F***] . |
static boolean |
matches(int actualDimensionValue,
char requiredDimensionSymbol)
Tests if the dimension value satisfies the dimension symbol.
|
boolean |
matches(String pattern)
Tests whether this matrix matches the given matrix pattern.
|
static boolean |
matches(String actualDimensionSymbols,
String requiredDimensionSymbols)
Tests if each of the actual dimension symbols in a matrix string satisfies the
corresponding required dimension symbol in a pattern string.
|
void |
set(int row,
int column,
int dimensionValue)
Changes the value of one of this
IntersectionMatrix s
elements. |
void |
set(String dimensionSymbols)
Changes the elements of this
IntersectionMatrix to the
dimension symbols in dimensionSymbols . |
void |
setAll(int dimensionValue)
Changes the elements of this
IntersectionMatrix to dimensionValue
. |
void |
setAtLeast(int row,
int column,
int minimumDimensionValue)
Changes the specified element to
minimumDimensionValue if the
element is less. |
void |
setAtLeast(String minimumDimensionSymbols)
For each element in this
IntersectionMatrix , changes the
element to the corresponding minimum dimension symbol if the element is
less. |
void |
setAtLeastIfValid(int row,
int column,
int minimumDimensionValue)
If row >= 0 and column >= 0, changes the specified element to
minimumDimensionValue
if the element is less. |
String |
toString()
Returns a nine-character
String representation of this IntersectionMatrix
. |
IntersectionMatrix |
transpose()
Transposes this IntersectionMatrix.
|
public IntersectionMatrix()
IntersectionMatrix
with FALSE
dimension values.public IntersectionMatrix(String elements)
IntersectionMatrix
with the given dimension
symbols.elements
- a String of nine dimension symbols in row major orderpublic IntersectionMatrix(IntersectionMatrix other)
IntersectionMatrix
with the same elements as
other
.other
- an IntersectionMatrix
to copypublic void add(IntersectionMatrix im)
im
- the matrix to addpublic static boolean isTrue(int actualDimensionValue)
actualDimensionValue
- a number that can be stored in the IntersectionMatrix
. Possible values are {TRUE, FALSE, DONTCARE, 0, 1, 2}
.public static boolean matches(int actualDimensionValue, char requiredDimensionSymbol)
actualDimensionValue
- a number that can be stored in the IntersectionMatrix
. Possible values are {TRUE, FALSE, DONTCARE, 0, 1, 2}
.requiredDimensionSymbol
- a character used in the string
representation of an IntersectionMatrix
. Possible values
are {T, F, * , 0, 1, 2}
.public static boolean matches(String actualDimensionSymbols, String requiredDimensionSymbols)
actualDimensionSymbols
- nine dimension symbols to validate.
Possible values are {T, F, * , 0, 1, 2}
.requiredDimensionSymbols
- nine dimension symbols to validate
against. Possible values are {T, F, * , 0, 1, 2}
.public void set(int row, int column, int dimensionValue)
IntersectionMatrix
s
elements.row
- the row of this IntersectionMatrix
,
indicating the interior, boundary or exterior of the first Geometry
column
- the column of this IntersectionMatrix
,
indicating the interior, boundary or exterior of the second Geometry
dimensionValue
- the new value of the elementpublic void set(String dimensionSymbols)
IntersectionMatrix
to the
dimension symbols in dimensionSymbols
.dimensionSymbols
- nine dimension symbols to which to set this IntersectionMatrix
s elements. Possible values are {T, F, * , 0, 1, 2}
public void setAtLeast(int row, int column, int minimumDimensionValue)
minimumDimensionValue
if the
element is less.row
- the row of this IntersectionMatrix
, indicating the interior, boundary or exterior of the first Geometry
column
- the column of this IntersectionMatrix
, indicating the interior, boundary or exterior of the second Geometry
minimumDimensionValue
- the dimension value with which to compare the
element. The order of dimension values from least to greatest is
{DONTCARE, TRUE, FALSE, 0, 1, 2}
.public void setAtLeastIfValid(int row, int column, int minimumDimensionValue)
minimumDimensionValue
if the element is less. Does nothing if row <0 or column < 0.row
- the row of this IntersectionMatrix
, indicating the interior, boundary or exterior of the first Geometry
column
- the column of this IntersectionMatrix
, indicating the interior, boundary or exterior of the second Geometry
minimumDimensionValue
- the dimension value with which to compare the
element. The order of dimension values from least to greatest is
{DONTCARE, TRUE, FALSE, 0, 1, 2}
.public void setAtLeast(String minimumDimensionSymbols)
IntersectionMatrix
, changes the
element to the corresponding minimum dimension symbol if the element is
less.minimumDimensionSymbols
- nine dimension symbols with which to
compare the elements of this IntersectionMatrix
. The
order of dimension values from least to greatest is {DONTCARE, TRUE, FALSE, 0, 1, 2}
.public void setAll(int dimensionValue)
IntersectionMatrix
to dimensionValue
.dimensionValue
- the dimension value to which to set this IntersectionMatrix
s elements. Possible values {TRUE, FALSE, DONTCARE, 0, 1, 2}
.public int get(int row, int column)
Location
class.
The value returned is a constant
from the Dimension
class.row
- the row of this IntersectionMatrix
, indicating
the interior, boundary or exterior of the first Geometry
column
- the column of this IntersectionMatrix
,
indicating the interior, boundary or exterior of the second Geometry
public boolean isDisjoint()
[FF*FF****]
.true
if the two Geometry
s related by
this matrix are disjointpublic boolean isIntersects()
isDisjoint
returns false.true
if the two Geometry
s related by
this matrix intersectpublic boolean isTouches(int dimensionOfGeometryA, int dimensionOfGeometryB)
[FT*******]
, [F**T*****]
or [F***T****]
.dimensionOfGeometryA
- the dimension of the first Geometry
dimensionOfGeometryB
- the dimension of the second Geometry
true
if the two Geometry
s related by this matrix touch; Returns false
if both Geometry
s are points.public boolean isCrosses(int dimensionOfGeometryA, int dimensionOfGeometryB)
The crosses
predicate has the following equivalent definitions:
[T*T******]
(for P/L, P/A, and L/A situations)
[T*****T**]
(for L/P, L/A, 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. JTS extends the definition to apply to L/P, A/P and A/L situations as well. This makes the relation symmetric.
dimensionOfGeometryA
- the dimension of the first Geometry
dimensionOfGeometryB
- the dimension of the second Geometry
true
if the two Geometry
s
related by this matrix cross.public boolean isWithin()
[T*F**F***]
.true
if the first Geometry
is within
the secondpublic boolean isContains()
true
if the first Geometry
contains the
secondpublic boolean isCovers()
[T*****FF*]
or [*T****FF*]
or [***T**FF*]
or [****T*FF*]
true
if the first Geometry
covers the
secondpublic boolean isCoveredBy()
[T*F**F***]
or [*TF**F***]
or [**FT*F***]
or [**F*TF***]
true
if the first Geometry
is covered by the secondpublic boolean isEquals(int dimensionOfGeometryA, int dimensionOfGeometryB)
Note: This pattern differs from the one stated in Simple feature access - Part 1: Common architecture. That document states the pattern as [TFFFTFFFT]. This would specify that two identical POINTs are not equal, which is not desirable behaviour. The pattern used here has been corrected to compute equality in this situation.
dimensionOfGeometryA
- the dimension of the first Geometry
dimensionOfGeometryB
- the dimension of the second Geometry
true
if the two Geometry
s
related by this matrix are equal; the
Geometry
s must have the same dimension to be equalpublic boolean isOverlaps(int dimensionOfGeometryA, int dimensionOfGeometryB)
dimensionOfGeometryA
- the dimension of the first Geometry
dimensionOfGeometryB
- the dimension of the second Geometry
true
if the two Geometry
s
related by this matrix overlap. For this
function to return true
, the Geometry
s must
be two points, two curves or two surfaces.public boolean matches(String pattern)
pattern
- A pattern containing nine dimension symbols with which to
compare the entries of this matrix. Possible
symbol values are {T, F, * , 0, 1, 2}
.true
if this matrix matches the patternpublic IntersectionMatrix transpose()
IntersectionMatrix
as a convenienceCopyright © 2024. All rights reserved.