rene 0.2.0

Computational geometry.
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

use crate::operations::Orient;
use crate::oriented::Orientation;

#[derive(Clone)]
pub(crate) struct Edge {
    pub(super) left_point_index: usize,
    pub(super) right_point_index: usize,
    pub(super) interior_to_left: bool,
}

impl Edge {
    pub(super) fn is_under<Point: PartialEq>(
        &self,
        other: &Self,
        endpoints: &[Point],
    ) -> bool
    where
        for<'a> &'a Point: Orient,
    {
        let other_left_orientation =
            self.orientation_of(&endpoints[other.left_point_index], endpoints);
        let other_right_orientation = self
            .orientation_of(&endpoints[other.right_point_index], endpoints);
        if other_left_orientation == other_right_orientation {
            other_left_orientation == Orientation::Counterclockwise
        } else if other_left_orientation == Orientation::Collinear {
            other_right_orientation == Orientation::Counterclockwise
        } else {
            let left_orientation = other
                .orientation_of(&endpoints[self.left_point_index], endpoints);
            let right_orientation = other
                .orientation_of(&endpoints[self.right_point_index], endpoints);
            if left_orientation == right_orientation {
                left_orientation == Orientation::Clockwise
            } else if left_orientation == Orientation::Collinear {
                right_orientation == Orientation::Clockwise
            } else if other_right_orientation == Orientation::Collinear {
                other_left_orientation == Orientation::Counterclockwise
            } else if right_orientation == Orientation::Collinear {
                left_orientation == Orientation::Clockwise
            } else {
                // crossing edges are incomparable
                false
            }
        }
    }

    pub(super) fn orientation_of<Point>(
        &self,
        point: &Point,
        endpoints: &[Point],
    ) -> Orientation
    where
        for<'a> &'a Point: Orient,
    {
        endpoints[self.left_point_index]
            .orient(&endpoints[self.right_point_index], point)
    }
}