Struct De9im 

pub struct De9im { /* private fields */ }

A DE-9IM (Dimensionally Extended 9-Intersection Model) matrix.

The nine cells are stored in row-major order:

[II, IB, IE,  BI, BB, BE,  EI, EB, EE]

where I = Interior, B = Boundary, E = Exterior, and the first letter refers to geometry a, the second to geometry b.

Implementations

impl De9im

pub const II: usize = 0

Interior-Interior

pub const IB: usize = 1

Interior-Boundary

pub const IE: usize = 2

Interior-Exterior

pub const BI: usize = 3

Boundary-Interior

pub const BB: usize = 4

Boundary-Boundary

pub const BE: usize = 5

Boundary-Exterior

pub const EI: usize = 6

Exterior-Interior

pub const EB: usize = 7

Exterior-Boundary

pub const EE: usize = 8

Exterior-Exterior

pub const fn new(cells: [Dimension; 9]) -> Self

Create a matrix from an explicit 9-element array.

pub fn from_str(s: &str) -> Result<Self>

Parse a 9-character DE-9IM string such as "212101212".

pub fn get(&self, index: usize) -> Dimension

Access a single cell by index (0..9).

pub fn set(&mut self, index: usize, dim: Dimension)

Set a single cell by index (0..9).

pub fn to_string_repr(&self) -> String

Return the 9-character string form (e.g. "212101212").

pub fn transpose(&self) -> Self

Return the transposed matrix (swap a <-> b).

pub fn matches(&self, pattern: &str) -> bool

Test whether this matrix matches a 9-character pattern string.

Pattern characters: T (non-empty), F (empty), * (any), 0 (Point), 1 (Line), 2 (Area).

pub fn is_equals(&self) -> bool

OGC Equals: T*F**FFF*

Two geometries are topologically equal when their interiors intersect and no part of either geometry lies in the exterior of the other.

pub fn is_disjoint(&self) -> bool

OGC Disjoint: FF*FF****

Two geometries are disjoint when they share no points in common.

pub fn is_intersects(&self) -> bool

OGC Intersects: NOT Disjoint.

pub fn is_touches(&self) -> bool

OGC Touches: the geometries share boundary but not interior.

Matches FT******* OR F**T***** OR F***T****.

pub fn is_crosses(&self, dim_a: u8, dim_b: u8) -> bool

OGC Crosses (requires the topological dimensions of the two geometries).

• Point/Line, Point/Area, Line/Area (dim_a < dim_b): pattern T*T******
• Line/Line (dim_a == dim_b == 1): pattern 0********
• Polygon/Polygon (dim_a == dim_b == 2): always false (undefined)

pub fn is_within(&self) -> bool

OGC Within: T*F**F***

Geometry a is within geometry b when every point of a lies inside (interior or boundary of) b and the interiors intersect.

pub fn is_contains(&self) -> bool

OGC Contains: T*****FF*

Geometry a contains geometry b when within(b, a) is true.

pub fn is_overlaps(&self, dim_a: u8, dim_b: u8) -> bool

OGC Overlaps (requires the topological dimensions of the two geometries).

• Point/Point or Area/Area (dim_a == dim_b, both != 1): T*T***T**
• Line/Line (dim_a == dim_b == 1): 1*T***T**
• Different dimensions: always false

pub fn is_covers(&self) -> bool

OGC Covers: T*****FF* OR *T****FF* OR ***T**FF* OR ****T*FF*

Geometry a covers geometry b when every point of b is a point of a.

pub fn is_covered_by(&self) -> bool

OGC CoveredBy: T*F**F*** OR *TF**F*** OR **FT*F*** OR **F*TF***

Geometry a is covered by geometry b when every point of a is a point of b.

Trait Implementations

impl Clone for De9im

fn clone(&self) -> De9im

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for De9im

impl Debug for De9im

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for De9im

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for De9im

impl Hash for De9im

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for De9im

fn eq(&self, other: &De9im) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for De9im