1use super::shapes2d::{Circle, Ellipse, Point2, Polygon, Rectangle, Triangle};
4use super::primitives2d::{Arc, LineSegment2, Sector};
5
6pub 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
18impl 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}