geo/algorithm/intersects/
mod.rs

1use crate::BoundingRect;
2use crate::*;
3
4/// Checks if the geometry Self intersects the geometry Rhs.
5/// More formally, either boundary or interior of Self has
6/// non-empty (set-theoretic) intersection with the boundary
7/// or interior of Rhs. In other words, the [DE-9IM]
8/// intersection matrix for (Self, Rhs) is _not_ `FF*FF****`.
9///
10/// This predicate is symmetric: `a.intersects(b)` iff
11/// `b.intersects(a)`.
12///
13/// [DE-9IM]: https://en.wikipedia.org/wiki/DE-9IM
14///
15/// # Examples
16///
17/// ```
18/// use geo::Intersects;
19/// use geo::line_string;
20///
21/// let line_string_a = line_string![
22///     (x: 3., y: 2.),
23///     (x: 7., y: 6.),
24/// ];
25///
26/// let line_string_b = line_string![
27///     (x: 3., y: 4.),
28///     (x: 8., y: 4.),
29/// ];
30///
31/// let line_string_c = line_string![
32///     (x: 9., y: 2.),
33///     (x: 11., y: 5.),
34/// ];
35///
36/// assert!(line_string_a.intersects(&line_string_b));
37/// assert!(!line_string_a.intersects(&line_string_c));
38/// ```
39pub trait Intersects<Rhs = Self> {
40    fn intersects(&self, rhs: &Rhs) -> bool;
41}
42
43// Since `Intersects` is symmetric, we use a macro to
44// implement `T: Intersects<S>` if `S: Intersects<T>` is
45// available.
46//
47// As a convention, we typically provide explicit impl.
48// whenever the Rhs is a "simpler geometry" than the target
49// type, and use the macro for the reverse impl. However,
50// when there is a blanket implementations (eg. Point from
51// Coord, MultiPoint from Point), we need to provide
52// the reverse (where Self is "simpler" than Rhs).
53macro_rules! symmetric_intersects_impl {
54    ($t:ty, $k:ty) => {
55        impl<T> $crate::Intersects<$k> for $t
56        where
57            $k: $crate::Intersects<$t>,
58            T: CoordNum,
59        {
60            fn intersects(&self, rhs: &$k) -> bool {
61                rhs.intersects(self)
62            }
63        }
64    };
65}
66
67mod collections;
68mod coordinate;
69mod line;
70mod line_string;
71mod point;
72mod polygon;
73mod rect;
74mod triangle;
75
76// Helper function to check value lies between min and max.
77// Only makes sense if min <= max (or always false)
78#[inline]
79fn value_in_range<T>(value: T, min: T, max: T) -> bool
80where
81    T: std::cmp::PartialOrd,
82{
83    value >= min && value <= max
84}
85
86// Helper function to check value lies between two bounds,
87// where the ordering of the bounds is not known
88#[inline]
89pub(crate) fn value_in_between<T>(value: T, bound_1: T, bound_2: T) -> bool
90where
91    T: std::cmp::PartialOrd,
92{
93    if bound_1 < bound_2 {
94        value_in_range(value, bound_1, bound_2)
95    } else {
96        value_in_range(value, bound_2, bound_1)
97    }
98}
99
100// Helper function to check point lies inside rect given by
101// bounds.  The first bound need not be min.
102#[inline]
103pub(crate) fn point_in_rect<T>(value: Coord<T>, bound_1: Coord<T>, bound_2: Coord<T>) -> bool
104where
105    T: CoordNum,
106{
107    value_in_between(value.x, bound_1.x, bound_2.x)
108        && value_in_between(value.y, bound_1.y, bound_2.y)
109}
110
111// A cheap bbox check to see if we can skip the more expensive intersection computation
112fn has_disjoint_bboxes<T, A, B>(a: &A, b: &B) -> bool
113where
114    T: CoordNum,
115    A: BoundingRect<T>,
116    B: BoundingRect<T>,
117{
118    let mut disjoint_bbox = false;
119    if let Some(a_bbox) = a.bounding_rect().into() {
120        if let Some(b_bbox) = b.bounding_rect().into() {
121            if !a_bbox.intersects(&b_bbox) {
122                disjoint_bbox = true;
123            }
124        }
125    }
126    disjoint_bbox
127}
128
129#[cfg(test)]
130mod test {
131    use crate::Intersects;
132    use crate::{
133        Geometry, Line, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon,
134        Rect, coord, line_string, polygon,
135    };
136
137    /// Tests: intersection LineString and LineString
138    #[test]
139    fn empty_linestring1_test() {
140        let linestring = line_string![(x: 3., y: 2.), (x: 7., y: 6.)];
141        assert!(!line_string![].intersects(&linestring));
142    }
143    #[test]
144    fn empty_linestring2_test() {
145        let linestring = line_string![(x: 3., y: 2.), (x: 7., y: 6.)];
146        assert!(!linestring.intersects(&LineString::new(Vec::new())));
147    }
148    #[test]
149    fn empty_all_linestring_test() {
150        let empty: LineString = line_string![];
151        assert!(!empty.intersects(&empty));
152    }
153    #[test]
154    fn intersect_linestring_test() {
155        let ls1 = line_string![(x: 3., y: 2.), (x: 7., y: 6.)];
156        let ls2 = line_string![(x: 3., y: 4.), (x: 8., y: 4.)];
157        assert!(ls1.intersects(&ls2));
158    }
159    #[test]
160    fn parallel_linestrings_test() {
161        let ls1 = line_string![(x: 3., y: 2.), (x: 7., y: 6.)];
162        let ls2 = line_string![(x: 3., y: 1.), (x: 7., y: 5.)];
163        assert!(!ls1.intersects(&ls2));
164    }
165    /// Tests: intersection LineString and Polygon
166    #[test]
167    fn linestring_in_polygon_test() {
168        let poly = polygon![
169            (x: 0., y: 0.),
170            (x: 5., y: 0.),
171            (x: 5., y: 6.),
172            (x: 0., y: 6.),
173            (x: 0., y: 0.),
174        ];
175        let ls = line_string![(x: 2., y: 2.), (x: 3., y: 3.)];
176        assert!(poly.intersects(&ls));
177    }
178    #[test]
179    fn linestring_on_boundary_polygon_test() {
180        let poly = Polygon::new(
181            LineString::from(vec![(0., 0.), (5., 0.), (5., 6.), (0., 6.), (0., 0.)]),
182            Vec::new(),
183        );
184        assert!(poly.intersects(&LineString::from(vec![(0., 0.), (5., 0.)])));
185        assert!(poly.intersects(&LineString::from(vec![(5., 0.), (5., 6.)])));
186        assert!(poly.intersects(&LineString::from(vec![(5., 6.), (0., 6.)])));
187        assert!(poly.intersects(&LineString::from(vec![(0., 6.), (0., 0.)])));
188    }
189    #[test]
190    fn intersect_linestring_polygon_test() {
191        let poly = Polygon::new(
192            LineString::from(vec![(0., 0.), (5., 0.), (5., 6.), (0., 6.), (0., 0.)]),
193            Vec::new(),
194        );
195        assert!(poly.intersects(&LineString::from(vec![(2., 2.), (6., 6.)])));
196    }
197    #[test]
198    fn linestring_outside_polygon_test() {
199        let poly = Polygon::new(
200            LineString::from(vec![(0., 0.), (5., 0.), (5., 6.), (0., 6.), (0., 0.)]),
201            Vec::new(),
202        );
203        assert!(!poly.intersects(&LineString::from(vec![(7., 2.), (9., 4.)])));
204    }
205    #[test]
206    fn linestring_in_inner_polygon_test() {
207        let e = LineString::from(vec![(0., 0.), (5., 0.), (5., 6.), (0., 6.), (0., 0.)]);
208        let v = vec![LineString::from(vec![
209            (1., 1.),
210            (4., 1.),
211            (4., 4.),
212            (1., 4.),
213            (1., 1.),
214        ])];
215        let poly = Polygon::new(e, v);
216        assert!(!poly.intersects(&LineString::from(vec![(2., 2.), (3., 3.)])));
217        assert!(poly.intersects(&LineString::from(vec![(2., 2.), (4., 4.)])));
218    }
219    #[test]
220    fn linestring_traverse_polygon_test() {
221        let e = LineString::from(vec![(0., 0.), (5., 0.), (5., 6.), (0., 6.), (0., 0.)]);
222        let v = vec![LineString::from(vec![
223            (1., 1.),
224            (4., 1.),
225            (4., 4.),
226            (1., 4.),
227            (1., 1.),
228        ])];
229        let poly = Polygon::new(e, v);
230        assert!(poly.intersects(&LineString::from(vec![(2., 0.5), (2., 5.)])));
231    }
232    #[test]
233    fn linestring_in_inner_with_2_inner_polygon_test() {
234        //                                        (8,9)
235        //     (2,8)                                |                                      (14,8)
236        //      ------------------------------------|------------------------------------------
237        //      |                                   |                                         |
238        //      |     (4,7)            (6,7)        |                                         |
239        //      |       ------------------          |                    (11,7)               |
240        //      |                                   |                       |                 |
241        //      |     (4,6)                (7,6)    |     (9,6)             |     (12,6)      |
242        //      |       ----------------------      |       ----------------|---------        |
243        //      |       |                    |      |       |               |        |        |
244        //      |       |       (6,5)        |      |       |               |        |        |
245        //      |       |        /           |      |       |               |        |        |
246        //      |       |       /            |      |       |               |        |        |
247        //      |       |     (5,4)          |      |       |               |        |        |
248        //      |       |                    |      |       |               |        |        |
249        //      |       ----------------------      |       ----------------|---------        |
250        //      |     (4,3)                (7,3)    |     (9,3)             |     (12,3)      |
251        //      |                                   |                    (11,2.5)             |
252        //      |                                   |                                         |
253        //      ------------------------------------|------------------------------------------
254        //    (2,2)                                 |                                      (14,2)
255        //                                        (8,1)
256        //
257        let e = LineString::from(vec![(2., 2.), (14., 2.), (14., 8.), (2., 8.), (2., 2.)]);
258        let v = vec![
259            LineString::from(vec![(4., 3.), (7., 3.), (7., 6.), (4., 6.), (4., 3.)]),
260            LineString::from(vec![(9., 3.), (12., 3.), (12., 6.), (9., 6.), (9., 3.)]),
261        ];
262        let poly = Polygon::new(e, v);
263        assert!(!poly.intersects(&LineString::from(vec![(5., 4.), (6., 5.)])));
264        assert!(poly.intersects(&LineString::from(vec![(11., 2.5), (11., 7.)])));
265        assert!(poly.intersects(&LineString::from(vec![(4., 7.), (6., 7.)])));
266        assert!(poly.intersects(&LineString::from(vec![(8., 1.), (8., 9.)])));
267    }
268    #[test]
269    fn polygons_do_not_intersect() {
270        let p1 = Polygon::new(
271            LineString::from(vec![(1., 3.), (3., 3.), (3., 5.), (1., 5.), (1., 3.)]),
272            Vec::new(),
273        );
274        let p2 = Polygon::new(
275            LineString::from(vec![
276                (10., 30.),
277                (30., 30.),
278                (30., 50.),
279                (10., 50.),
280                (10., 30.),
281            ]),
282            Vec::new(),
283        );
284
285        assert!(!p1.intersects(&p2));
286        assert!(!p2.intersects(&p1));
287    }
288    #[test]
289    fn polygons_overlap() {
290        let p1 = Polygon::new(
291            LineString::from(vec![(1., 3.), (3., 3.), (3., 5.), (1., 5.), (1., 3.)]),
292            Vec::new(),
293        );
294        let p2 = Polygon::new(
295            LineString::from(vec![(2., 3.), (4., 3.), (4., 7.), (2., 7.), (2., 3.)]),
296            Vec::new(),
297        );
298
299        assert!(p1.intersects(&p2));
300        assert!(p2.intersects(&p1));
301    }
302    #[test]
303    fn polygon_contained() {
304        let p1 = Polygon::new(
305            LineString::from(vec![(1., 3.), (4., 3.), (4., 6.), (1., 6.), (1., 3.)]),
306            Vec::new(),
307        );
308        let p2 = Polygon::new(
309            LineString::from(vec![(2., 4.), (3., 4.), (3., 5.), (2., 5.), (2., 4.)]),
310            Vec::new(),
311        );
312
313        assert!(p1.intersects(&p2));
314        assert!(p2.intersects(&p1));
315    }
316    #[test]
317    fn polygons_conincident() {
318        let p1 = Polygon::new(
319            LineString::from(vec![(1., 3.), (4., 3.), (4., 6.), (1., 6.), (1., 3.)]),
320            Vec::new(),
321        );
322        let p2 = Polygon::new(
323            LineString::from(vec![(1., 3.), (4., 3.), (4., 6.), (1., 6.), (1., 3.)]),
324            Vec::new(),
325        );
326
327        assert!(p1.intersects(&p2));
328        assert!(p2.intersects(&p1));
329    }
330    #[test]
331    fn polygon_intersects_bounding_rect_test() {
332        // Polygon poly =
333        //
334        // (0,8)               (12,8)
335        //  ┌──────────────────────┐
336        //  │         (7,7) (11,7) │
337        //  │             ┌──────┐ │
338        //  │             │      │ │
339        //  │             │(hole)│ │
340        //  │             │      │ │
341        //  │             │      │ │
342        //  │             └──────┘ │
343        //  │         (7,4) (11,4) │
344        //  │                      │
345        //  │                      │
346        //  │                      │
347        //  │                      │
348        //  │                      │
349        //  └──────────────────────┘
350        // (0,0)               (12,0)
351        let poly = Polygon::new(
352            LineString::from(vec![(0., 0.), (12., 0.), (12., 8.), (0., 8.), (0., 0.)]),
353            vec![LineString::from(vec![
354                (7., 4.),
355                (11., 4.),
356                (11., 7.),
357                (7., 7.),
358                (7., 4.),
359            ])],
360        );
361        let b1 = Rect::new(coord! { x: 11., y: 1. }, coord! { x: 13., y: 2. });
362        let b2 = Rect::new(coord! { x: 2., y: 2. }, coord! { x: 8., y: 5. });
363        let b3 = Rect::new(coord! { x: 8., y: 5. }, coord! { x: 10., y: 6. });
364        let b4 = Rect::new(coord! { x: 1., y: 1. }, coord! { x: 3., y: 3. });
365        // overlaps
366        assert!(poly.intersects(&b1));
367        // contained in exterior, overlaps with hole
368        assert!(poly.intersects(&b2));
369        // completely contained in the hole
370        assert!(!poly.intersects(&b3));
371        // completely contained in the polygon
372        assert!(poly.intersects(&b4));
373        // conversely,
374        assert!(b1.intersects(&poly));
375        assert!(b2.intersects(&poly));
376        assert!(!b3.intersects(&poly));
377        assert!(b4.intersects(&poly));
378    }
379    #[test]
380    fn bounding_rect_test() {
381        let bounding_rect_xl =
382            Rect::new(coord! { x: -100., y: -200. }, coord! { x: 100., y: 200. });
383        let bounding_rect_sm = Rect::new(coord! { x: -10., y: -20. }, coord! { x: 10., y: 20. });
384        let bounding_rect_s2 = Rect::new(coord! { x: 0., y: 0. }, coord! { x: 20., y: 30. });
385        // confirmed using GEOS
386        assert!(bounding_rect_xl.intersects(&bounding_rect_sm));
387        assert!(bounding_rect_sm.intersects(&bounding_rect_xl));
388        assert!(bounding_rect_sm.intersects(&bounding_rect_s2));
389        assert!(bounding_rect_s2.intersects(&bounding_rect_sm));
390    }
391    #[test]
392    fn rect_intersection_consistent_with_poly_intersection_test() {
393        let bounding_rect_xl =
394            Rect::new(coord! { x: -100., y: -200. }, coord! { x: 100., y: 200. });
395        let bounding_rect_sm = Rect::new(coord! { x: -10., y: -20. }, coord! { x: 10., y: 20. });
396        let bounding_rect_s2 = Rect::new(coord! { x: 0., y: 0. }, coord! { x: 20., y: 30. });
397
398        assert!(bounding_rect_xl.to_polygon().intersects(&bounding_rect_sm));
399        assert!(bounding_rect_xl.intersects(&bounding_rect_sm.to_polygon()));
400        assert!(
401            bounding_rect_xl
402                .to_polygon()
403                .intersects(&bounding_rect_sm.to_polygon())
404        );
405
406        assert!(bounding_rect_sm.to_polygon().intersects(&bounding_rect_xl));
407        assert!(bounding_rect_sm.intersects(&bounding_rect_xl.to_polygon()));
408        assert!(
409            bounding_rect_sm
410                .to_polygon()
411                .intersects(&bounding_rect_xl.to_polygon())
412        );
413
414        assert!(bounding_rect_sm.to_polygon().intersects(&bounding_rect_s2));
415        assert!(bounding_rect_sm.intersects(&bounding_rect_s2.to_polygon()));
416        assert!(
417            bounding_rect_sm
418                .to_polygon()
419                .intersects(&bounding_rect_s2.to_polygon())
420        );
421
422        assert!(bounding_rect_s2.to_polygon().intersects(&bounding_rect_sm));
423        assert!(bounding_rect_s2.intersects(&bounding_rect_sm.to_polygon()));
424        assert!(
425            bounding_rect_s2
426                .to_polygon()
427                .intersects(&bounding_rect_sm.to_polygon())
428        );
429    }
430    #[test]
431    fn point_intersects_line_test() {
432        let p0 = Point::new(2., 4.);
433        // vertical line
434        let line1 = Line::from([(2., 0.), (2., 5.)]);
435        // point on line, but outside line segment
436        let line2 = Line::from([(0., 6.), (1.5, 4.5)]);
437        // point on line
438        let line3 = Line::from([(0., 6.), (3., 3.)]);
439        // point above line with positive slope
440        let line4 = Line::from([(1., 2.), (5., 3.)]);
441        // point below line with positive slope
442        let line5 = Line::from([(1., 5.), (5., 6.)]);
443        // point above line with negative slope
444        let line6 = Line::from([(1., 2.), (5., -3.)]);
445        // point below line with negative slope
446        let line7 = Line::from([(1., 6.), (5., 5.)]);
447        assert!(line1.intersects(&p0));
448        assert!(p0.intersects(&line1));
449        assert!(!line2.intersects(&p0));
450        assert!(!p0.intersects(&line2));
451        assert!(line3.intersects(&p0));
452        assert!(p0.intersects(&line3));
453        assert!(!line4.intersects(&p0));
454        assert!(!p0.intersects(&line4));
455        assert!(!line5.intersects(&p0));
456        assert!(!p0.intersects(&line5));
457        assert!(!line6.intersects(&p0));
458        assert!(!p0.intersects(&line6));
459        assert!(!line7.intersects(&p0));
460        assert!(!p0.intersects(&line7));
461    }
462    #[test]
463    fn line_intersects_line_test() {
464        let line0 = Line::from([(0., 0.), (3., 4.)]);
465        let line1 = Line::from([(2., 0.), (2., 5.)]);
466        let line2 = Line::from([(0., 7.), (5., 4.)]);
467        let line3 = Line::from([(0., 0.), (-3., -4.)]);
468        assert!(line0.intersects(&line0));
469        assert!(line0.intersects(&line1));
470        assert!(!line0.intersects(&line2));
471        assert!(line0.intersects(&line3));
472
473        assert!(line1.intersects(&line0));
474        assert!(line1.intersects(&line1));
475        assert!(!line1.intersects(&line2));
476        assert!(!line1.intersects(&line3));
477
478        assert!(!line2.intersects(&line0));
479        assert!(!line2.intersects(&line1));
480        assert!(line2.intersects(&line2));
481        assert!(!line1.intersects(&line3));
482    }
483    #[test]
484    fn line_intersects_linestring_test() {
485        let line0 = Line::from([(0., 0.), (3., 4.)]);
486        let linestring0 = LineString::from(vec![(0., 1.), (1., 0.), (2., 0.)]);
487        let linestring1 = LineString::from(vec![(0.5, 0.2), (1., 0.), (2., 0.)]);
488        assert!(line0.intersects(&linestring0));
489        assert!(!line0.intersects(&linestring1));
490        assert!(linestring0.intersects(&line0));
491        assert!(!linestring1.intersects(&line0));
492    }
493    #[test]
494    fn line_intersects_polygon_test() {
495        let line0 = Line::from([(0.5, 0.5), (2., 1.)]);
496        let poly0 = Polygon::new(
497            LineString::from(vec![(0., 0.), (1., 2.), (1., 0.), (0., 0.)]),
498            vec![],
499        );
500        let poly1 = Polygon::new(
501            LineString::from(vec![(1., -1.), (2., -1.), (2., -2.), (1., -1.)]),
502            vec![],
503        );
504        // line contained in the hole
505        let poly2 = Polygon::new(
506            LineString::from(vec![(-1., -1.), (-1., 10.), (10., -1.), (-1., -1.)]),
507            vec![LineString::from(vec![
508                (0., 0.),
509                (3., 4.),
510                (3., 0.),
511                (0., 0.),
512            ])],
513        );
514        assert!(line0.intersects(&poly0));
515        assert!(poly0.intersects(&line0));
516
517        assert!(!line0.intersects(&poly1));
518        assert!(!poly1.intersects(&line0));
519
520        assert!(!line0.intersects(&poly2));
521        assert!(!poly2.intersects(&line0));
522    }
523    #[test]
524    // See https://github.com/georust/geo/issues/419
525    fn rect_test_419() {
526        let a = Rect::new(
527            coord! {
528                x: 9.228515625,
529                y: 46.83013364044739,
530            },
531            coord! {
532                x: 9.2724609375,
533                y: 46.86019101567026,
534            },
535        );
536        let b = Rect::new(
537            coord! {
538                x: 9.17953,
539                y: 46.82018,
540            },
541            coord! {
542                x: 9.26309,
543                y: 46.88099,
544            },
545        );
546        assert!(a.intersects(&b));
547        assert!(b.intersects(&a));
548    }
549
550    #[test]
551    fn compile_test_geom_geom() {
552        // This test should check existence of all
553        // combinations of geometry types.
554        let geom: Geometry<_> = Line::from([(0.5, 0.5), (2., 1.)]).into();
555        assert!(geom.intersects(&geom));
556    }
557
558    #[test]
559    fn exhaustive_compile_test() {
560        use geo_types::{Coord, GeometryCollection, Triangle};
561        let c = Coord { x: 0., y: 0. };
562        let pt: Point = Point::new(0., 0.);
563        let ls = line_string![(0., 0.).into(), (1., 1.).into()];
564        let multi_ls = MultiLineString::new(vec![ls.clone()]);
565        let ln: Line = Line::new((0., 0.), (1., 1.));
566
567        let poly = Polygon::new(LineString::from(vec![(0., 0.), (1., 1.), (1., 0.)]), vec![]);
568        let rect = Rect::new(coord! { x: 10., y: 20. }, coord! { x: 30., y: 10. });
569        let tri = Triangle::new(
570            coord! { x: 0., y: 0. },
571            coord! { x: 10., y: 20. },
572            coord! { x: 20., y: -10. },
573        );
574        let geom = Geometry::Point(pt);
575        let gc = GeometryCollection::new_from(vec![geom.clone()]);
576        let multi_point = MultiPoint::new(vec![pt]);
577        let multi_poly = MultiPolygon::new(vec![poly.clone()]);
578
579        let _ = c.intersects(&c);
580        let _ = c.intersects(&pt);
581        let _ = c.intersects(&ln);
582        let _ = c.intersects(&ls);
583        let _ = c.intersects(&poly);
584        let _ = c.intersects(&rect);
585        let _ = c.intersects(&tri);
586        let _ = c.intersects(&geom);
587        let _ = c.intersects(&gc);
588        let _ = c.intersects(&multi_point);
589        let _ = c.intersects(&multi_ls);
590        let _ = c.intersects(&multi_poly);
591
592        let _ = pt.intersects(&c);
593        let _ = pt.intersects(&pt);
594        let _ = pt.intersects(&ln);
595        let _ = pt.intersects(&ls);
596        let _ = pt.intersects(&poly);
597        let _ = pt.intersects(&rect);
598        let _ = pt.intersects(&tri);
599        let _ = pt.intersects(&geom);
600        let _ = pt.intersects(&gc);
601        let _ = pt.intersects(&multi_point);
602        let _ = pt.intersects(&multi_ls);
603        let _ = pt.intersects(&multi_poly);
604
605        let _ = ln.intersects(&c);
606        let _ = ln.intersects(&pt);
607        let _ = ln.intersects(&ln);
608        let _ = ln.intersects(&ls);
609        let _ = ln.intersects(&poly);
610        let _ = ln.intersects(&rect);
611        let _ = ln.intersects(&tri);
612        let _ = ln.intersects(&geom);
613        let _ = ln.intersects(&gc);
614        let _ = ln.intersects(&multi_point);
615        let _ = ln.intersects(&multi_ls);
616        let _ = ln.intersects(&multi_poly);
617
618        let _ = ls.intersects(&c);
619        let _ = ls.intersects(&pt);
620        let _ = ls.intersects(&ln);
621        let _ = ls.intersects(&ls);
622        let _ = ls.intersects(&poly);
623        let _ = ls.intersects(&rect);
624        let _ = ls.intersects(&tri);
625        let _ = ls.intersects(&geom);
626        let _ = ls.intersects(&gc);
627        let _ = ls.intersects(&multi_point);
628        let _ = ls.intersects(&multi_ls);
629        let _ = ls.intersects(&multi_poly);
630
631        let _ = poly.intersects(&c);
632        let _ = poly.intersects(&pt);
633        let _ = poly.intersects(&ln);
634        let _ = poly.intersects(&ls);
635        let _ = poly.intersects(&poly);
636        let _ = poly.intersects(&rect);
637        let _ = poly.intersects(&tri);
638        let _ = poly.intersects(&geom);
639        let _ = poly.intersects(&gc);
640        let _ = poly.intersects(&multi_point);
641        let _ = poly.intersects(&multi_ls);
642        let _ = poly.intersects(&multi_poly);
643
644        let _ = rect.intersects(&c);
645        let _ = rect.intersects(&pt);
646        let _ = rect.intersects(&ln);
647        let _ = rect.intersects(&ls);
648        let _ = rect.intersects(&poly);
649        let _ = rect.intersects(&rect);
650        let _ = rect.intersects(&tri);
651        let _ = rect.intersects(&geom);
652        let _ = rect.intersects(&gc);
653        let _ = rect.intersects(&multi_point);
654        let _ = rect.intersects(&multi_ls);
655        let _ = rect.intersects(&multi_poly);
656
657        let _ = tri.intersects(&c);
658        let _ = tri.intersects(&pt);
659        let _ = tri.intersects(&ln);
660        let _ = tri.intersects(&ls);
661        let _ = tri.intersects(&poly);
662        let _ = tri.intersects(&rect);
663        let _ = tri.intersects(&tri);
664        let _ = tri.intersects(&geom);
665        let _ = tri.intersects(&gc);
666        let _ = tri.intersects(&multi_point);
667        let _ = tri.intersects(&multi_ls);
668        let _ = tri.intersects(&multi_poly);
669
670        let _ = geom.intersects(&c);
671        let _ = geom.intersects(&pt);
672        let _ = geom.intersects(&ln);
673        let _ = geom.intersects(&ls);
674        let _ = geom.intersects(&poly);
675        let _ = geom.intersects(&rect);
676        let _ = geom.intersects(&tri);
677        let _ = geom.intersects(&geom);
678        let _ = geom.intersects(&gc);
679        let _ = geom.intersects(&multi_point);
680        let _ = geom.intersects(&multi_ls);
681        let _ = geom.intersects(&multi_poly);
682
683        let _ = gc.intersects(&c);
684        let _ = gc.intersects(&pt);
685        let _ = gc.intersects(&ln);
686        let _ = gc.intersects(&ls);
687        let _ = gc.intersects(&poly);
688        let _ = gc.intersects(&rect);
689        let _ = gc.intersects(&tri);
690        let _ = gc.intersects(&geom);
691        let _ = gc.intersects(&gc);
692        let _ = gc.intersects(&multi_point);
693        let _ = gc.intersects(&multi_ls);
694        let _ = gc.intersects(&multi_poly);
695
696        let _ = multi_point.intersects(&c);
697        let _ = multi_point.intersects(&pt);
698        let _ = multi_point.intersects(&ln);
699        let _ = multi_point.intersects(&ls);
700        let _ = multi_point.intersects(&poly);
701        let _ = multi_point.intersects(&rect);
702        let _ = multi_point.intersects(&tri);
703        let _ = multi_point.intersects(&geom);
704        let _ = multi_point.intersects(&gc);
705        let _ = multi_point.intersects(&multi_point);
706        let _ = multi_point.intersects(&multi_ls);
707        let _ = multi_point.intersects(&multi_poly);
708
709        let _ = multi_ls.intersects(&c);
710        let _ = multi_ls.intersects(&pt);
711        let _ = multi_ls.intersects(&ln);
712        let _ = multi_ls.intersects(&ls);
713        let _ = multi_ls.intersects(&poly);
714        let _ = multi_ls.intersects(&rect);
715        let _ = multi_ls.intersects(&tri);
716        let _ = multi_ls.intersects(&geom);
717        let _ = multi_ls.intersects(&gc);
718        let _ = multi_ls.intersects(&multi_point);
719        let _ = multi_ls.intersects(&multi_ls);
720        let _ = multi_ls.intersects(&multi_poly);
721
722        let _ = multi_poly.intersects(&c);
723        let _ = multi_poly.intersects(&pt);
724        let _ = multi_poly.intersects(&ln);
725        let _ = multi_poly.intersects(&ls);
726        let _ = multi_poly.intersects(&poly);
727        let _ = multi_poly.intersects(&rect);
728        let _ = multi_poly.intersects(&tri);
729        let _ = multi_poly.intersects(&geom);
730        let _ = multi_poly.intersects(&gc);
731        let _ = multi_poly.intersects(&multi_point);
732        let _ = multi_poly.intersects(&multi_ls);
733        let _ = multi_poly.intersects(&multi_poly);
734    }
735}
geo/algorithm/intersects/mod.rs

geo/algorithm/intersects/
mod.rs
