sightloom-core 0.1.0

Portable geometry, detections, NMS, zones, and event core for SightLoom
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

//! Finite line-segment geometry.

use core::cmp::Ordering;

use crate::{GeometryError, Point, orientation::orientation_sign};

/// A finite, directed line segment with distinct endpoints.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct LineSegment {
    start: Point,
    end: Point,
}

impl LineSegment {
    /// Creates a line segment with distinct endpoints.
    ///
    /// # Errors
    ///
    /// Returns [`GeometryError::DegenerateSegment`] when both endpoints are
    /// equal.
    pub fn new(start: Point, end: Point) -> Result<Self, GeometryError> {
        if start == end {
            return Err(GeometryError::DegenerateSegment);
        }

        Ok(Self { start, end })
    }

    /// Returns the directed segment's starting endpoint.
    #[must_use]
    pub const fn start(self) -> Point {
        self.start
    }

    /// Returns the directed segment's ending endpoint.
    #[must_use]
    pub const fn end(self) -> Point {
        self.end
    }
}

/// The algebraic side of a point relative to a directed line.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LineSide {
    /// The point has positive orientation relative to the line.
    Left,
    /// The point is exactly collinear with the line.
    On,
    /// The point has negative orientation relative to the line.
    Right,
}

/// Returns the algebraic side of a point relative to a directed segment.
#[must_use]
pub fn line_side(segment: LineSegment, point: Point) -> LineSide {
    match orientation_sign(segment.start, segment.end, point) {
        Ordering::Greater => LineSide::Left,
        Ordering::Equal => LineSide::On,
        Ordering::Less => LineSide::Right,
    }
}

/// Returns whether two closed finite segments intersect.
#[must_use]
pub fn crosses_segment(first: LineSegment, second: LineSegment) -> bool {
    let first_start_side = line_side(first, second.start);
    let first_end_side = line_side(first, second.end);
    let second_start_side = line_side(second, first.start);
    let second_end_side = line_side(second, first.end);

    if opposite(first_start_side, first_end_side) && opposite(second_start_side, second_end_side) {
        return true;
    }

    (first_start_side == LineSide::On && point_on_segment(first.start, first.end, second.start))
        || (first_end_side == LineSide::On && point_on_segment(first.start, first.end, second.end))
        || (second_start_side == LineSide::On
            && point_on_segment(second.start, second.end, first.start))
        || (second_end_side == LineSide::On
            && point_on_segment(second.start, second.end, first.end))
}

/// Returns whether a point belongs to the closed segment between two points.
#[must_use]
pub(crate) fn point_on_segment(start: Point, end: Point, point: Point) -> bool {
    orientation_sign(start, end, point) == Ordering::Equal
        && point.x() >= start.x().min(end.x())
        && point.x() <= start.x().max(end.x())
        && point.y() >= start.y().min(end.y())
        && point.y() <= start.y().max(end.y())
}

fn opposite(first: LineSide, second: LineSide) -> bool {
    matches!(
        (first, second),
        (LineSide::Left, LineSide::Right) | (LineSide::Right, LineSide::Left)
    )
}