GNOME.org
 

[librsvg: 12/15] BoundsBuilder - return a new Bounds value instead of (clipped, unclipped)


commit 8e2cf0a57ab6be5f9cc09b412f2271b304571cf3
Author: Federico Mena Quintero <federico gnome org>
Date:   Thu Apr 8 17:06:53 2021 -0500

    BoundsBuilder - return a new Bounds value instead of (clipped, unclipped)
    
    This renames .into_rect() to compute(), and removes .into_irect(),
    since that is just .into_rect().clipped.into::<IRect>().

 src/filters/blend.rs              |  7 +++++--
 src/filters/bounds.rs             | 24 ++++++++++++++----------
 src/filters/color_matrix.rs       |  7 ++++++-
 src/filters/component_transfer.rs |  7 ++++++-
 src/filters/composite.rs          |  7 +++++--
 src/filters/convolve_matrix.rs    |  6 +++++-
 src/filters/displacement_map.rs   |  7 +++++--
 src/filters/flood.rs              |  3 ++-
 src/filters/gaussian_blur.rs      |  6 +++++-
 src/filters/image.rs              | 24 ++++++++----------------
 src/filters/lighting.rs           |  6 +++++-
 src/filters/merge.rs              |  2 +-
 src/filters/morphology.rs         |  6 +++++-
 src/filters/offset.rs             |  7 ++++++-
 src/filters/tile.rs               |  3 ++-
 src/filters/turbulence.rs         |  3 ++-
 16 files changed, 82 insertions(+), 43 deletions(-)
