refactor

Author: indierusty

node-graph/gcore/src/vector/algorithms/mod.rs

@@ -1,3 +1,4 @@
 mod instance;
 mod merge_by_distance;
 pub mod offset_subpath;
+pub mod position_on_bezpath;

node-graph/gcore/src/vector/algorithms/position_on_bezpath.rs

@@ -0,0 +1,96 @@
+use kurbo::{BezPath, ParamCurve, Point, Shape};
+
+pub fn position_on_bezpath(bezpath: &BezPath, t: f64, euclidian: bool) -> Point {
+	if euclidian {
+		let (segment_index, t) = t_value_to_parametric(&bezpath, BezPathTValue::GlobalEuclidean(t));
+		let segment = bezpath.get_seg(segment_index + 1).unwrap();
+		eval_pathseg_euclidian(segment, t, POSITION_ACCURACY)
+	} else {
+		let (segment_index, t) = t_value_to_parametric(&bezpath, BezPathTValue::GlobalParametric(t));
+		let segment = bezpath.get_seg(segment_index + 1).unwrap();
+		segment.eval(t)
+	}
+}
+
+/// Accuracy to find the position on [kurbo::Bezpath].
+const POSITION_ACCURACY: f64 = 1e-3;
+/// Accuracy to find the length of the [kurbo::PathSeg].
+const PERIMETER_ACCURACY: f64 = 1e-3;
+
+/// Finds the point on the given path segment i.e fractional distance along the segment's total length.
+/// It uses a binary search to find the value `t` such that the ratio `length_upto_t / total_length` approximates the input `distance`.
+fn eval_pathseg_euclidian(path: kurbo::PathSeg, distance: f64, accuracy: f64) -> kurbo::Point {
+	let mut low_t = 0.;
+	let mut hight_t = 1.;
+	let mut mid_t = 0.5;
+
+	let total_length = path.perimeter(accuracy);
+
+	if !total_length.is_finite() || total_length <= f64::EPSILON {
+		return path.start();
+	}
+
+	let distance = distance.clamp(0., 1.);
+
+	while hight_t - low_t > accuracy {
+		let current_length = path.subsegment(0.0..mid_t).perimeter(accuracy);
+		let current_distance = current_length / total_length;
+
+		if current_distance > distance {
+			hight_t = mid_t;
+		} else {
+			low_t = mid_t;
+		}
+		mid_t = (hight_t + low_t) / 2.;
+	}
+
+	path.eval(mid_t)
+}
+
+/// Converts from a bezpath (composed of multiple segments) to a point along a certain segment represented.
+/// The returned tuple represents the segment index and the `t` value along that segment.
+/// Both the input global `t` value and the output `t` value are in euclidean space, meaning there is a constant rate of change along the arc length.
+fn global_euclidean_to_local_euclidean(bezpath: &kurbo::BezPath, global_t: f64, lengths: &[f64], total_length: f64) -> (usize, f64) {
+	let mut accumulator = 0.;
+	for (index, length) in lengths.iter().enumerate() {
+		let length_ratio = length / total_length;
+		if (index == 0 || accumulator <= global_t) && global_t <= accumulator + length_ratio {
+			return (index, ((global_t - accumulator) / length_ratio).clamp(0., 1.));
+		}
+		accumulator += length_ratio;
+	}
+	(bezpath.segments().count() - 2, 1.)
+}
+
+enum BezPathTValue {
+	GlobalEuclidean(f64),
+	GlobalParametric(f64),
+}
+
+/// Convert a [BezPathTValue] to a parametric `(segment_index, t)` tuple.
+/// - Asserts that `t` values contained within the `SubpathTValue` argument lie in the range [0, 1].
+fn t_value_to_parametric(bezpath: &kurbo::BezPath, t: BezPathTValue) -> (usize, f64) {
+	let segment_len = bezpath.segments().count();
+	assert!(segment_len >= 1);
+
+	match t {
+		BezPathTValue::GlobalEuclidean(t) => {
+			let lengths = bezpath.segments().map(|bezier| bezier.perimeter(PERIMETER_ACCURACY)).collect::<Vec<f64>>();
+			let total_length: f64 = lengths.iter().sum();
+			global_euclidean_to_local_euclidean(&bezpath, t, lengths.as_slice(), total_length)
+		}
+		BezPathTValue::GlobalParametric(global_t) => {
+			assert!((0.0..=1.).contains(&global_t));
+
+			if global_t == 1. {
+				return (segment_len - 1, 1.);
+			}
+
+			let scaled_t = global_t * segment_len as f64;
+			let segment_index = scaled_t.floor() as usize;
+			let t = scaled_t - segment_index as f64;
+
+			(segment_index, t)
+		}
+	}
+}

