Bezier-rs: Updated Bezier function signatures to accept TValue (#967)

* Create helper for converting d to t values

* Add euclidean option for tangent and normal

* Modified bezier functions signatures to accept ComputeType

* Stylistic changes per review

* Added ComputeType documentation

* Renamed ComputeType to TValue

* Fixed comments

* Fixed failing unit tests

* Code review

* Fix comments in code review

* Renamed compute_type_to_parametric to t_value_to_parametric

---------

Co-authored-by: Linda Zheng <[email protected]>
Co-authored-by: Keavon Chambers <[email protected]>

Author: 3 people

editor/src/messages/tool/common_functionality/shape_editor.rs

@@ -1,6 +1,6 @@
 use crate::messages::prelude::*;
 
-use bezier_rs::ComputeType;
+use bezier_rs::TValue;
 use document_legacy::{LayerId, Operation};
 use graphene_std::vector::consts::ManipulatorType;
 use graphene_std::vector::manipulator_group::ManipulatorGroup;
@@ -296,7 +296,7 @@ impl ShapeEditor {
 		for bezier_id in document.layer(layer_path).ok()?.as_subpath()?.bezier_iter() {
 			let bezier = bezier_id.internal;
 			let t = bezier.project(layer_pos, projection_options);
-			let layerspace = bezier.evaluate(ComputeType::Parametric(t));
+			let layerspace = bezier.evaluate(TValue::Parametric(t));
 
 			let screenspace = transform.transform_point2(layerspace);
 			let distance_squared = screenspace.distance_squared(position);
@@ -314,7 +314,7 @@ impl ShapeEditor {
 	pub fn split(&self, document: &Document, position: glam::DVec2, tolerance: f64, responses: &mut VecDeque<Message>) {
 		for layer_path in &self.selected_layers {
 			if let Some((bezier_id, t)) = self.closest_segment(document, layer_path, position, tolerance) {
-				let [first, second] = bezier_id.internal.split(t);
+				let [first, second] = bezier_id.internal.split(TValue::Parametric(t));
 
 				// Adjust the first manipulator group's out handle
 				let out_handle = Operation::SetManipulatorPoints {

libraries/bezier-rs/src/bezier/core.rs

@@ -203,7 +203,7 @@ impl Bezier {
 
 #[cfg(test)]
 mod tests {
-	use crate::utils::ComputeType;
+	use crate::utils::TValue;
 
 	use super::compare::compare_points;
 	use super::*;
@@ -215,13 +215,13 @@ mod tests {
 		let p3 = DVec2::new(160., 170.);
 
 		let bezier1 = Bezier::quadratic_through_points(p1, p2, p3, None);
-		assert!(compare_points(bezier1.evaluate(ComputeType::Parametric(0.5)), p2));
+		assert!(compare_points(bezier1.evaluate(TValue::Parametric(0.5)), p2));
 
 		let bezier2 = Bezier::quadratic_through_points(p1, p2, p3, Some(0.8));
-		assert!(compare_points(bezier2.evaluate(ComputeType::Parametric(0.8)), p2));
+		assert!(compare_points(bezier2.evaluate(TValue::Parametric(0.8)), p2));
 
 		let bezier3 = Bezier::quadratic_through_points(p1, p2, p3, Some(0.));
-		assert!(compare_points(bezier3.evaluate(ComputeType::Parametric(0.)), p2));
+		assert!(compare_points(bezier3.evaluate(TValue::Parametric(0.)), p2));
 	}
 
 	#[test]
@@ -231,12 +231,12 @@ mod tests {
 		let p3 = DVec2::new(160., 160.);
 
 		let bezier1 = Bezier::cubic_through_points(p1, p2, p3, Some(0.3), Some(10.));
-		assert!(compare_points(bezier1.evaluate(ComputeType::Parametric(0.3)), p2));
+		assert!(compare_points(bezier1.evaluate(TValue::Parametric(0.3)), p2));
 
 		let bezier2 = Bezier::cubic_through_points(p1, p2, p3, Some(0.8), Some(91.7));
-		assert!(compare_points(bezier2.evaluate(ComputeType::Parametric(0.8)), p2));
+		assert!(compare_points(bezier2.evaluate(TValue::Parametric(0.8)), p2));
 
 		let bezier3 = Bezier::cubic_through_points(p1, p2, p3, Some(0.), Some(91.7));
-		assert!(compare_points(bezier3.evaluate(ComputeType::Parametric(0.)), p2));
+		assert!(compare_points(bezier3.evaluate(TValue::Parametric(0.)), p2));
 	}
 }

libraries/bezier-rs/src/bezier/lookup.rs

@@ -1,72 +1,75 @@
-use crate::utils::{f64_compare, ComputeType};
+use crate::utils::{f64_compare, TValue};
 
 use super::*;
 
 /// Functionality relating to looking up properties of the `Bezier` or points along the `Bezier`.
 impl Bezier {
-	/// Calculate the point on the curve based on the `t`-value provided.
-	pub(crate) fn unrestricted_parametric_evaluate(&self, t: f64) -> DVec2 {
-		// Basis code based off of pseudocode found here: <https://pomax.github.io/bezierinfo/#explanation>.
-
-		let t_squared = t * t;
-		let one_minus_t = 1. - t;
-		let squared_one_minus_t = one_minus_t * one_minus_t;
-
-		match self.handles {
-			BezierHandles::Linear => self.start.lerp(self.end, t),
-			BezierHandles::Quadratic { handle } => squared_one_minus_t * self.start + 2. * one_minus_t * t * handle + t_squared * self.end,
-			BezierHandles::Cubic { handle_start, handle_end } => {
-				let t_cubed = t_squared * t;
-				let cubed_one_minus_t = squared_one_minus_t * one_minus_t;
-				cubed_one_minus_t * self.start + 3. * squared_one_minus_t * t * handle_start + 3. * one_minus_t * t_squared * handle_end + t_cubed * self.end
-			}
-		}
-	}
-
-	/// Calculate the point along the curve that is a factor of `d` away from the start.
-	pub(crate) fn unrestricted_euclidean_evaluate(&self, d: f64, error: f64) -> DVec2 {
-		if let BezierHandles::Linear = self.handles {
-			return self.unrestricted_parametric_evaluate(d);
-		}
-
+	/// Convert a euclidean distance ratio along the `Bezier` curve to a parametric `t`-value.
+	pub fn euclidean_to_parametric(&self, ratio: f64, error: f64) -> f64 {
 		let mut low = 0.;
 		let mut mid = 0.;
 		let mut high = 1.;
 		let total_length = self.length(None);
 
 		while low < high {
 			mid = (low + high) / 2.;
-			let test_d = self.trim(0., mid).length(None) / total_length;
-			if f64_compare(test_d, d, error) {
+			let test_ratio = self.trim(TValue::Parametric(0.), TValue::Parametric(mid)).length(None) / total_length;
+			if f64_compare(test_ratio, ratio, error) {
 				break;
-			} else if test_d < d {
+			} else if test_ratio < ratio {
 				low = mid;
 			} else {
 				high = mid;
 			}
 		}
-		self.unrestricted_parametric_evaluate(mid)
+
+		mid
 	}
 
-	/// Calculate the point on the curve based on the `t`-value provided.
-	/// Expects `t` to be within the inclusive range `[0, 1]`.
-	pub fn evaluate(&self, t: ComputeType) -> DVec2 {
+	/// Convert a [TValue] to a parametric `t`-value.
+	pub(crate) fn t_value_to_parametric(&self, t: TValue) -> f64 {
 		match t {
-			ComputeType::Parametric(t) => {
+			TValue::Parametric(t) => {
 				assert!((0.0..=1.).contains(&t));
-				self.unrestricted_parametric_evaluate(t)
+				t
 			}
-			ComputeType::Euclidean(t) => {
+			TValue::Euclidean(t) => {
 				assert!((0.0..=1.).contains(&t));
-				self.unrestricted_euclidean_evaluate(t, 0.0001)
+				self.euclidean_to_parametric(t, DEFAULT_EUCLIDEAN_ERROR_BOUND)
 			}
-			ComputeType::EuclideanWithinError { t, epsilon } => {
+			TValue::EuclideanWithinError { t, error } => {
 				assert!((0.0..=1.).contains(&t));
-				self.unrestricted_euclidean_evaluate(t, epsilon)
+				self.euclidean_to_parametric(t, error)
 			}
 		}
 	}
 
+	/// Calculate the point on the curve based on the `t`-value provided.
+	pub(crate) fn unrestricted_parametric_evaluate(&self, t: f64) -> DVec2 {
+		// Basis code based off of pseudocode found here: <https://pomax.github.io/bezierinfo/#explanation>.
+
+		let t_squared = t * t;
+		let one_minus_t = 1. - t;
+		let squared_one_minus_t = one_minus_t * one_minus_t;
+
+		match self.handles {
+			BezierHandles::Linear => self.start.lerp(self.end, t),
+			BezierHandles::Quadratic { handle } => squared_one_minus_t * self.start + 2. * one_minus_t * t * handle + t_squared * self.end,
+			BezierHandles::Cubic { handle_start, handle_end } => {
+				let t_cubed = t_squared * t;
+				let cubed_one_minus_t = squared_one_minus_t * one_minus_t;
+				cubed_one_minus_t * self.start + 3. * squared_one_minus_t * t * handle_start + 3. * one_minus_t * t_squared * handle_end + t_cubed * self.end
+			}
+		}
+	}
+
+	/// Calculate the coordinates of the point `t` along the curve.
+	/// Expects `t` to be within the inclusive range `[0, 1]`.
+	pub fn evaluate(&self, t: TValue) -> DVec2 {
+		let t = self.t_value_to_parametric(t);
+		self.unrestricted_parametric_evaluate(t)
+	}
+
 	/// Return a selection of equidistant points on the bezier curve.
 	/// If no value is provided for `steps`, then the function will default `steps` to be 10.
 	pub fn compute_lookup_table(&self, steps: Option<usize>) -> Vec<DVec2> {
@@ -75,7 +78,7 @@ impl Bezier {
 		let mut steps_array = Vec::with_capacity(steps_unwrapped + 1);
 
 		for t in 0..steps_unwrapped + 1 {
-			steps_array.push(self.evaluate(ComputeType::Parametric(f64::from(t as i32) * ratio)))
+			steps_array.push(self.evaluate(TValue::Parametric(f64::from(t as i32) * ratio)))
 		}
 
 		steps_array
@@ -107,7 +110,7 @@ impl Bezier {
 		}
 	}
 
-	/// Returns the `t` value that corresponds to the closest point on the curve to the provided point.
+	/// Returns the parametric `t`-value that corresponds to the closest point on the curve to the provided point.
 	/// Uses a searching algorithm akin to binary search that can be customized using the [ProjectionOptions] structure.
 	pub fn project(&self, point: DVec2, options: ProjectionOptions) -> f64 {
 		let ProjectionOptions {
@@ -162,7 +165,7 @@ impl Bezier {
 				if step_index == 0 {
 					distance = *table_distance;
 				} else {
-					distance = point.distance(self.evaluate(ComputeType::Parametric(iterator_t)));
+					distance = point.distance(self.evaluate(TValue::Parametric(iterator_t)));
 					*table_distance = distance;
 				}
 				if distance < new_minimum_distance {
@@ -212,27 +215,27 @@ mod tests {
 		let p4 = DVec2::new(30., 21.);
 
 		let bezier1 = Bezier::from_quadratic_dvec2(p1, p2, p3);
-		assert_eq!(bezier1.evaluate(ComputeType::Parametric(0.5)), DVec2::new(12.5, 6.25));
+		assert_eq!(bezier1.evaluate(TValue::Parametric(0.5)), DVec2::new(12.5, 6.25));
 
 		let bezier2 = Bezier::from_cubic_dvec2(p1, p2, p3, p4);
-		assert_eq!(bezier2.evaluate(ComputeType::Parametric(0.5)), DVec2::new(16.5, 9.625));
+		assert_eq!(bezier2.evaluate(TValue::Parametric(0.5)), DVec2::new(16.5, 9.625));
 	}
 
 	#[test]
 	fn test_compute_lookup_table() {
 		let bezier1 = Bezier::from_quadratic_coordinates(10., 10., 30., 30., 50., 10.);
 		let lookup_table1 = bezier1.compute_lookup_table(Some(2));
-		assert_eq!(lookup_table1, vec![bezier1.start(), bezier1.evaluate(ComputeType::Parametric(0.5)), bezier1.end()]);
+		assert_eq!(lookup_table1, vec![bezier1.start(), bezier1.evaluate(TValue::Parametric(0.5)), bezier1.end()]);
 
 		let bezier2 = Bezier::from_cubic_coordinates(10., 10., 30., 30., 70., 70., 90., 10.);
 		let lookup_table2 = bezier2.compute_lookup_table(Some(4));
 		assert_eq!(
 			lookup_table2,
 			vec![
 				bezier2.start(),
-				bezier2.evaluate(ComputeType::Parametric(0.25)),
-				bezier2.evaluate(ComputeType::Parametric(0.50)),
-				bezier2.evaluate(ComputeType::Parametric(0.75)),
+				bezier2.evaluate(TValue::Parametric(0.25)),
+				bezier2.evaluate(TValue::Parametric(0.50)),
+				bezier2.evaluate(TValue::Parametric(0.75)),
 				bezier2.end()
 			]
 		);