public class IntersectionMatrix extends Object implements Cloneable
Geometrys.
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
IntersectionMatrixs
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)
IntersectionMatrixs
elements.row - the row of this IntersectionMatrix,
indicating the interior, boundary or exterior of the first Geometrycolumn - the column of this IntersectionMatrix,
indicating the interior, boundary or exterior of the second GeometrydimensionValue - 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 Geometrycolumn - the column of this IntersectionMatrix
, indicating the interior, boundary or exterior of the second GeometryminimumDimensionValue - 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 Geometrycolumn - the column of this IntersectionMatrix
, indicating the interior, boundary or exterior of the second GeometryminimumDimensionValue - 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 Geometrycolumn - the column of this IntersectionMatrix,
indicating the interior, boundary or exterior of the second Geometrypublic boolean isDisjoint()
[FF*FF****].true if the two Geometrys related by
this matrix are disjointpublic boolean isIntersects()
isDisjoint returns false.true if the two Geometrys related by
this matrix intersectpublic boolean isTouches(int dimensionOfGeometryA,
int dimensionOfGeometryB)
[FT*******], [F**T*****] or [F***T****].dimensionOfGeometryA - the dimension of the first GeometrydimensionOfGeometryB - the dimension of the second Geometrytrue if the two Geometry
s related by this matrix touch; Returns false
if both Geometrys 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 GeometrydimensionOfGeometryB - the dimension of the second Geometrytrue if the two Geometrys
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 GeometrydimensionOfGeometryB - the dimension of the second Geometrytrue if the two Geometrys
related by this matrix are equal; the
Geometrys must have the same dimension to be equalpublic boolean isOverlaps(int dimensionOfGeometryA,
int dimensionOfGeometryB)
dimensionOfGeometryA - the dimension of the first GeometrydimensionOfGeometryB - the dimension of the second Geometrytrue if the two Geometrys
related by this matrix overlap. For this
function to return true, the Geometrys 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.