node-graph/gcore/src/vector/misc.rs

@@ -1,6 +1,6 @@
 use dyn_any::DynAny;
-use glam::{DAffine2, DVec2};
-use kurbo::{Affine, Point};
+use glam::DVec2;
+use kurbo::Point;
 
 /// Represents different ways of calculating the centroid.
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, Hash, DynAny, specta::Type)]
@@ -111,10 +111,3 @@ pub fn point_to_dvec2(point: Point) -> DVec2 {
 pub fn dvec2_to_point(value: DVec2) -> Point {
 	Point { x: value.x, y: value.y }
 }
-
-pub fn daffine2_to_affine(value: DAffine2) -> Affine {
-	let x_axis = value.matrix2.x_axis;
-	let y_axis = value.matrix2.y_axis;
-	let translation = value.translation;
-	Affine::new([x_axis.x, x_axis.y, y_axis.x, y_axis.y, translation.x, translation.y])
-}

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

@@ -1,5 +1,6 @@
 use super::algorithms::offset_subpath::offset_subpath;
-use super::misc::{CentroidType, daffine2_to_affine, point_to_dvec2};
+use super::algorithms::position_on_bezpath::position_on_bezpath;
+use super::misc::{CentroidType, point_to_dvec2};
 use super::style::{Fill, Gradient, GradientStops, Stroke};
 use super::{PointId, SegmentDomain, SegmentId, StrokeId, VectorData, VectorDataTable};
 use crate::instances::{InstanceMut, Instances};
@@ -12,7 +13,7 @@ use crate::{CloneVarArgs, Color, Context, Ctx, ExtractAll, GraphicElement, Graph
 use bezier_rs::{Join, ManipulatorGroup, Subpath, SubpathTValue, TValue};
 use core::f64::consts::PI;
 use glam::{DAffine2, DVec2};
-use kurbo::{BezPath, ParamCurve, Shape};
+use kurbo::Affine;
 use rand::{Rng, SeedableRng};
 
 /// Implemented for types that can be converted to an iterator of vector data.
@@ -1258,79 +1259,6 @@ async fn sample_points(_: impl Ctx, vector_data: VectorDataTable, spacing: f64,
 	result
 }
 
-////////////// TODO: clean up and refactor.
-fn eval_pathseg_euclidian(path: kurbo::PathSeg, distance: f64, accuracy: f64) -> kurbo::Point {
-	let mut low_t = 0.;
-	let mut hight_t = 1.;
-	let mut mid_t = 0.5;
-
-	let total_length = path.perimeter(accuracy);
-	while hight_t - low_t > accuracy {
-		let cur_len = path.subsegment(0.0..mid_t).perimeter(accuracy);
-		let cur_distance = cur_len / total_length;
-
-		if cur_distance > distance {
-			hight_t = mid_t;
-		} else {
-			low_t = mid_t;
-		}
-		mid_t = (hight_t + low_t) / 2.;
-	}
-
-	path.eval(mid_t)
-}
-
-/// Converts from a subpath (composed of multiple segments) to a point along a certain segment represented.
-/// The returned tuple represents the segment index and the `t` value along that segment.
-/// Both the input global `t` value and the output `t` value are in euclidean space, meaning there is a constant rate of change along the arc length.
-pub fn global_euclidean_to_local_euclidean(bezpath: &kurbo::BezPath, global_t: f64, lengths: &[f64], total_length: f64) -> (usize, f64) {
-	let mut accumulator = 0.;
-	for (index, length) in lengths.iter().enumerate() {
-		let length_ratio = length / total_length;
-		if (index == 0 || accumulator <= global_t) && global_t <= accumulator + length_ratio {
-			return (index, ((global_t - accumulator) / length_ratio).clamp(0., 1.));
-		}
-		accumulator += length_ratio;
-	}
-	(bezpath.segments().count() - 2, 1.)
-}
-/// Default error bound for `t_value_to_parametric` function when TValue argument is Euclidean
-pub const DEFAULT_EUCLIDEAN_ERROR_BOUND: f64 = 0.001;
-
-/// Convert a [SubpathTValue] to a parametric `(segment_index, t)` tuple.
-/// - Asserts that `t` values contained within the `SubpathTValue` argument lie in the range [0, 1].
-/// - If the argument is a variant containing a `segment_index`, asserts that the index references a valid segment on the curve.
-// fn t_value_to_parametric(bezpath: &kurbo::BezPath, t: SubpathTValue) -> (usize, f64) {
-fn segment_index_t_value(bezpath: &kurbo::BezPath, t: SubpathTValue) -> (usize, f64) {
-	let segment_len = bezpath.segments().count();
-	assert!(segment_len >= 1);
-
-	match t {
-		SubpathTValue::GlobalEuclidean(t) => {
-			let lengths = bezpath.segments().map(|bezier| bezier.perimeter(0.01)).collect::<Vec<f64>>();
-			let total_length: f64 = lengths.iter().sum();
-			let (segment_index, segment_t_euclidean) = global_euclidean_to_local_euclidean(&bezpath, t, lengths.as_slice(), total_length);
-			// let segment_t_parametric = bezpath.get_seg(segment_index).unwrap().euclidean_to_parametric(segment_t_euclidean, DEFAULT_EUCLIDEAN_ERROR_BOUND);
-			// (segment_index, segment_t_parametric)
-			(segment_index, segment_t_euclidean)
-		}
-		SubpathTValue::GlobalParametric(global_t) => {
-			assert!((0.0..=1.).contains(&global_t));
-
-			if global_t == 1. {
-				return (segment_len - 1, 1.);
-			}
-
-			let scaled_t = global_t * segment_len as f64;
-			let segment_index = scaled_t.floor() as usize;
-			let t = scaled_t - segment_index as f64;
-
-			(segment_index, t)
-		}
-		_ => unreachable!(),
-	}
-}
-
 /// Determines the position of a point on the path, given by its progress from 0 to 1 along the path.
 /// If multiple subpaths make up the path, the whole number part of the progress value selects the subpath and the decimal part determines the position along it.
 #[node_macro::node(name("Position on Path"), category("Vector"), path(graphene_core::vector))]
@@ -1350,27 +1278,20 @@ async fn position_on_path(
 	let vector_data_transform = vector_data.transform();
 	let vector_data = vector_data.one_instance().instance;
 
-	let mut bezpaths: Vec<BezPath> = vector_data.stroke_bezpath_iter().collect();
+	let mut bezpaths: Vec<kurbo::BezPath> = vector_data.stroke_bezpath_iter().collect();
 	let bezpath_count = bezpaths.len() as f64;
 	let progress = progress.clamp(0., bezpath_count);
 	let progress = if reverse { bezpath_count - progress } else { progress };
 	let index = if progress >= bezpath_count { (bezpath_count - 1.) as usize } else { progress as usize };
 
 	bezpaths.get_mut(index).map_or(DVec2::ZERO, |bezpath| {
 		let t = if progress == bezpath_count { 1. } else { progress.fract() };
-		bezpath.apply_affine(daffine2_to_affine(vector_data_transform));
-		if euclidian {
-			let (seg_index, t) = segment_index_t_value(&bezpath, SubpathTValue::GlobalEuclidean(t));
-			let seg = bezpath.get_seg(1 + seg_index).unwrap();
-			point_to_dvec2(eval_pathseg_euclidian(seg, t, 0.001))
-		} else {
-			let (seg_index, t) = segment_index_t_value(&bezpath, SubpathTValue::GlobalParametric(t));
-			let seg = bezpath.get_seg(1 + seg_index).unwrap();
-			point_to_dvec2(seg.eval(t))
-		}
+		bezpath.apply_affine(Affine::new(vector_data_transform.to_cols_array()));
+
+		let position = position_on_bezpath(&bezpath, t, euclidian);
+		point_to_dvec2(position)
 	})
 }
-/////////////
 
 /// Determines the angle of the tangent at a point on the path, given by its progress from 0 to 1 along the path.
 /// If multiple subpaths make up the path, the whole number part of the progress value selects the subpath and the decimal part determines the position along it.