Simplify transform calcs

Author: sameer

star/src/lower/visit.rs

@@ -365,22 +365,7 @@ impl<'a, 'input, T: Turtle> XmlVisitor for ConversionVisitor<'a, 'input, T> {
                 )
             };
 
-            let corners = [
-                viewport_box.min,
-                Point::new(viewport_box.max.x, viewport_box.min.y),
-                Point::new(viewport_box.min.x, viewport_box.max.y),
-                viewport_box.max,
-            ];
-            let new_bounds = Box2D::from_points(
-                corners.map(|p| self.terrarium.current_transform.transform_point(p)),
-            );
-
-            let combined_bounds = match self.terrarium.current_bounds {
-                Some(parent) => parent.intersection(&new_bounds),
-                None => Some(new_bounds),
-            };
-
-            self.terrarium.push_bounds(combined_bounds);
+            self.terrarium.push_viewport_bounds(viewport_box);
         }
 
         if !self.should_draw_node(node) {

star/src/turtle/elements/image_ops.rs

@@ -31,17 +31,10 @@ pub fn transform_image(
     let orig_w = image.width();
     let orig_h = image.height();
 
-    let pixel_corners = [
-        point(0., 0.),
-        point(orig_w as f64, 0.),
-        point(0., orig_h as f64),
-        point(orig_w as f64, orig_h as f64),
-    ];
-    let user_corners = pixel_corners.map(|p| image_to_user.transform_point(p));
-    let user_bounds = Box2D::from_points(user_corners);
-
-    let transformed_corners = user_corners.map(|p| user_to_final.transform_point(p));
-    let transformed_box = Box2D::from_points(transformed_corners);
+    let pixel_bounds = Box2D::new(point(0., 0.), point(orig_w as f64, orig_h as f64));
+    let user_bounds = image_to_user.outer_transformed_box(&pixel_bounds);
+    let image_to_final = image_to_user.then(user_to_final);
+    let transformed_box = image_to_final.outer_transformed_box(&pixel_bounds);
 
     let (is_transform_axis_aligned, [transformed_x_axis, transformed_y_axis]) = {
         let tx = user_to_final.transform_vector(vector(1.0, 0.0));
@@ -79,7 +72,7 @@ pub fn transform_image(
         // During non-aligned rotation, the corners need to be transparent
         image = add_alpha_channel(image);
 
-        let image_to_final = image_to_user.then(user_to_final);
+
 
         let scale_x = image_to_final.transform_vector(vector(1.0, 0.0)).length();
         let scale_y = image_to_final.transform_vector(vector(0.0, 1.0)).length();

star/src/turtle/mod.rs

@@ -57,12 +57,12 @@ pub(crate) struct Terrarium<T: Turtle + std::fmt::Debug> {
     has_begun: bool,
     current_position: Point<f64>,
     initial_position: Point<f64>,
-    pub(crate) current_transform: Transform2D<f64>,
+    current_transform: Transform2D<f64>,
     pub transform_stack: Vec<Transform2D<f64>>,
     previous_quadratic_control: Option<Point<f64>>,
     previous_cubic_control: Option<Point<f64>>,
     comment: Option<String>,
-    pub(crate) current_bounds: Option<Box2D<f64>>,
+    current_bounds: Option<Box2D<f64>>,
     bounds_stack: Vec<Option<Box2D<f64>>>,
 }
 
@@ -84,6 +84,15 @@ impl<T: Turtle + std::fmt::Debug> Terrarium<T> {
         }
     }
 
+    pub fn push_viewport_bounds(&mut self, viewport_box: Box2D<f64>) {
+        let new_bounds = self.current_transform.outer_transformed_box(&viewport_box);
+        let combined_bounds = match self.current_bounds {
+            Some(parent) => parent.intersection(&new_bounds),
+            None => Some(new_bounds),
+        };
+        self.push_bounds(combined_bounds);
+    }
+
     pub fn push_bounds(&mut self, bounds: Option<Box2D<f64>>) {
         self.bounds_stack.push(self.current_bounds);
         self.current_bounds = bounds;