gdsr 0.0.1-alpha.3

A GDSII reader and writer for Rust
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

use crate::{Point, elements::polygon::get_correct_polygon_points_format};

/// Check if a point is strictly inside a polygon.
///
/// Uses the [ray casting algorithm](https://en.wikipedia.org/wiki/Point_in_polygon#Ray_casting_algorithm).
/// Points on the boundary are not considered inside.
pub fn is_point_inside(point: &Point, points: &[Point]) -> bool {
    if points.len() < 3 {
        return false;
    }

    let closed = get_correct_polygon_points_format(points.to_vec());

    let px = point.x().float_value();
    let py = point.y().float_value();
    let n = closed.len() - 1;

    // Exclude points on the boundary (edges and vertices)
    for i in 0..n {
        let xi = closed[i].x().float_value();
        let yi = closed[i].y().float_value();
        let xn = closed[i + 1].x().float_value();
        let yn = closed[i + 1].y().float_value();

        let cross = (px - xi) * (yn - yi) - (py - yi) * (xn - xi);
        if cross.abs() <= 1e-10 {
            let in_x = px >= xi.min(xn) && px <= xi.max(xn);
            let in_y = py >= yi.min(yn) && py <= yi.max(yn);
            if in_x && in_y {
                return false;
            }
        }
    }

    // Ray casting
    let mut inside = false;
    let mut j = n - 1;

    for i in 0..n {
        let xi = closed[i].x().float_value();
        let yi = closed[i].y().float_value();
        let xj = closed[j].x().float_value();
        let yj = closed[j].y().float_value();

        if ((yi > py) != (yj > py)) && (px < (xj - xi) * (py - yi) / (yj - yi) + xi) {
            inside = !inside;
        }
        j = i;
    }

    inside
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_point_inside() {
        let square = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(2.0, 0.0, 1e-6),
            Point::float(2.0, 2.0, 1e-6),
            Point::float(0.0, 2.0, 1e-6),
        ];

        assert!(is_point_inside(&Point::integer(1, 1, 1e-9), &square));
        assert!(!is_point_inside(&Point::integer(3, 3, 1e-9), &square));
    }

    #[test]
    fn test_point_inside_too_few_points() {
        let square = [Point::float(0.0, 0.0, 1e-6), Point::float(2.0, 0.0, 1e-6)];
        assert!(!is_point_inside(&Point::integer(0, 0, 1e-9), &square));
    }

    #[test]
    fn test_point_inside_edge_cases() {
        let square = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(2.0, 0.0, 1e-6),
            Point::float(2.0, 2.0, 1e-6),
            Point::float(0.0, 2.0, 1e-6),
        ];

        assert!(!is_point_inside(&Point::float(0.0, 0.0, 1e-6), &square));
        assert!(!is_point_inside(&Point::float(1.0, 0.0, 1e-6), &square));
        assert!(is_point_inside(&Point::float(1.0, 1.0, 1e-6), &square));
        assert!(!is_point_inside(&Point::float(-1.0, 1.0, 1e-6), &square));
        assert!(!is_point_inside(&Point::float(3.0, 1.0, 1e-6), &square));
    }

    #[test]
    fn test_is_point_inside_concave_polygon() {
        let concave = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(4.0, 0.0, 1e-6),
            Point::float(4.0, 4.0, 1e-6),
            Point::float(2.0, 2.0, 1e-6),
            Point::float(0.0, 4.0, 1e-6),
        ];
        assert!(is_point_inside(&Point::float(1.0, 1.0, 1e-6), &concave));
        assert!(!is_point_inside(&Point::float(2.0, 3.0, 1e-6), &concave));
    }
}

#[cfg(test)]
mod property_tests {
    use super::*;
    use quickcheck_macros::quickcheck;

    /// Points far outside a polygon centered at the origin should never be inside.
    #[quickcheck]
    fn far_away_point_is_outside(offset: u16) -> bool {
        let square = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(1.0, 0.0, 1e-6),
            Point::float(1.0, 1.0, 1e-6),
            Point::float(0.0, 1.0, 1e-6),
        ];
        let far = f64::from(offset) + 2.0;
        !is_point_inside(&Point::float(far, far, 1e-6), &square)
    }

    /// The centroid of a convex axis-aligned rectangle should be inside.
    #[quickcheck]
    fn centroid_of_rectangle_is_inside(w: u8, h: u8) -> bool {
        let w = f64::from(w.max(1));
        let h = f64::from(h.max(1));
        let rect = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(w, 0.0, 1e-6),
            Point::float(w, h, 1e-6),
            Point::float(0.0, h, 1e-6),
        ];
        is_point_inside(&Point::float(w / 2.0, h / 2.0, 1e-6), &rect)
    }
}