---
diff --git a/src/filters/blend.rs b/src/filters/blend.rs
index 63dadcd0..637f6539 100644
--- a/src/filters/blend.rs
+++ b/src/filters/blend.rs
@@ -8,6 +8,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node};
 use crate::parsers::{Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
@@ -89,10 +90,12 @@ impl Blend {
             &self.in2,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder
+        let bounds: IRect = bounds_builder
             .add_input(&input_1)
             .add_input(&input_2)
-            .into_irect(ctx);
+            .compute(ctx)
+            .clipped
+            .into();
 
         let surface = input_1.surface().compose(
             input_2.surface(),
diff --git a/src/filters/bounds.rs b/src/filters/bounds.rs
index c8d946e9..48fe137e 100644
--- a/src/filters/bounds.rs
+++ b/src/filters/bounds.rs
@@ -1,5 +1,5 @@
 //! Filter primitive subregion computation.
-use crate::rect::{IRect, Rect};
+use crate::rect::Rect;
 use crate::transform::Transform;
 
 use super::context::{FilterContext, FilterInput};
@@ -25,6 +25,15 @@ pub struct BoundsBuilder {
     rect: Option<Rect>,
 }
 
+/// A filter primitive's subregion.
+pub struct Bounds {
+    /// Primitive's subregion, clipped to the filter effects region.
+    pub clipped: Rect,
+
+    /// Primitive's subregion, unclipped.
+    pub unclipped: Rect,
+}
+
 impl BoundsBuilder {
     /// Constructs a new `BoundsBuilder`.
     #[inline]
@@ -71,7 +80,7 @@ impl BoundsBuilder {
     }
 
     /// Returns the final exact bounds, both with and without clipping to the effects region.
-    pub fn into_rect(self, ctx: &FilterContext) -> (Rect, Rect) {
+    pub fn compute(self, ctx: &FilterContext) -> Bounds {
         let effects_region = ctx.effects_region();
 
         // The default value is the filter effects region converted into
@@ -103,17 +112,12 @@ impl BoundsBuilder {
         }
 
         // Convert into the surface coordinate system.
-        let unclipped_rect = self.transform.transform_rect(&rect);
+        let unclipped = self.transform.transform_rect(&rect);
 
-        let clipped_rect = unclipped_rect
+        let clipped = unclipped
             .intersection(&effects_region)
             .unwrap_or_else(Rect::default);
 
-        (clipped_rect, unclipped_rect)
-    }
-
-    /// Returns the final pixel bounds, clipped to the effects region.
-    pub fn into_irect(self, ctx: &FilterContext) -> IRect {
-        self.into_rect(ctx).0.into()
+        Bounds { clipped, unclipped }
     }
 }
diff --git a/src/filters/color_matrix.rs b/src/filters/color_matrix.rs
index 73e9c939..76bd198f 100644
--- a/src/filters/color_matrix.rs
+++ b/src/filters/color_matrix.rs
@@ -9,6 +9,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node};
 use crate::parsers::{NumberList, NumberListLength, Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::surface_utils::{
     iterators::Pixels, shared_surface::ExclusiveImageSurface, ImageSurfaceDataExt, Pixel,
 };
@@ -163,7 +164,11 @@ impl ColorMatrix {
             &self.in1,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
 
         let mut surface = ExclusiveImageSurface::new(
             ctx.source_graphic().width(),
diff --git a/src/filters/component_transfer.rs b/src/filters/component_transfer.rs
index 49448723..c6031d60 100644
--- a/src/filters/component_transfer.rs
+++ b/src/filters/component_transfer.rs
@@ -10,6 +10,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node, NodeBorrow};
 use crate::parsers::{NumberList, NumberListLength, Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::surface_utils::{
     iterators::Pixels, shared_surface::ExclusiveImageSurface, ImageSurfaceDataExt, Pixel,
 };
@@ -300,7 +301,11 @@ impl ComponentTransfer {
             &self.in1,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
 
         // Create the output surface.
         let mut surface = ExclusiveImageSurface::new(
diff --git a/src/filters/composite.rs b/src/filters/composite.rs
index 082f98ac..a0707242 100644
--- a/src/filters/composite.rs
+++ b/src/filters/composite.rs
@@ -8,6 +8,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node};
 use crate::parsers::{Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
@@ -88,10 +89,12 @@ impl Composite {
             &self.in2,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder
+        let bounds: IRect = bounds_builder
             .add_input(&input_1)
             .add_input(&input_2)
-            .into_irect(ctx);
+            .compute(ctx)
+            .clipped
+            .into();
 
         let surface = if self.operator == Operator::Arithmetic {
             input_1.surface().compose_arithmetic(
diff --git a/src/filters/convolve_matrix.rs b/src/filters/convolve_matrix.rs
index 168fd993..0bfad70a 100644
--- a/src/filters/convolve_matrix.rs
+++ b/src/filters/convolve_matrix.rs
@@ -150,7 +150,11 @@ impl ConvolveMatrix {
             &self.in1,
             self.color_interpolation_filters,
         )?;
-        let mut bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let mut bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
         let original_bounds = bounds;
 
         let target_x = match self.target_x {
diff --git a/src/filters/displacement_map.rs b/src/filters/displacement_map.rs
index 31a0fb3b..2d84967b 100644
--- a/src/filters/displacement_map.rs
+++ b/src/filters/displacement_map.rs
@@ -8,6 +8,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node};
 use crate::parsers::{Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::surface_utils::{iterators::Pixels, shared_surface::ExclusiveImageSurface};
 use crate::xml::Attributes;
 
@@ -93,10 +94,12 @@ impl DisplacementMap {
             &self.in2,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder
+        let bounds: IRect = bounds_builder
             .add_input(&input_1)
             .add_input(&displacement_input)
-            .into_irect(ctx);
+            .compute(ctx)
+            .clipped
+            .into();
 
         // Displacement map's values need to be non-premultiplied.
         let displacement_surface = displacement_input.surface().unpremultiply(bounds)?;
diff --git a/src/filters/flood.rs b/src/filters/flood.rs
index 9371dcae..dee1b01a 100644
--- a/src/filters/flood.rs
+++ b/src/filters/flood.rs
@@ -3,6 +3,7 @@ use crate::drawing_ctx::DrawingCtx;
 use crate::element::{ElementResult, SetAttributes};
 use crate::node::{CascadedValues, Node};
 use crate::paint_server::resolve_color;
+use crate::rect::IRect;
 use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
@@ -34,7 +35,7 @@ impl Flood {
         _acquired_nodes: &mut AcquiredNodes<'_>,
         _draw_ctx: &mut DrawingCtx,
     ) -> Result<FilterOutput, FilterError> {
-        let bounds = bounds_builder.into_irect(ctx);
+        let bounds: IRect = bounds_builder.compute(ctx).clipped.into();
 
         let surface = ctx.source_graphic().flood(bounds, self.color)?;
 
diff --git a/src/filters/gaussian_blur.rs b/src/filters/gaussian_blur.rs
index 3699990d..6a44235b 100644
--- a/src/filters/gaussian_blur.rs
+++ b/src/filters/gaussian_blur.rs
@@ -199,7 +199,11 @@ impl GaussianBlur {
             &self.in1,
             self.color_interpolation_filters,
         )?;
-        let bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
 
         let (std_x, std_y) = self.std_deviation;
         let (std_x, std_y) = ctx.paffine().transform_distance(std_x, std_y);
diff --git a/src/filters/image.rs b/src/filters/image.rs
index d68caa54..3e2614bb 100644
--- a/src/filters/image.rs
+++ b/src/filters/image.rs
@@ -13,7 +13,7 @@ use crate::surface_utils::shared_surface::SharedImageSurface;
 use crate::viewbox::ViewBox;
 use crate::xml::Attributes;
 
-use super::bounds::BoundsBuilder;
+use super::bounds::{Bounds, BoundsBuilder};
 use super::context::{FilterContext, FilterOutput};
 use super::{FilterEffect, FilterError, Primitive, PrimitiveParams};
 
@@ -79,8 +79,7 @@ impl Image {
         ctx: &FilterContext,
         acquired_nodes: &mut AcquiredNodes<'_>,
         _draw_ctx: &DrawingCtx,
-        bounds: Rect,
-        unclipped_bounds: &Rect,
+        bounds: &Bounds,
         url: &str,
     ) -> Result<SharedImageSurface, FilterError> {
         // FIXME: translate the error better here
@@ -93,12 +92,12 @@ impl Image {
                 f64::from(image.width()),
                 f64::from(image.height()),
             )),
-            &unclipped_bounds,
+            &bounds.unclipped,
         );
 
         let surface = ctx
             .source_graphic()
-            .paint_image(bounds, &image, Some(rect))?;
+            .paint_image(bounds.clipped, &image, Some(rect))?;
 
         Ok(surface)
     }
@@ -135,27 +134,20 @@ impl Image {
         acquired_nodes: &mut AcquiredNodes<'_>,
         draw_ctx: &mut DrawingCtx,
     ) -> Result<FilterOutput, FilterError> {
-        let (bounds, unclipped_bounds) = bounds_builder.into_rect(ctx);
+        let bounds = bounds_builder.compute(ctx);
 
         let href = self.params.href.as_ref().ok_or(FilterError::InvalidInput)?;
 
         let surface = if let Ok(node_id) = NodeId::parse(href) {
             // if href has a fragment specified, render as a node
-            self.render_node(ctx, acquired_nodes, draw_ctx, bounds, &node_id)
+            self.render_node(ctx, acquired_nodes, draw_ctx, bounds.clipped, &node_id)
         } else {
-            self.render_external_image(
-                ctx,
-                acquired_nodes,
-                draw_ctx,
-                bounds,
-                &unclipped_bounds,
-                href,
-            )
+            self.render_external_image(ctx, acquired_nodes, draw_ctx, &bounds, href)
         }?;
 
         Ok(FilterOutput {
             surface,
-            bounds: bounds.into(),
+            bounds: bounds.clipped.into(),
         })
     }
 }
diff --git a/src/filters/lighting.rs b/src/filters/lighting.rs
index ea192705..fb5d6690 100644
--- a/src/filters/lighting.rs
+++ b/src/filters/lighting.rs
@@ -449,7 +449,11 @@ macro_rules! impl_lighting_filter {
                     &self.params.in1,
                     self.light.color_interpolation_filters,
                 )?;
-                let mut bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+                let mut bounds: IRect = bounds_builder
+                    .add_input(&input_1)
+                    .compute(ctx)
+                    .clipped
+                    .into();
                 let original_bounds = bounds;
 
                 let scale = self
diff --git a/src/filters/merge.rs b/src/filters/merge.rs
index 3dd679c0..bf0b4ef0 100644
--- a/src/filters/merge.rs
+++ b/src/filters/merge.rs
@@ -114,7 +114,7 @@ impl Merge {
             bounds_builder = bounds_builder.add_input(&input);
         }
 
-        let bounds = bounds_builder.into_irect(ctx);
+        let bounds: IRect = bounds_builder.compute(ctx).clipped.into();
 
         // Now merge them all.
         let mut output_surface = None;
diff --git a/src/filters/morphology.rs b/src/filters/morphology.rs
index 295e6696..073fdcf8 100644
--- a/src/filters/morphology.rs
+++ b/src/filters/morphology.rs
@@ -87,7 +87,11 @@ impl Morphology {
             &self.in1,
             ColorInterpolationFilters::Auto,
         )?;
-        let bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
 
         let (rx, ry) = self.radius;
         let (rx, ry) = ctx.paffine().transform_distance(rx, ry);
diff --git a/src/filters/offset.rs b/src/filters/offset.rs
index 98c11a72..e97369d6 100644
--- a/src/filters/offset.rs
+++ b/src/filters/offset.rs
@@ -6,6 +6,7 @@ use crate::element::{ElementResult, SetAttributes};
 use crate::node::Node;
 use crate::parsers::ParseValue;
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
@@ -64,7 +65,11 @@ impl Offset {
             &self.in1,
             ColorInterpolationFilters::Auto,
         )?;
-        let bounds = bounds_builder.add_input(&input_1).into_irect(ctx);
+        let bounds: IRect = bounds_builder
+            .add_input(&input_1)
+            .compute(ctx)
+            .clipped
+            .into();
 
         let (dx, dy) = ctx.paffine().transform_distance(self.dx, self.dy);
 
diff --git a/src/filters/tile.rs b/src/filters/tile.rs
index 1683080d..6f431fbc 100644
--- a/src/filters/tile.rs
+++ b/src/filters/tile.rs
@@ -3,6 +3,7 @@ use crate::drawing_ctx::DrawingCtx;
 use crate::element::{ElementResult, SetAttributes};
 use crate::node::Node;
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::xml::Attributes;
 
 use super::bounds::BoundsBuilder;
@@ -52,7 +53,7 @@ impl Tile {
         )?;
 
         // feTile doesn't consider its inputs in the filter primitive subregion calculation.
-        let bounds = bounds_builder.into_irect(ctx);
+        let bounds: IRect = bounds_builder.compute(ctx).clipped.into();
 
         let surface = match input_1 {
             FilterInput::StandardInput(input_surface) => input_surface,
diff --git a/src/filters/turbulence.rs b/src/filters/turbulence.rs
index f1bde0f6..02694185 100644
--- a/src/filters/turbulence.rs
+++ b/src/filters/turbulence.rs
@@ -8,6 +8,7 @@ use crate::error::*;
 use crate::node::{CascadedValues, Node};
 use crate::parsers::{NonNegative, NumberOptionalNumber, Parse, ParseValue};
 use crate::property_defs::ColorInterpolationFilters;
+use crate::rect::IRect;
 use crate::surface_utils::{
     shared_surface::{ExclusiveImageSurface, SurfaceType},
     ImageSurfaceDataExt, Pixel, PixelOps,
@@ -347,7 +348,7 @@ impl Turbulence {
         _acquired_nodes: &mut AcquiredNodes<'_>,
         _draw_ctx: &mut DrawingCtx,
     ) -> Result<FilterOutput, FilterError> {
-        let bounds = bounds_builder.into_irect(ctx);
+        let bounds: IRect = bounds_builder.compute(ctx).clipped.into();
 
         let affine = ctx.paffine().invert().unwrap();
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]