sightloom-core 0.1.6

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
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
136
137
138
139
140
141
142
143

//! Public zone-geometry contract tests.

use sightloom_core::{
    GeometryError, LineSegment, LineSide, Point, Polygon, crosses_segment, line_side,
};

fn point(x: f32, y: f32) -> Point {
    Point::new(x, y).unwrap()
}

fn segment(start: (f32, f32), end: (f32, f32)) -> LineSegment {
    LineSegment::new(point(start.0, start.1), point(end.0, end.1)).unwrap()
}

// Catches accepting an endpoint pair that cannot define an orientation.
#[test]
fn line_segment_rejects_a_directionless_segment() {
    let endpoint = point(1.0, 2.0);
    assert_eq!(
        LineSegment::new(endpoint, endpoint),
        Err(GeometryError::DegenerateSegment)
    );
}

// Catches reversed orientation, treating collinearity as approximate, or f32 overflow.
#[test]
fn line_side_uses_an_exact_algebraic_orientation() {
    let horizontal = segment((0.0, 0.0), (4.0, 0.0));
    assert_eq!(line_side(horizontal, point(2.0, 1.0)), LineSide::Left);
    assert_eq!(line_side(horizontal, point(2.0, -1.0)), LineSide::Right);
    assert_eq!(line_side(horizontal, point(2.0, 0.0)), LineSide::On);

    let large = segment((0.0, 0.0), (f32::MAX, f32::MAX * 0.5));
    assert_eq!(
        line_side(large, point(f32::MAX * 0.5, f32::MAX)),
        LineSide::Left
    );
}

// Catches infinite-line intersection in place of closed finite-segment intersection.
#[test]
fn finite_segments_do_not_cross_only_on_their_extensions() {
    assert!(crosses_segment(
        segment((0.0, 0.0), (4.0, 0.0)),
        segment((2.0, -1.0), (2.0, 1.0))
    ));
    assert!(crosses_segment(
        segment((0.0, 0.0), (2.0, 0.0)),
        segment((2.0, 0.0), (2.0, 2.0))
    ));
    assert!(crosses_segment(
        segment((0.0, 0.0), (3.0, 0.0)),
        segment((2.0, 0.0), (4.0, 0.0))
    ));
    assert!(!crosses_segment(
        segment((0.0, 0.0), (1.0, 0.0)),
        segment((2.0, 0.0), (3.0, 0.0))
    ));
    assert!(!crosses_segment(
        segment((0.0, 0.0), (1.0, 0.0)),
        segment((2.0, -1.0), (2.0, 1.0))
    ));
}

// Catches constructing a polygon that lacks enough supplied vertices for edges.
#[test]
fn polygon_rejects_fewer_than_three_supplied_points() {
    let points = [point(0.0, 0.0), point(1.0, 0.0)];
    assert_eq!(Polygon::new(&points), Err(GeometryError::TooFewPoints));
}

// Catches omitted boundary handling or incorrect ordinary polygon membership.
#[test]
fn polygon_membership_covers_inside_outside_and_boundary_points() {
    let points = [
        point(0.0, 0.0),
        point(4.0, 0.0),
        point(4.0, 4.0),
        point(0.0, 4.0),
    ];
    let polygon = Polygon::new(&points).unwrap();
    assert!(polygon.contains(point(2.0, 2.0)));
    assert!(!polygon.contains(point(5.0, 2.0)));
    assert!(polygon.contains(point(0.0, 2.0)));
    assert!(polygon.contains(point(0.0, 0.0)));
    assert_eq!(polygon.points(), &points);
}

// Catches winding-only logic rather than even-odd parity across concave crossings.
#[test]
fn polygon_uses_even_odd_membership_for_concave_and_self_intersecting_shapes() {
    let concave = [
        point(0.0, 0.0),
        point(4.0, 0.0),
        point(4.0, 4.0),
        point(2.0, 2.0),
        point(0.0, 4.0),
    ];
    let concave = Polygon::new(&concave).unwrap();
    assert!(concave.contains(point(3.0, 1.0)));
    assert!(!concave.contains(point(2.0, 3.0)));

    let bow_tie = [
        point(0.0, 0.0),
        point(4.0, 4.0),
        point(0.0, 4.0),
        point(4.0, 0.0),
    ];
    let bow_tie = Polygon::new(&bow_tie).unwrap();
    assert!(bow_tie.contains(point(2.0, 0.5)));
    assert!(!bow_tie.contains(point(0.5, 2.0)));
    assert!(bow_tie.contains(point(2.0, 2.0)));
}

// Catches parity toggling from zero-length edges or rejecting optional closure.
#[test]
fn polygon_accepts_repeated_adjacent_and_closing_vertices() {
    let points = [
        point(0.0, 0.0),
        point(4.0, 0.0),
        point(4.0, 0.0),
        point(4.0, 4.0),
        point(0.0, 4.0),
        point(0.0, 0.0),
    ];
    assert!(Polygon::new(&points).unwrap().contains(point(2.0, 2.0)));
}

// Catches rounded f64 products erasing a finite-f32 orientation at extreme translation.
#[test]
fn translated_extreme_coordinates_keep_exact_geometry_signs() {
    let max = f32::MAX;
    let diagonal = segment((max, max), (0.0, 0.0));
    assert_eq!(line_side(diagonal, point(1.0, 0.0)), LineSide::Left);
    assert!(!crosses_segment(diagonal, segment((1.0, 0.0), (1.0, -1.0))));

    let thin_triangle = [point(max, max), point(0.0, 0.0), point(0.0, -1.0)];
    assert!(
        !Polygon::new(&thin_triangle)
            .unwrap()
            .contains(point(1.0, 0.0))
    );
}