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

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

/// A feature which is the origin-centered rotation of its contained geometry.
#[derive(Debug, Clone)]
pub struct Rotate<U = super::Unit> {
    features: Vec<U>,
    rotate: f64,
}

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

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

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

    fn edge_union(&self) -> Option<MultiPolygon<f64>> {
        use geo::algorithm::rotate::Rotate;

        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().rotate(self.rotate))
            .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>> {
        use geo::algorithm::rotate::Rotate;

        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().rotate(self.rotate))
            .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 identity() {
        let a = Rotate::new(0.0, vec![Rect::with_center([0., 0.].into(), 2., 3.)]);

        assert_eq!(a.edge_subtract(), None,);

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

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

        use geo::bounding_rect::BoundingRect;
        let bounds = a.edge_union().unwrap().bounding_rect().unwrap();
        assert!(bounds.width() > 2.99);
        assert!(bounds.height() < 1.01);
    }
}