geo 0.33.0

Geospatial primitives and algorithms
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use super::{Covers, impl_covers_from_intersects, impl_covers_from_relate};
use crate::{Contains, HasDimensions, geometry::*};
use crate::{GeoFloat, GeoNum};

// valid because RHS is point or multipoint
// all exterior pts of RHS intersecting self means self covers RHS
impl_covers_from_intersects!(LineString<T>, [Point<T>, MultiPoint<T>]);

impl<T> Covers<Line<T>> for LineString<T>
where
    T: GeoNum,
{
    fn covers(&self, rhs: &Line<T>) -> bool {
        if rhs.start == rhs.end {
            // handle edge case where line might sit within a linestring's boundary
            self.covers(&rhs.start)
        } else {
            // remaining scenarios are eqivalent to contains
            self.contains(rhs)
        }
    }
}

impl<T> Covers<LineString<T>> for LineString<T>
where
    T: GeoNum,
{
    fn covers(&self, rhs: &LineString<T>) -> bool {
        if self.is_empty() || rhs.is_empty() {
            return false;
        }
        rhs.lines().all(|l| self.covers(&l))
    }
}

impl_covers_from_relate!(LineString<T>, [
MultiLineString<T>,
Rect<T>, Triangle<T>,
Polygon<T>,  MultiPolygon<T>,
Geometry<T>, GeometryCollection<T>
]);

// valid because RHS is point or multipoint
// all exterior pts of RHS intersecting self means self covers RHS
impl_covers_from_intersects!(MultiLineString<T>, [Point<T>, MultiPoint<T>]);

impl_covers_from_relate!(MultiLineString<T>, [
Line<T>,
LineString<T>,  MultiLineString<T>,
Rect<T>, Triangle<T>,
Polygon<T>,  MultiPolygon<T>,
Geometry<T>, GeometryCollection<T>
]);

#[cfg(test)]
mod tests {
    use super::*;
    use crate::algorithm::convert::Convert;
    use crate::wkt;

    #[test]
    fn test_rhs_empty() {
        let s: LineString<f64> = wkt!(LINESTRING(0 0,1 1)).convert();
        assert!(!s.covers(&LineString::empty()));
        assert!(!s.covers(&Polygon::empty()));
        assert!(!s.covers(&MultiPoint::empty()));
        assert!(!s.covers(&MultiLineString::empty()));
        assert!(!s.covers(&MultiPolygon::empty()));
        assert!(!s.covers(&GeometryCollection::empty()));

        let s: MultiLineString<f64> = wkt!(MULTILINESTRING((0 0,1 1))).convert();
        assert!(!s.covers(&LineString::empty()));
        assert!(!s.covers(&Polygon::empty()));
        assert!(!s.covers(&MultiPoint::empty()));
        assert!(!s.covers(&MultiLineString::empty()));
        assert!(!s.covers(&MultiPolygon::empty()));
        assert!(!s.covers(&GeometryCollection::empty()));
    }

    #[test]
    fn test_lhs_empty() {
        let s: LineString<f64> = LineString::empty();
        assert!(!s.covers(&wkt!(POINT(0 0)).convert()));
        assert!(!s.covers(&wkt!(MULTIPOINT(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(LINE(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(LINESTRING(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(MULTILINESTRING((0 0,1 1),(2 2,3 3))).convert()));
        assert!(!s.covers(&wkt!(POLYGON((0 0,1 1,1 0,0 0))).convert()));
        assert!(!s.covers(&wkt!(MULTIPOLYGON(((0 0,1 0, 1 1,0 1, 0 0)))).convert()));
        assert!(!s.covers(&wkt!(RECT(0 0, 1 1)).convert()));
        assert!(!s.covers(&wkt!(TRIANGLE(0 0, 0 1, 1 1)).convert()));
        assert!(!s.covers(&Into::<Geometry>::into(wkt!(POINT(0 0)).convert())));
        assert!(!s.covers(&wkt!(GEOMETRYCOLLECTION(POINT(0 0))).convert()));

        let s: MultiLineString<f64> = MultiLineString::empty();
        assert!(!s.covers(&wkt!(POINT(0 0)).convert()));
        assert!(!s.covers(&wkt!(MULTIPOINT(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(LINE(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(LINESTRING(0 0,1 1)).convert()));
        assert!(!s.covers(&wkt!(MULTILINESTRING((0 0,1 1),(2 2,3 3))).convert()));
        assert!(!s.covers(&wkt!(POLYGON((0 0,1 1,1 0,0 0))).convert()));
        assert!(!s.covers(&wkt!(MULTIPOLYGON(((0 0,1 0, 1 1,0 1, 0 0)))).convert()));
        assert!(!s.covers(&wkt!(RECT(0 0, 1 1)).convert()));
        assert!(!s.covers(&wkt!(TRIANGLE(0 0, 0 1, 1 1)).convert()));
        assert!(!s.covers(&Into::<Geometry>::into(wkt!(POINT(0 0)).convert())));
        assert!(!s.covers(&wkt!(GEOMETRYCOLLECTION(POINT(0 0))).convert()));
    }

    #[test]
    fn differ_from_contains() {
        // test that the edge case is covered by custom implementation

        let ls: LineString<f64> = wkt!(LINESTRING(0 0, 1 1)).convert();
        let ls_s: LineString<f64> = wkt!(LINESTRING(0 0, 0 0)).convert();
        let ls_e: LineString<f64> = wkt!(LINESTRING(1 1, 1 1)).convert();
        let ln_s: Line<f64> = wkt!(LINE(0 0, 0 0)).convert();
        let ln_e: Line<f64> = wkt!(LINE(1 1, 1 1)).convert();
        let pt_s: Point<f64> = wkt!(POINT(0 0)).convert();
        let pt_e: Point<f64> = wkt!(POINT(1 1)).convert();

        assert!(ls.covers(&ls_s));
        assert!(ls.covers(&ls_e));
        assert!(ls.covers(&ln_s));
        assert!(ls.covers(&ln_e));
        assert!(ls.covers(&pt_s));
        assert!(ls.covers(&pt_e));

        assert!(!ls.contains(&ls_s));
        assert!(!ls.contains(&ls_e));
        assert!(!ls.contains(&ln_s));
        assert!(!ls.contains(&ln_e));
        assert!(!ls.contains(&pt_s));
        assert!(!ls.contains(&pt_e));
    }
}