Replace usvg::utils::view_box_to_transform with `usvg::ViewBox::to_…

…transform`.

CHANGELOG.md

@@ -41,6 +41,7 @@ This changelog also contains important changes in dependencies.
 - All shared nodes are stored in `Arc` and not `Rc<RefCell>` now.
 - `resvg::render_node` now includes filters bounding box. Meaning that a node with a blur filter
   no longer be clipped.
+- Replace `usvg::utils::view_box_to_transform` with `usvg::ViewBox::to_transform`.
 
 ### Removed
 - `usvg::Tree::postprocess()` and `usvg::PostProcessingSteps`. No longer needed.

crates/resvg/src/lib.rs

@@ -46,12 +46,7 @@ pub fn render(
     )
     .unwrap();
 
-    let ts = usvg::utils::view_box_to_transform(
-        tree.view_box().rect,
-        tree.view_box().aspect,
-        tree.size(),
-    );
-
+    let ts = tree.view_box().to_transform(tree.size());
     let root_transform = transform.pre_concat(ts);
 
     let ctx = render::Context { max_bbox };

crates/resvg/src/path.rs

@@ -196,7 +196,7 @@ fn render_pattern_pixmap(
 
     let mut transform = tiny_skia::Transform::from_scale(sx, sy);
     if let Some(vbox) = pattern.view_box() {
-        let ts = usvg::utils::view_box_to_transform(vbox.rect, vbox.aspect, rect.size());
+        let ts = vbox.to_transform(rect.size());
         transform = transform.pre_concat(ts);
     }
 

crates/usvg/src/parser/marker.rs

@@ -183,7 +183,7 @@ fn resolve(
 
         if let Some(vbox) = view_box {
             let size = Size::from_wh(r.width() * stroke_scale, r.height() * stroke_scale).unwrap();
-            let vbox_ts = crate::utils::view_box_to_transform(vbox.rect, vbox.aspect, size);
+            let vbox_ts = vbox.to_transform(size);
             let (sx, sy) = vbox_ts.get_scale();
             ts = ts.pre_scale(sx, sy);
         } else {

crates/usvg/src/parser/use_node.rs

@@ -8,7 +8,7 @@ use svgtypes::{Length, LengthUnit};
 
 use super::converter;
 use super::svgtree::{AId, EId, SvgNode};
-use crate::{Group, IsValidLength, Node, NonZeroRect, Path, Size, Transform};
+use crate::{Group, IsValidLength, Node, NonZeroRect, Path, Size, Transform, ViewBox};
 
 pub(crate) fn convert(
     node: SvgNode,
@@ -316,10 +316,11 @@ fn viewbox_transform(
     }
 
     let size = Size::from_wh(w, h)?;
-    let vb = linked.parse_viewbox()?;
+    let rect = linked.parse_viewbox()?;
     let aspect = linked
         .attribute(AId::PreserveAspectRatio)
         .unwrap_or_default();
+    let view_box = ViewBox { rect, aspect };
 
-    Some(crate::utils::view_box_to_transform(vb, aspect, size))
+    Some(view_box.to_transform(size))
 }

crates/usvg/src/tree/geom.rs

@@ -5,7 +5,7 @@
 use strict_num::ApproxEqUlps;
 pub use tiny_skia_path::{NonZeroRect, Rect, Size, Transform};
 
-use crate::AspectRatio;
+use crate::{Align, AspectRatio};
 
 /// Approximate zero equality comparisons.
 pub trait ApproxZeroUlps: ApproxEqUlps {
@@ -55,6 +55,44 @@ pub struct ViewBox {
     pub aspect: AspectRatio,
 }
 
+impl ViewBox {
+    /// Converts `viewBox` into `Transform`.
+    pub fn to_transform(&self, img_size: Size) -> Transform {
+        let vr = self.rect;
+
+        let sx = img_size.width() / vr.width();
+        let sy = img_size.height() / vr.height();
+
+        let (sx, sy) = if self.aspect.align == Align::None {
+            (sx, sy)
+        } else {
+            let s = if self.aspect.slice {
+                if sx < sy {
+                    sy
+                } else {
+                    sx
+                }
+            } else {
+                if sx > sy {
+                    sy
+                } else {
+                    sx
+                }
+            };
+
+            (s, s)
+        };
+
+        let x = -vr.x() * sx;
+        let y = -vr.y() * sy;
+        let w = img_size.width() - vr.width() * sx;
+        let h = img_size.height() - vr.height() * sy;
+
+        let (tx, ty) = utils::aligned_pos(self.aspect.align, x, y, w, h);
+        Transform::from_row(sx, 0.0, 0.0, sy, tx, ty)
+    }
+}
+
 /// A bounding box calculator.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct BBox {
@@ -142,49 +180,8 @@ impl BBox {
 
 /// Some useful utilities.
 pub mod utils {
-    use super::*;
     use crate::Align;
 
-    /// Converts `viewBox` to `Transform`.
-    pub fn view_box_to_transform(
-        view_box: NonZeroRect,
-        aspect: AspectRatio,
-        img_size: Size,
-    ) -> Transform {
-        let vr = view_box;
-
-        let sx = img_size.width() / vr.width();
-        let sy = img_size.height() / vr.height();
-
-        let (sx, sy) = if aspect.align == Align::None {
-            (sx, sy)
-        } else {
-            let s = if aspect.slice {
-                if sx < sy {
-                    sy
-                } else {
-                    sx
-                }
-            } else {
-                if sx > sy {
-                    sy
-                } else {
-                    sx
-                }
-            };
-
-            (s, s)
-        };
-
-        let x = -vr.x() * sx;
-        let y = -vr.y() * sy;
-        let w = img_size.width() - vr.width() * sx;
-        let h = img_size.height() - vr.height() * sy;
-
-        let (tx, ty) = aligned_pos(aspect.align, x, y, w, h);
-        Transform::from_row(sx, 0.0, 0.0, sy, tx, ty)
-    }
-
     /// Returns object aligned position.
     pub fn aligned_pos(align: Align, x: f32, y: f32, w: f32, h: f32) -> (f32, f32) {
         match align {