Skip to main content

mathverse_geometry/
transforms.rs

1//! Shape transforms: rotation, scaling, translation for 2D shapes.
2
3use super::shapes2d::{Circle, Ellipse, Point2, Polygon, Rectangle, Triangle};
4use super::primitives2d::{Arc, LineSegment2, Sector};
5
6// ---------------------------------------------------------------------------
7// Transform2D trait
8// ---------------------------------------------------------------------------
9
10/// Generic transform for 2D shapes.
11pub trait Transform2D {
12    fn translate(self, dx: f64, dy: f64) -> Self;
13    fn scale_xy(self, sx: f64, sy: f64) -> Self;
14    fn rotate(self, angle: f64) -> Self;
15    fn rotate_around(self, angle: f64, center: Point2) -> Self;
16}
17
18// ---------------------------------------------------------------------------
19// Implementations
20// ---------------------------------------------------------------------------
21
22impl Transform2D for Point2 {
23    fn translate(self, dx: f64, dy: f64) -> Self {
24        self.translate(dx, dy)
25    }
26    fn scale_xy(self, sx: f64, sy: f64) -> Self {
27        Point2::new(self.x * sx, self.y * sy)
28    }
29    fn rotate(self, angle: f64) -> Self {
30        self.rotate(angle)
31    }
32    fn rotate_around(self, angle: f64, center: Point2) -> Self {
33        self.rotate_around(angle, center)
34    }
35}
36
37impl Transform2D for LineSegment2 {
38    fn translate(self, dx: f64, dy: f64) -> Self {
39        Self::new(self.a.translate(dx, dy), self.b.translate(dx, dy))
40    }
41    fn scale_xy(self, sx: f64, sy: f64) -> Self {
42        Self::new(
43            Point2::new(self.a.x * sx, self.a.y * sy),
44            Point2::new(self.b.x * sx, self.b.y * sy),
45        )
46    }
47    fn rotate(self, angle: f64) -> Self {
48        Self::new(self.a.rotate(angle), self.b.rotate(angle))
49    }
50    fn rotate_around(self, angle: f64, center: Point2) -> Self {
51        Self::new(self.a.rotate_around(angle, center), self.b.rotate_around(angle, center))
52    }
53}
54
55impl Transform2D for Circle {
56    fn translate(self, dx: f64, dy: f64) -> Self {
57        Self::new(self.center.translate(dx, dy), self.radius)
58    }
59    fn scale_xy(self, sx: f64, sy: f64) -> Self {
60        let s = (sx.abs() * sy.abs()).sqrt();
61        Self::new(Point2::new(self.center.x * sx, self.center.y * sy), self.radius * s)
62    }
63    fn rotate(self, _angle: f64) -> Self {
64        self
65    }
66    fn rotate_around(self, angle: f64, center: Point2) -> Self {
67        Self::new(self.center.rotate_around(angle, center), self.radius)
68    }
69}
70
71impl Transform2D for Rectangle {
72    fn translate(self, dx: f64, dy: f64) -> Self {
73        Self::new(self.x + dx, self.y + dy, self.width, self.height)
74    }
75    fn scale_xy(self, sx: f64, sy: f64) -> Self {
76        Self::new(self.x * sx, self.y * sy, self.width * sx.abs(), self.height * sy.abs())
77    }
78    fn rotate(self, angle: f64) -> Self {
79        let c = self.centroid();
80        self.rotate_around(angle, c)
81    }
82    fn rotate_around(self, angle: f64, center: Point2) -> Self {
83        let c = self.centroid();
84        let new_center = c.rotate_around(angle, center);
85        Self::new(
86            new_center.x - self.width / 2.0,
87            new_center.y - self.height / 2.0,
88            self.width,
89            self.height,
90        )
91    }
92}
93
94impl Transform2D for Triangle {
95    fn translate(self, dx: f64, dy: f64) -> Self {
96        Self::new(self.a.translate(dx, dy), self.b.translate(dx, dy), self.c.translate(dx, dy))
97    }
98    fn scale_xy(self, sx: f64, sy: f64) -> Self {
99        Self::new(
100            Point2::new(self.a.x * sx, self.a.y * sy),
101            Point2::new(self.b.x * sx, self.b.y * sy),
102            Point2::new(self.c.x * sx, self.c.y * sy),
103        )
104    }
105    fn rotate(self, angle: f64) -> Self {
106        Self::new(self.a.rotate(angle), self.b.rotate(angle), self.c.rotate(angle))
107    }
108    fn rotate_around(self, angle: f64, center: Point2) -> Self {
109        Self::new(self.a.rotate_around(angle, center), self.b.rotate_around(angle, center), self.c.rotate_around(angle, center))
110    }
111}
112
113impl Transform2D for Polygon {
114    fn translate(self, dx: f64, dy: f64) -> Self {
115        Self::new(self.points.into_iter().map(|p| p.translate(dx, dy)).collect())
116    }
117    fn scale_xy(self, sx: f64, sy: f64) -> Self {
118        Self::new(self.points.into_iter().map(|p| Point2::new(p.x * sx, p.y * sy)).collect())
119    }
120    fn rotate(self, angle: f64) -> Self {
121        Self::new(self.points.into_iter().map(|p| p.rotate(angle)).collect())
122    }
123    fn rotate_around(self, angle: f64, center: Point2) -> Self {
124        Self::new(self.points.into_iter().map(|p| p.rotate_around(angle, center)).collect())
125    }
126}
127
128impl Transform2D for Ellipse {
129    fn translate(self, dx: f64, dy: f64) -> Self {
130        Self::new(self.center.translate(dx, dy), self.rx, self.ry)
131    }
132    fn scale_xy(self, sx: f64, sy: f64) -> Self {
133        Self::new(Point2::new(self.center.x * sx, self.center.y * sy), self.rx * sx.abs(), self.ry * sy.abs())
134    }
135    fn rotate(self, _angle: f64) -> Self {
136        self
137    }
138    fn rotate_around(self, angle: f64, center: Point2) -> Self {
139        Self::new(self.center.rotate_around(angle, center), self.rx, self.ry)
140    }
141}
142
143impl Transform2D for Arc {
144    fn translate(self, dx: f64, dy: f64) -> Self {
145        Self::new(self.center.translate(dx, dy), self.radius, self.start, self.sweep)
146    }
147    fn scale_xy(self, sx: f64, sy: f64) -> Self {
148        let s = (sx.abs() * sy.abs()).sqrt();
149        Self::new(Point2::new(self.center.x * sx, self.center.y * sy), self.radius * s, self.start, self.sweep)
150    }
151    fn rotate(self, angle: f64) -> Self {
152        Self::new(self.center, self.radius, self.start + angle, self.sweep)
153    }
154    fn rotate_around(self, angle: f64, center: Point2) -> Self {
155        Self::new(self.center.rotate_around(angle, center), self.radius, self.start + angle, self.sweep)
156    }
157}
158
159impl Transform2D for Sector {
160    fn translate(self, dx: f64, dy: f64) -> Self {
161        Self::new(self.center.translate(dx, dy), self.radius, self.start, self.sweep)
162    }
163    fn scale_xy(self, sx: f64, sy: f64) -> Self {
164        let s = (sx.abs() * sy.abs()).sqrt();
165        Self::new(Point2::new(self.center.x * sx, self.center.y * sy), self.radius * s, self.start, self.sweep)
166    }
167    fn rotate(self, angle: f64) -> Self {
168        Self::new(self.center, self.radius, self.start + angle, self.sweep)
169    }
170    fn rotate_around(self, angle: f64, center: Point2) -> Self {
171        Self::new(self.center.rotate_around(angle, center), self.radius, self.start + angle, self.sweep)
172    }
173}
174
175#[cfg(test)]
176mod tests {
177    use super::*;
178    use super::super::shapes2d::Polygon;
179
180    fn pt(x: f64, y: f64) -> Point2 { Point2::new(x, y) }
181
182    #[test]
183    fn translate_triangle() {
184        let t = Triangle::new(pt(0.0, 0.0), pt(1.0, 0.0), pt(0.0, 1.0));
185        let moved = t.translate(2.0, 3.0);
186        assert_eq!(moved.a, pt(2.0, 3.0));
187        assert_eq!(moved.b, pt(3.0, 3.0));
188        assert_eq!(moved.c, pt(2.0, 4.0));
189    }
190
191    #[test]
192    fn rotate_polygon() {
193        use mathverse_core::constants::PI;
194        let sq = Polygon::new(vec![pt(0.0, 0.0), pt(1.0, 0.0), pt(1.0, 1.0), pt(0.0, 1.0)]);
195        let rotated = sq.clone().rotate(PI);
196        for (orig, rot) in sq.points.iter().zip(rotated.points.iter()) {
197            let expected = orig.rotate(PI);
198            assert!((rot.x - expected.x).abs() < 1e-12);
199            assert!((rot.y - expected.y).abs() < 1e-12);
200        }
201    }
202
203    #[test]
204    fn circle_translate() {
205        let c = Circle::new(pt(0.0, 0.0), 1.0);
206        let moved = c.translate(3.0, 4.0);
207        assert_eq!(moved.center, pt(3.0, 4.0));
208        assert_eq!(moved.radius, 1.0);
209    }
210}