cavalier_contours 0.7.0

2D polyline/shape library for offsetting, combining, etc.
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

use cavalier_contours::core::{
    math::{LineCircleIntr::*, Vector2, line_circle_intr},
    traits::FuzzyEq,
};

macro_rules! assert_case_eq {
    ($left:expr, $right:expr) => {
        match ($left, $right) {
            (NoIntersect, NoIntersect) => {}
            (TangentIntersect { t0: a1 }, TangentIntersect { t0: a2 }) if a1.fuzzy_eq(a2) => {}
            (TwoIntersects { t0: a1, t1: b1 }, TwoIntersects { t0: a2, t1: b2 })
                if a1.fuzzy_eq(a2) && b1.fuzzy_eq(b2) => {}
            _ => panic!(
                "intersect cases do not match: left: {:?}, right: {:?}",
                $left, $right
            ),
        };
    };
}

#[test]
fn no_intersect() {
    let p0 = Vector2::new(-1.0, -1.0);
    let p1 = Vector2::new(1.0, 1.0);
    let circle_center = Vector2::new(0.0, 5.0);
    let radius = 0.5;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, NoIntersect::<f64>);
}

#[test]
fn no_intersect_vertical() {
    let p0 = Vector2::new(0.0, -1.0);
    let p1 = Vector2::new(0.0, 1.0);
    let circle_center = Vector2::new(2.0, 0.0);
    let radius = 0.5;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, NoIntersect::<f64>);
}

#[test]
fn no_intersect_horizontal() {
    let p0 = Vector2::new(1.0, 1.0);
    let p1 = Vector2::new(3.0, 1.0);
    let circle_center = Vector2::new(2.0, -2.0);
    let radius = 0.5;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, NoIntersect::<f64>);
}

#[test]
fn two_intersects_true() {
    let p0 = Vector2::new(-1.0, -1.0);
    let p1 = Vector2::new(1.0, 1.0);
    // placing edge of circle at (0, 0)
    let radius = 0.5f64;
    let offset = (radius * radius / 2.0).sqrt();
    let circle_center = Vector2::new(offset, offset);
    let expected_t1_intr_point_x = 2.0 * offset;
    let expected_t1 = (expected_t1_intr_point_x - p0.x) / (p1.x - p0.x);
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(
        result,
        TwoIntersects {
            t0: 0.5,
            t1: expected_t1
        }
    );
}

#[test]
fn two_intersects_seg_inside_vertical() {
    let p0 = Vector2::new(0.0, -1.0);
    let p1 = Vector2::new(0.0, 1.0);
    let circle_center = Vector2::new(0.0, 0.0);
    let radius = 1.0;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TwoIntersects { t0: 0.0, t1: 1.0 });
}

#[test]
fn two_intersects_seg_inside_horizontal() {
    let p0 = Vector2::new(-1.0, 0.0);
    let p1 = Vector2::new(1.0, 0.0);
    let circle_center = Vector2::new(0.0, 0.0);
    let radius = 1.0;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TwoIntersects { t0: 0.0, t1: 1.0 });
}

#[test]
fn two_intersects_seg_touching() {
    let p0 = Vector2::new(0.0, -1.0);
    let p1 = Vector2::new(0.0, 1.0);
    let circle_center = Vector2::new(0.0, 0.0);
    let radius = 1.0;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TwoIntersects { t0: 0.0, t1: 1.0 });
}

#[test]
fn tangent_intersect_vertical() {
    let p0 = Vector2::new(0.0, -1.0);
    let p1 = Vector2::new(0.0, 1.0);
    let circle_center = Vector2::new(1.0, 0.0);
    let radius = 1.0;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TangentIntersect { t0: 0.5 });
}

#[test]
fn tangent_intersect_horizontal() {
    let p0 = Vector2::new(-1.0, 0.0);
    let p1 = Vector2::new(1.0, 0.0);
    let circle_center = Vector2::new(0.0, -1.0);
    let radius = 1.0;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TangentIntersect { t0: 0.5 });
}

#[test]
fn tangent_at_start_point() {
    // this is a case that previously failed due to numeric stability issues
    let p0 = Vector2::new(161.29, 113.665);
    let p1 = Vector2::new(167.64, 113.665);
    let circle_center = Vector2::new(161.29, 114.30000000000001);
    let radius = 0.634_999_999_999_998;
    let result = line_circle_intr(p0, p1, radius, circle_center, 1e-5);
    assert_case_eq!(result, TangentIntersect { t0: 0.0 });
}