maker-panel 0.13.0

Generator for modular mechanical panels
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

use geo::{Coordinate, MultiPolygon};
use std::fmt;

/// A feature which is the negative of its contained geometry.
#[derive(Debug, Clone)]
pub struct Negative<U = super::Unit> {
    features: Vec<U>,
}

impl<U: super::Feature + fmt::Debug + Clone> Negative<U> {
    pub fn new(features: Vec<U>) -> Self {
        Self { features }
    }
}

impl<U> fmt::Display for Negative<U>
where
    U: super::Feature + fmt::Debug + Clone,
{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Negative({:?})", self.features)
    }
}

impl<U> super::Feature for Negative<U>
where
    U: super::Feature + fmt::Debug + Clone,
{
    fn name(&self) -> &'static str {
        "negative"
    }

    fn edge_union(&self) -> Option<MultiPolygon<f64>> {
        self.features
            .iter()
            .map(|f| match f.edge_subtract() {
                Some(edge_geo) => Some(edge_geo.clone()),
                None => None,
            })
            .filter(|f| f.is_some())
            .map(|f| f.unwrap())
            .fold(None, |mut acc, g| {
                use geo_booleanop::boolean::BooleanOp;
                if let Some(current) = acc {
                    acc = Some(g.union(&current));
                } else {
                    acc = Some(g);
                };
                acc
            })
    }

    fn edge_subtract(&self) -> Option<MultiPolygon<f64>> {
        self.features
            .iter()
            .map(|f| match f.edge_union() {
                Some(edge_geo) => Some(edge_geo.clone()),
                None => None,
            })
            .filter(|f| f.is_some())
            .map(|f| f.unwrap())
            .fold(None, |mut acc, g| {
                use geo_booleanop::boolean::BooleanOp;
                if let Some(current) = acc {
                    acc = Some(g.union(&current));
                } else {
                    acc = Some(g);
                };
                acc
            })
    }

    fn translate(&mut self, v: Coordinate<f64>) {
        for e in self.features.iter_mut() {
            e.translate(v);
        }
    }

    fn interior(&self) -> Vec<super::InnerAtom> {
        vec![]
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::features::{Feature, Rect};

    #[test]
    fn not_union() {
        let a = Negative::new(vec![
            Rect::with_center([0., 0.].into(), 2., 3.),
            Rect::with_center([0., 0.].into(), 3., 2.),
        ]);

        assert_eq!(a.edge_union(), None,);
        assert!(a.edge_subtract().is_some());
    }

    #[test]
    fn basic() {
        let a = Negative::new(vec![
            Rect::with_center([0., 0.].into(), 1., 1.),
            Rect::with_center([0.5, 0.].into(), 1., 1.),
        ]);

        assert_eq!(
            a.edge_subtract(),
            Some(geo::MultiPolygon::from(vec![geo::Polygon::new(
                geo::LineString(vec![
                    geo::Coordinate { x: -0.5, y: -0.5 },
                    geo::Coordinate { x: 0.0, y: -0.5 },
                    geo::Coordinate { x: 0.5, y: -0.5 },
                    geo::Coordinate { x: 1.0, y: -0.5 },
                    geo::Coordinate { x: 1.0, y: 0.5 },
                    geo::Coordinate { x: 0.5, y: 0.5 },
                    geo::Coordinate { x: 0.0, y: 0.5 },
                    geo::Coordinate { x: -0.5, y: 0.5 },
                    geo::Coordinate { x: -0.5, y: -0.5 }
                ]),
                vec![],
            )])),
        );
    }
}