Refactor transform decomposition API with skew support, add 'Decompose Skew' node, and fix stroke transform interpolation (#3973)

* Refactor transform decomposition API with skew support, add Decompose Skew node, and fix stroke transform interpolation

* Fix bug in master with skew changing Area node calculated value

* Code review simplification

* More code review fixes

* Rename cases where "shear" terminology was used in place of "skew"

node-graph/graph-craft/src/document/value.rs

@@ -272,6 +272,7 @@ tagged_value! {
 	CentroidType(vector::misc::CentroidType),
 	BooleanOperation(vector::misc::BooleanOperation),
 	TextAlign(text_nodes::TextAlign),
+	ScaleType(core_types::transform::ScaleType),
 }
 
 impl TaggedValue {

node-graph/interpreted-executor/src/node_registry.rs

@@ -134,6 +134,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::transform::ReferencePoint]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::CentroidType]),
 		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::text::TextAlign]),
+		async_node!(graphene_core::memo::MonitorNode<_, _, _>, input: Context, fn_params: [Context => graphene_std::transform::ScaleType]),
 		// Context nullification
 		#[cfg(feature = "gpu")]
 		async_node!(graphene_core::context_modification::ContextModificationNode<_, _>, input: Context, fn_params: [Context => &WasmEditorApi, Context => graphene_std::ContextFeatures]),
@@ -227,6 +228,7 @@ fn node_registry() -> HashMap<ProtoNodeIdentifier, HashMap<NodeIOTypes, NodeCons
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::CentroidType]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::vector::misc::BooleanOperation]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::text::TextAlign]),
+		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => graphene_std::transform::ScaleType]),
 		async_node!(graphene_core::memo::MemoNode<_, _>, input: Context, fn_params: [Context => RenderIntermediate]),
 	];
 	// =============

node-graph/libraries/core-types/src/transform.rs

@@ -1,7 +1,21 @@
 use crate::math::bbox::AxisAlignedBbox;
 use core::f64;
+use dyn_any::DynAny;
 use glam::{DAffine2, DMat2, DVec2, UVec2};
 
+/// Controls whether the Decompose Scale node returns axis-length magnitudes or pure scale factors.
+#[repr(C)]
+#[cfg_attr(feature = "wasm", derive(tsify::Tsify))]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, node_macro::ChoiceType)]
+#[widget(Radio)]
+pub enum ScaleType {
+	/// The visual length of each axis (always positive, includes any skew contribution).
+	#[default]
+	Magnitude,
+	/// The isolated scale factors with rotation and skew stripped away (can be negative for flipped axes).
+	Pure,
+}
+
 pub trait Transform {
 	fn transform(&self) -> DAffine2;
 
@@ -9,15 +23,66 @@ pub trait Transform {
 		pivot
 	}
 
+	/// Decomposes the full transform into `(rotation, signed_scale, skew)` using a TRS+Skew factorization.
+	///
+	/// - `rotation`: angle in radians
+	/// - `signed_scale`: the algebraic scale factors (can be negative for reflections, excludes skew)
+	/// - `skew`: the horizontal shear coefficient (the raw matrix value, not an angle)
+	///
+	/// The original transform can be reconstructed as:
+	/// ```
+	/// DAffine2::from_scale_angle_translation(scale, rotation, translation) * DAffine2::from_cols_array(&[1., 0., skew, 1., 0., 0.])
+	/// ```
+	#[inline(always)]
+	fn decompose_rotation_scale_skew(&self) -> (f64, DVec2, f64) {
+		let t = self.transform();
+		let x_axis = t.matrix2.x_axis;
+		let y_axis = t.matrix2.y_axis;
+
+		let angle = x_axis.y.atan2(x_axis.x);
+		let (sin, cos) = angle.sin_cos();
+
+		let scale_x = if cos.abs() > 1e-10 { x_axis.x / cos } else { x_axis.y / sin };
+
+		let mut skew = (sin * y_axis.y + cos * y_axis.x) / scale_x;
+		if !skew.is_finite() {
+			skew = 0.;
+		}
+
+		let scale_y = if cos.abs() > 1e-10 {
+			(y_axis.y - scale_x * sin * skew) / cos
+		} else {
+			(scale_x * cos * skew - y_axis.x) / sin
+		};
+
+		(angle, DVec2::new(scale_x, scale_y), skew)
+	}
+
+	/// Extracts the rotation angle (in radians) from the transform.
+	/// This is the angle of the x-axis and is correct regardless of skew, negative scale, or non-uniform scale.
+	fn decompose_rotation(&self) -> f64 {
+		let x_axis = self.transform().matrix2.x_axis;
+		let rotation = x_axis.y.atan2(x_axis.x);
+		if rotation == -0. { 0. } else { rotation }
+	}
+
+	/// Returns the signed scale components from the TRS+Skew decomposition.
+	/// Unlike [`Self::scale_magnitudes`] which returns positive axis-length magnitudes,
+	/// this returns the algebraic scale factors which can be negative for reflections and exclude skew.
 	fn decompose_scale(&self) -> DVec2 {
+		self.decompose_rotation_scale_skew().1
+	}
+
+	/// Returns the unsigned scale as the lengths of each axis (always positive, includes skew contribution).
+	/// Use this for magnitude-based queries like stroke width scaling, zoom level, or bounding box inflation.
+	fn scale_magnitudes(&self) -> DVec2 {
 		DVec2::new(self.transform().transform_vector2(DVec2::X).length(), self.transform().transform_vector2(DVec2::Y).length())
 	}
 
-	/// Requires that the transform does not contain any skew.
-	fn decompose_rotation(&self) -> f64 {
-		let rotation_matrix = (self.transform() * DAffine2::from_scale(self.decompose_scale().recip())).matrix2;
-		let rotation = -rotation_matrix.mul_vec2(DVec2::X).angle_to(DVec2::X);
-		if rotation == -0. { 0. } else { rotation }
+	/// Returns the horizontal skew (shear) coefficient from the TRS+Skew decomposition.
+	/// This is the raw matrix coefficient. To convert to degrees: `skew.atan().to_degrees()`.
+	fn decompose_skew(&self) -> f64 {
+		self.decompose_rotation_scale_skew().2
 	}
 
 	/// Detects if the transform contains skew by checking if the transformation matrix
@@ -135,7 +200,7 @@ impl Footprint {
 	}
 
 	pub fn scale(&self) -> DVec2 {
-		self.transform.decompose_scale()
+		self.transform.scale_magnitudes()
 	}
 
 	pub fn offset(&self) -> DVec2 {

node-graph/libraries/vector-types/src/vector/click_target.rs

@@ -179,7 +179,7 @@ impl ClickTarget {
 
 				// Decompose transform into rotation, scale, translation for caching strategy
 				let rotation = transform.decompose_rotation();
-				let scale = transform.decompose_scale();
+				let scale = transform.scale_magnitudes();
 				let translation = transform.translation;
 
 				// Generate fingerprint for cache lookup

node-graph/libraries/vector-types/src/vector/style.rs

@@ -4,8 +4,10 @@ pub use crate::gradient::*;
 use core_types::Color;
 use core_types::color::Alpha;
 use core_types::table::Table;
+use core_types::transform::Transform;
 use dyn_any::DynAny;
 use glam::DAffine2;
+use std::f64::consts::{PI, TAU};
 
 /// Describes the fill of a layer.
 ///
@@ -364,10 +366,30 @@ impl Stroke {
 			join: if time < 0.5 { self.join } else { other.join },
 			join_miter_limit: self.join_miter_limit + (other.join_miter_limit - self.join_miter_limit) * time,
 			align: if time < 0.5 { self.align } else { other.align },
-			transform: DAffine2::from_mat2_translation(
-				time * self.transform.matrix2 + (1. - time) * other.transform.matrix2,
-				self.transform.translation * time + other.transform.translation * (1. - time),
-			),
+			transform: {
+				// Decompose into scale/rotation/skew and interpolate each component separately.
+				// We do this instead of linear matrix interpolation because that passes through a zero matrix
+				// (and thus a division by 0 when rendering) when transforms have opposing rotations (e.g. 0° vs 180°).
+
+				let (s_angle, s_scale, s_skew) = self.transform.decompose_rotation_scale_skew();
+				let (t_angle, t_scale, t_skew) = other.transform.decompose_rotation_scale_skew();
+
+				let lerp = |a: f64, b: f64| a + (b - a) * time;
+				let lerped_translation = self.transform.translation * (1. - time) + other.transform.translation * time;
+
+				// Shortest-arc rotation interpolation
+				let mut rotation_diff = t_angle - s_angle;
+				if rotation_diff > PI {
+					rotation_diff -= TAU;
+				} else if rotation_diff < -PI {
+					rotation_diff += TAU;
+				}
+				let lerped_angle = s_angle + rotation_diff * time;
+
+				let trs = DAffine2::from_scale_angle_translation(s_scale.lerp(t_scale, time), lerped_angle, lerped_translation);
+				let skew = DAffine2::from_cols_array(&[1., 0., lerp(s_skew, t_skew), 1., 0., 0.]);
+				trs * skew
+			},
 			paint_order: if time < 0.5 { self.paint_order } else { other.paint_order },
 		}
 	}

node-graph/libraries/vector-types/src/vector/vector_types.rs

@@ -483,7 +483,7 @@ impl<Upstream> BoundingBox for Vector<Upstream> {
 		// Include stroke by adding offset based on stroke width
 		let stroke_width = self.style.stroke().map(|s| s.weight()).unwrap_or_default();
 		let miter_limit = self.style.stroke().map(|s| s.join_miter_limit).unwrap_or(1.);
-		let scale = transform.decompose_scale();
+		let scale = transform.scale_magnitudes();
 
 		// Use the full line width to account for different styles of stroke caps
 		let offset = DVec2::splat(stroke_width * scale.x.max(scale.y) * miter_limit);

node-graph/nodes/gstd/src/pixel_preview.rs

@@ -22,7 +22,7 @@ pub async fn pixel_preview<'a: 'n>(
 	let physical_scale = render_params.scale;
 
 	let footprint = *ctx.footprint();
-	let viewport_zoom = footprint.decompose_scale().x * physical_scale;
+	let viewport_zoom = footprint.scale_magnitudes().x * physical_scale;
 
 	if render_params.render_mode != RenderMode::PixelPreview || !matches!(render_params.render_output_type, RenderOutputTypeRequest::Vello) || viewport_zoom <= 1. {
 		let context = OwnedContextImpl::from(ctx).into_context();

node-graph/nodes/gstd/src/render_cache.rs

@@ -393,7 +393,7 @@ pub async fn render_output_cache<'a: 'n>(
 	}
 
 	let device_scale = render_params.scale;
-	let zoom = footprint.decompose_scale().x;
+	let zoom = footprint.scale_magnitudes().x;
 	let rotation = footprint.decompose_rotation();
 
 	let viewport_origin_offset = footprint.transform.translation;

node-graph/nodes/gstd/src/render_node.rs

@@ -108,7 +108,7 @@ async fn create_context<'a: 'n>(
 		render_output_type,
 		footprint: Footprint::default(),
 		scale: render_config.scale,
-		viewport_zoom: footprint.decompose_scale().x,
+		viewport_zoom: footprint.scale_magnitudes().x,
 		..Default::default()
 	};
 

node-graph/nodes/raster/src/std_nodes.rs

@@ -203,7 +203,7 @@ pub fn mask(
 		.into_iter()
 		.filter_map(|mut row| {
 			let image_size = DVec2::new(row.element.width as f64, row.element.height as f64);
-			let mask_size = stencil.transform.decompose_scale();
+			let mask_size = stencil.transform.scale_magnitudes();
 
 			if mask_size == DVec2::ZERO {
 				return None;

node-graph/nodes/transform/src/transform_nodes.rs

@@ -1,7 +1,7 @@
 use core::f64;
 use core_types::color::Color;
 use core_types::table::Table;
-use core_types::transform::{ApplyTransform, Transform};
+use core_types::transform::{ApplyTransform, ScaleType, Transform};
 use core_types::{CloneVarArgs, Context, Ctx, ExtractAll, InjectFootprint, ModifyFootprint, OwnedContextImpl};
 use glam::{DAffine2, DMat2, DVec2};
 use graphic_types::Graphic;
@@ -77,7 +77,7 @@ fn reset_transform<T>(
 				row.transform.matrix2 = DMat2::IDENTITY;
 			}
 			(true, false) => {
-				let scale = row.transform.decompose_scale();
+				let scale = row.transform.scale_magnitudes();
 				row.transform.matrix2 = DMat2::from_diagonal(scale);
 			}
 			(false, true) => {
@@ -143,15 +143,24 @@ fn decompose_translation(_: impl Ctx, transform: DAffine2) -> DVec2 {
 }
 
 /// Extracts the rotation component (in degrees) from the input transform.
-/// This, together with the "Decompose Scale" node, also may jointly represent any shear component in the original transform.
 #[node_macro::node(category("Math: Transform"))]
 fn decompose_rotation(_: impl Ctx, transform: DAffine2) -> f64 {
 	transform.decompose_rotation().to_degrees()
 }
 
 /// Extracts the scale component from the input transform.
-/// This, together with the "Decompose Rotation" node, also may jointly represent any shear component in the original transform.
+/// **Magnitude** returns the visual length of each axis (always positive, includes any skew contribution).
+/// **Pure** returns the isolated scale factors with rotation and skew stripped away (can be negative for flipped axes).
 #[node_macro::node(category("Math: Transform"))]
-fn decompose_scale(_: impl Ctx, transform: DAffine2) -> DVec2 {
-	transform.decompose_scale()
+fn decompose_scale(_: impl Ctx, transform: DAffine2, scale_type: ScaleType) -> DVec2 {
+	match scale_type {
+		ScaleType::Magnitude => transform.scale_magnitudes(),
+		ScaleType::Pure => transform.decompose_scale(),
+	}
+}
+
+/// Extracts the skew angle (in degrees) from the input transform.
+#[node_macro::node(category("Math: Transform"))]
+fn decompose_skew(_: impl Ctx, transform: DAffine2) -> f64 {
+	transform.decompose_skew().atan().to_degrees()
 }

node-graph/nodes/vector/src/vector_nodes.rs

@@ -4,7 +4,7 @@ use core::hash::{Hash, Hasher};
 use core_types::bounds::{BoundingBox, RenderBoundingBox};
 use core_types::registry::types::{Angle, Length, Multiplier, Percentage, PixelLength, Progression, SeedValue};
 use core_types::table::{Table, TableRow, TableRowMut};
-use core_types::transform::{Footprint, Transform};
+use core_types::transform::Footprint;
 use core_types::{CloneVarArgs, Color, Context, Ctx, ExtractAll, OwnedContextImpl};
 use glam::{DAffine2, DVec2};
 use graphic_types::Vector;
@@ -2534,8 +2534,8 @@ async fn area(ctx: impl Ctx + CloneVarArgs + ExtractAll, content: impl Node<Cont
 	vector
 		.iter()
 		.map(|row| {
-			let scale = row.transform.decompose_scale();
-			row.element.stroke_bezpath_iter().map(|subpath| subpath.area() * scale.x * scale.y).sum::<f64>()
+			let area_scale = row.transform.matrix2.determinant().abs();
+			row.element.stroke_bezpath_iter().map(|subpath| subpath.area() * area_scale).sum::<f64>()
 		})
 		.sum()
 }