Refactor the Centroid node and Subpath struct and methods to use Kurbo, eliminating all remaining usages of Bezier-rs (#3036)

* define Subpath struct in gcore and refactor node-graph

* Refactor few methods

* refactoring worked!

* refactor centoid area and length

* remove unused

* cleanup

* fix pathseg_points function

* fix tranforming segments

* fix segment intersection

* refactor to_path_segments fn in gpath-bool crate

* refactor gcraft

* add bezier-rs dep

* Code review the editor directory

* use path-bool for solving roots

* Code review

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

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

@@ -3,7 +3,6 @@ use crate::messages::portfolio::document::node_graph::document_node_definitions;
 use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::portfolio::document::utility_types::network_interface::{FlowType, InputConnector, NodeNetworkInterface, NodeTemplate};
 use crate::messages::prelude::*;
-use bezier_rs::Subpath;
 use glam::DVec2;
 use graph_craft::document::value::TaggedValue;
 use graph_craft::document::{NodeId, NodeInput};
@@ -12,6 +11,7 @@ use graphene_std::Color;
 use graphene_std::NodeInputDecleration;
 use graphene_std::raster::BlendMode;
 use graphene_std::raster_types::{CPU, GPU, Raster};
+use graphene_std::subpath::Subpath;
 use graphene_std::table::Table;
 use graphene_std::text::{Font, TypesettingConfig};
 use graphene_std::vector::misc::ManipulatorPointId;

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

@@ -1,6 +1,6 @@
 use super::graph_modification_utils::merge_layers;
 use super::snapping::{SnapCache, SnapCandidatePoint, SnapData, SnapManager, SnappedPoint};
-use super::utility_functions::{adjust_handle_colinearity, calculate_bezier_bbox, calculate_segment_angle, restore_g1_continuity, restore_previous_handle_position};
+use super::utility_functions::{adjust_handle_colinearity, calculate_segment_angle, restore_g1_continuity, restore_previous_handle_position};
 use crate::consts::HANDLE_LENGTH_FACTOR;
 use crate::messages::portfolio::document::overlays::utility_functions::selected_segments;
 use crate::messages::portfolio::document::utility_types::document_metadata::{DocumentMetadata, LayerNodeIdentifier};
@@ -9,12 +9,15 @@ use crate::messages::portfolio::document::utility_types::network_interface::Node
 use crate::messages::preferences::SelectionMode;
 use crate::messages::prelude::*;
 use crate::messages::tool::common_functionality::snapping::SnapTypeConfiguration;
-use crate::messages::tool::common_functionality::utility_functions::{is_intersecting, is_visible_point};
+use crate::messages::tool::common_functionality::utility_functions::is_visible_point;
 use crate::messages::tool::tool_messages::path_tool::{PathOverlayMode, PointSelectState};
-use bezier_rs::{Bezier, BezierHandles, Subpath, TValue};
 use glam::{DAffine2, DVec2};
-use graphene_std::vector::misc::{HandleId, ManipulatorPointId};
+use graphene_std::subpath::{BezierHandles, Subpath};
+use graphene_std::subpath::{PathSegPoints, pathseg_points};
+use graphene_std::vector::algorithms::bezpath_algorithms::pathseg_compute_lookup_table;
+use graphene_std::vector::misc::{HandleId, ManipulatorPointId, dvec2_to_point, point_to_dvec2};
 use graphene_std::vector::{HandleExt, PointId, SegmentId, Vector, VectorModificationType};
+use kurbo::{Affine, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveNearest, PathSeg, Rect, Shape};
 use std::f64::consts::TAU;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -26,7 +29,7 @@ pub enum SelectionChange {
 
 #[derive(Clone, Copy, Debug)]
 pub enum SelectionShape<'a> {
-	Box([DVec2; 2]),
+	Box(Rect),
 	Lasso(&'a Vec<DVec2>),
 }
 
@@ -185,7 +188,7 @@ pub type OpposingHandleLengths = HashMap<LayerNodeIdentifier, HashMap<HandleId,
 pub struct ClosestSegment {
 	layer: LayerNodeIdentifier,
 	segment: SegmentId,
-	bezier: Bezier,
+	bezier: PathSeg,
 	points: [PointId; 2],
 	colinear: [Option<HandleId>; 2],
 	t: f64,
@@ -205,12 +208,12 @@ impl ClosestSegment {
 		self.points
 	}
 
-	pub fn bezier(&self) -> Bezier {
+	pub fn pathseg(&self) -> PathSeg {
 		self.bezier
 	}
 
 	pub fn closest_point_document(&self) -> DVec2 {
-		self.bezier.evaluate(TValue::Parametric(self.t))
+		point_to_dvec2(self.bezier.eval(self.t))
 	}
 
 	pub fn closest_point_to_viewport(&self) -> DVec2 {
@@ -219,7 +222,7 @@ impl ClosestSegment {
 
 	pub fn closest_point(&self, document_metadata: &DocumentMetadata, network_interface: &NodeNetworkInterface) -> DVec2 {
 		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
-		let bezier_point = self.bezier.evaluate(TValue::Parametric(self.t));
+		let bezier_point = point_to_dvec2(self.bezier.eval(self.t));
 		transform.transform_point2(bezier_point)
 	}
 
@@ -228,10 +231,10 @@ impl ClosestSegment {
 		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
 		let layer_mouse_pos = transform.inverse().transform_point2(mouse_position);
 
-		let t = self.bezier.project(layer_mouse_pos).clamp(0., 1.);
+		let t = self.bezier.nearest(dvec2_to_point(layer_mouse_pos), DEFAULT_ACCURACY).t.clamp(0., 1.);
 		self.t = t;
 
-		let bezier_point = self.bezier.evaluate(TValue::Parametric(t));
+		let bezier_point = point_to_dvec2(self.bezier.eval(t));
 		let bezier_point = transform.transform_point2(bezier_point);
 		self.bezier_point_to_viewport = bezier_point;
 	}
@@ -249,22 +252,24 @@ impl ClosestSegment {
 		let transform = document_metadata.transform_to_viewport_if_feeds(self.layer, network_interface);
 
 		// Split the Bezier at the parameter `t`
-		let [first, second] = self.bezier.split(TValue::Parametric(self.t));
+		let first = self.bezier.subsegment(0_f64..self.t);
+		let second = self.bezier.subsegment(self.t..1.);
 
 		// Transform the handle positions to viewport space
-		let first_handle = first.handle_end().map(|handle| transform.transform_point2(handle));
-		let second_handle = second.handle_start().map(|handle| transform.transform_point2(handle));
+		let first_handle = pathseg_points(first).p2.map(|handle| transform.transform_point2(handle));
+		let second_handle = pathseg_points(second).p1.map(|handle| transform.transform_point2(handle));
 
 		(first_handle, second_handle)
 	}
 
 	pub fn adjusted_insert(&self, responses: &mut VecDeque<Message>) -> (PointId, [SegmentId; 2]) {
 		let layer = self.layer;
-		let [first, second] = self.bezier.split(TValue::Parametric(self.t));
+		let first = pathseg_points(self.bezier.subsegment(0_f64..self.t));
+		let second = pathseg_points(self.bezier.subsegment(self.t..1.));
 
 		// Point
 		let midpoint = PointId::generate();
-		let modification_type = VectorModificationType::InsertPoint { id: midpoint, position: first.end };
+		let modification_type = VectorModificationType::InsertPoint { id: midpoint, position: first.p3 };
 		responses.add(GraphOperationMessage::Vector { layer, modification_type });
 
 		// First segment
@@ -272,7 +277,7 @@ impl ClosestSegment {
 		let modification_type = VectorModificationType::InsertSegment {
 			id: segment_ids[0],
 			points: [self.points[0], midpoint],
-			handles: [first.handle_start().map(|handle| handle - first.start), first.handle_end().map(|handle| handle - first.end)],
+			handles: [first.p1.map(|handle| handle - first.p0), first.p2.map(|handle| handle - first.p3)],
 		};
 		responses.add(GraphOperationMessage::Vector { layer, modification_type });
 
@@ -280,12 +285,12 @@ impl ClosestSegment {
 		let modification_type = VectorModificationType::InsertSegment {
 			id: segment_ids[1],
 			points: [midpoint, self.points[1]],
-			handles: [second.handle_start().map(|handle| handle - second.start), second.handle_end().map(|handle| handle - second.end)],
+			handles: [second.p1.map(|handle| handle - second.p0), second.p2.map(|handle| handle - second.p3)],
 		};
 		responses.add(GraphOperationMessage::Vector { layer, modification_type });
 
 		// G1 continuous on new handles
-		if self.bezier.handle_end().is_some() {
+		if pathseg_points(self.bezier).p2.is_some() {
 			let handles = [HandleId::end(segment_ids[0]), HandleId::primary(segment_ids[1])];
 			let modification_type = VectorModificationType::SetG1Continuous { handles, enabled: true };
 			responses.add(GraphOperationMessage::Vector { layer, modification_type });
@@ -353,8 +358,8 @@ impl ClosestSegment {
 	) -> Option<[Option<HandleId>; 2]> {
 		let transform = document.metadata().transform_to_viewport_if_feeds(self.layer, &document.network_interface);
 
-		let start = self.bezier.start;
-		let end = self.bezier.end;
+		let start = point_to_dvec2(self.bezier.start());
+		let end = point_to_dvec2(self.bezier.end());
 
 		// Apply the drag delta to the segment's handles
 		let b = self.bezier_point_to_viewport;
@@ -1686,9 +1691,9 @@ impl ShapeState {
 
 		let vector = network_interface.compute_modified_vector(layer)?;
 
-		for (segment, mut bezier, start, end) in vector.segment_bezier_iter() {
-			let t = bezier.project(layer_pos);
-			let layerspace = bezier.evaluate(TValue::Parametric(t));
+		for (segment_id, mut segment, start, end) in vector.segment_iter() {
+			let t = segment.nearest(dvec2_to_point(layer_pos), DEFAULT_ACCURACY).t;
+			let layerspace = point_to_dvec2(segment.eval(t));
 
 			let screenspace = transform.transform_point2(layerspace);
 			let distance_squared = screenspace.distance_squared(position);
@@ -1697,20 +1702,22 @@ impl ShapeState {
 				closest_distance_squared = distance_squared;
 
 				// Convert to linear if handes are on top of control points
-				if let bezier_rs::BezierHandles::Cubic { handle_start, handle_end } = bezier.handles {
-					if handle_start.abs_diff_eq(bezier.start(), f64::EPSILON * 100.) && handle_end.abs_diff_eq(bezier.end(), f64::EPSILON * 100.) {
-						bezier = Bezier::from_linear_dvec2(bezier.start, bezier.end);
+				let PathSegPoints { p0: _, p1, p2, p3: _ } = pathseg_points(segment);
+				if let (Some(p1), Some(p2)) = (p1, p2) {
+					let segment_points = pathseg_points(segment);
+					if p1.abs_diff_eq(segment_points.p0, f64::EPSILON * 100.) && p2.abs_diff_eq(segment_points.p3, f64::EPSILON * 100.) {
+						segment = PathSeg::Line(Line::new(segment.start(), segment.end()));
 					}
 				}
 
-				let primary_handle = vector.colinear_manipulators.iter().find(|handles| handles.contains(&HandleId::primary(segment)));
-				let end_handle = vector.colinear_manipulators.iter().find(|handles| handles.contains(&HandleId::end(segment)));
-				let primary_handle = primary_handle.and_then(|&handles| handles.into_iter().find(|handle| handle.segment != segment));
-				let end_handle = end_handle.and_then(|&handles| handles.into_iter().find(|handle| handle.segment != segment));
+				let primary_handle = vector.colinear_manipulators.iter().find(|handles| handles.contains(&HandleId::primary(segment_id)));
+				let end_handle = vector.colinear_manipulators.iter().find(|handles| handles.contains(&HandleId::end(segment_id)));
+				let primary_handle = primary_handle.and_then(|&handles| handles.into_iter().find(|handle| handle.segment != segment_id));
+				let end_handle = end_handle.and_then(|&handles| handles.into_iter().find(|handle| handle.segment != segment_id));
 
 				closest = Some(ClosestSegment {
-					segment,
-					bezier,
+					segment: segment_id,
+					bezier: segment,
 					points: [start, end],
 					colinear: [primary_handle, end_handle],
 					t,
@@ -2076,21 +2083,24 @@ impl ShapeState {
 			};
 
 			// Selection segments
-			for (id, bezier, _, _) in vector.segment_bezier_iter() {
+			for (id, segment, _, _) in vector.segment_iter() {
 				if select_segments {
 					// Select segments if they lie inside the bounding box or lasso polygon
-					let segment_bbox = calculate_bezier_bbox(bezier);
-					let bottom_left = transform.transform_point2(segment_bbox[0]);
-					let top_right = transform.transform_point2(segment_bbox[1]);
+					let transformed_segment = Affine::new(transform.to_cols_array()) * segment;
+					let segment_bbox = transformed_segment.bounding_box();
 
 					let select = match selection_shape {
-						SelectionShape::Box(quad) => {
-							let enclosed = quad[0].min(quad[1]).cmple(bottom_left).all() && quad[0].max(quad[1]).cmpge(top_right).all();
+						SelectionShape::Box(rect) => {
+							let enclosed = segment_bbox.contains_rect(rect);
 							match selection_mode {
 								SelectionMode::Enclosed => enclosed,
 								_ => {
 									// Check for intersection with the segment
-									enclosed || is_intersecting(bezier, quad, transform)
+									enclosed
+										|| rect
+											.path_segments(DEFAULT_ACCURACY)
+											.map(|seg| seg.as_line().unwrap())
+											.any(|line| !transformed_segment.intersect_line(line).is_empty())
 								}
 							}
 						}
@@ -2098,7 +2108,7 @@ impl ShapeState {
 							let polygon = polygon_subpath.as_ref().expect("If `selection_shape` is a polygon then subpath is constructed beforehand.");
 
 							// Sample 10 points on the bezier and check if all or some lie inside the polygon
-							let points = bezier.compute_lookup_table(Some(10), None);
+							let points = pathseg_compute_lookup_table(segment, Some(10), false);
 							match selection_mode {
 								SelectionMode::Enclosed => points.map(|p| transform.transform_point2(p)).all(|p| polygon.contains_point(p)),
 								_ => points.map(|p| transform.transform_point2(p)).any(|p| polygon.contains_point(p)),
@@ -2111,13 +2121,15 @@ impl ShapeState {
 					}
 				}
 
+				let segment_points = pathseg_points(segment);
+
 				// Selecting handles
-				for (position, id) in [(bezier.handle_start(), ManipulatorPointId::PrimaryHandle(id)), (bezier.handle_end(), ManipulatorPointId::EndHandle(id))] {
+				for (position, id) in [(segment_points.p1, ManipulatorPointId::PrimaryHandle(id)), (segment_points.p2, ManipulatorPointId::EndHandle(id))] {
 					let Some(position) = position else { continue };
 					let transformed_position = transform.transform_point2(position);
 
 					let select = match selection_shape {
-						SelectionShape::Box(quad) => quad[0].min(quad[1]).cmple(transformed_position).all() && quad[0].max(quad[1]).cmpge(transformed_position).all(),
+						SelectionShape::Box(rect) => rect.contains(dvec2_to_point(transformed_position)),
 						SelectionShape::Lasso(_) => polygon_subpath
 							.as_ref()
 							.expect("If `selection_shape` is a polygon then subpath is constructed beforehand.")
@@ -2139,7 +2151,7 @@ impl ShapeState {
 				let transformed_position = transform.transform_point2(position);
 
 				let select = match selection_shape {
-					SelectionShape::Box(quad) => quad[0].min(quad[1]).cmple(transformed_position).all() && quad[0].max(quad[1]).cmpge(transformed_position).all(),
+					SelectionShape::Box(rect) => rect.contains(dvec2_to_point(transformed_position)),
 					SelectionShape::Lasso(_) => polygon_subpath
 						.as_ref()
 						.expect("If `selection_shape` is a polygon then subpath is constructed beforehand.")

editor/src/messages/tool/common_functionality/shapes/shape_utility.rs

@@ -11,10 +11,10 @@ use crate::messages::tool::common_functionality::shape_editor::ShapeState;
 use crate::messages::tool::common_functionality::transformation_cage::BoundingBoxManager;
 use crate::messages::tool::tool_messages::tool_prelude::Key;
 use crate::messages::tool::utility_types::*;
-use bezier_rs::Subpath;
 use glam::{DAffine2, DMat2, DVec2};
 use graph_craft::document::NodeInput;
 use graph_craft::document::value::TaggedValue;
+use graphene_std::subpath::{self, Subpath};
 use graphene_std::vector::click_target::ClickTargetType;
 use graphene_std::vector::misc::{ArcType, dvec2_to_point};
 use kurbo::{BezPath, PathEl, Shape};
@@ -363,9 +363,9 @@ pub fn arc_outline(layer: Option<LayerNodeIdentifier>, document: &DocumentMessag
 		start_angle / 360. * std::f64::consts::TAU,
 		sweep_angle / 360. * std::f64::consts::TAU,
 		match arc_type {
-			ArcType::Open => bezier_rs::ArcType::Open,
-			ArcType::Closed => bezier_rs::ArcType::Closed,
-			ArcType::PieSlice => bezier_rs::ArcType::PieSlice,
+			ArcType::Open => subpath::ArcType::Open,
+			ArcType::Closed => subpath::ArcType::Closed,
+			ArcType::PieSlice => subpath::ArcType::PieSlice,
 		},
 	))];
 	let viewport = document.metadata().transform_to_viewport(layer);

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

@@ -10,14 +10,16 @@ use crate::messages::portfolio::document::utility_types::document_metadata::Laye
 use crate::messages::portfolio::document::utility_types::misc::{GridSnapTarget, PathSnapTarget, SnapTarget};
 use crate::messages::prelude::*;
 pub use alignment_snapper::*;
-use bezier_rs::TValue;
 pub use distribution_snapper::*;
 use glam::{DAffine2, DVec2};
 use graphene_std::renderer::Quad;
 use graphene_std::renderer::Rect;
 use graphene_std::vector::NoHashBuilder;
 use graphene_std::vector::PointId;
+use graphene_std::vector::algorithms::intersection::filtered_segment_intersections;
+use graphene_std::vector::misc::point_to_dvec2;
 pub use grid_snapper::*;
+use kurbo::ParamCurve;
 pub use layer_snapper::*;
 pub use snap_results::*;
 use std::cmp::Ordering;
@@ -81,6 +83,7 @@ impl SnapConstraint {
 		}
 	}
 }
+
 pub fn snap_tolerance(document: &DocumentMessageHandler) -> f64 {
 	document.snapping_state.tolerance / document.document_ptz.zoom()
 }
@@ -127,13 +130,16 @@ fn get_closest_point(points: Vec<SnappedPoint>) -> Option<SnappedPoint> {
 		}
 	}
 }
+
 fn get_closest_curve(curves: &[SnappedCurve], exclude_paths: bool) -> Option<&SnappedPoint> {
 	let keep_curve = |curve: &&SnappedCurve| !exclude_paths || curve.point.target != SnapTarget::Path(PathSnapTarget::AlongPath);
 	curves.iter().filter(keep_curve).map(|curve| &curve.point).min_by(compare_points)
 }
+
 fn get_closest_line(lines: &[SnappedLine]) -> Option<&SnappedPoint> {
 	lines.iter().map(|curve| &curve.point).min_by(compare_points)
 }
+
 fn get_closest_intersection(snap_to: DVec2, curves: &[SnappedCurve]) -> Option<SnappedPoint> {
 	let mut best = None;
 	for curve_i in curves {
@@ -141,8 +147,8 @@ fn get_closest_intersection(snap_to: DVec2, curves: &[SnappedCurve]) -> Option<S
 			if curve_i.start == curve_j.start && curve_i.layer == curve_j.layer {
 				continue;
 			}
-			for curve_i_t in curve_i.document_curve.intersections(&curve_j.document_curve, None, None) {
-				let snapped_point_document = curve_i.document_curve.evaluate(TValue::Parametric(curve_i_t));
+			for curve_i_t in filtered_segment_intersections(curve_i.document_curve, curve_j.document_curve, None, None) {
+				let snapped_point_document = point_to_dvec2(curve_i.document_curve.eval(curve_i_t));
 				let distance = snap_to.distance(snapped_point_document);
 				let i_closer = curve_i.point.distance < curve_j.point.distance;
 				let close = if i_closer { curve_i } else { curve_j };
@@ -165,6 +171,7 @@ fn get_closest_intersection(snap_to: DVec2, curves: &[SnappedCurve]) -> Option<S
 	}
 	best
 }
+
 fn get_grid_intersection(snap_to: DVec2, lines: &[SnappedLine]) -> Option<SnappedPoint> {
 	let mut best = None;
 	for line_i in lines {
@@ -237,6 +244,7 @@ impl<'a> SnapData<'a> {
 		self.node_snap_cache.is_some_and(|cache| !cache.manipulators.is_empty())
 	}
 }
+
 impl SnapManager {
 	pub fn update_indicator(&mut self, snapped_point: SnappedPoint) {
 		self.indicator = snapped_point.is_snapped().then_some(snapped_point);

editor/src/messages/tool/common_functionality/snapping/layer_snapper.rs

@@ -3,11 +3,17 @@ use crate::consts::HIDE_HANDLE_DISTANCE;
 use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::portfolio::document::utility_types::misc::*;
 use crate::messages::prelude::*;
-use bezier_rs::{Bezier, Identifier, Subpath, TValue};
 use glam::{DAffine2, DVec2};
 use graphene_std::math::math_ext::QuadExt;
 use graphene_std::renderer::Quad;
+use graphene_std::subpath::pathseg_points;
+use graphene_std::subpath::{Identifier, ManipulatorGroup, Subpath};
 use graphene_std::vector::PointId;
+use graphene_std::vector::algorithms::bezpath_algorithms::{pathseg_normals_to_point, pathseg_tangents_to_point};
+use graphene_std::vector::algorithms::intersection::filtered_segment_intersections;
+use graphene_std::vector::misc::dvec2_to_point;
+use graphene_std::vector::misc::point_to_dvec2;
+use kurbo::{Affine, DEFAULT_ACCURACY, Nearest, ParamCurve, ParamCurveNearest, PathSeg};
 
 #[derive(Clone, Debug, Default)]
 pub struct LayerSnapper {
@@ -37,7 +43,7 @@ impl LayerSnapper {
 			return;
 		}
 
-		for document_curve in bounds.bezier_lines() {
+		for document_curve in bounds.to_lines() {
 			self.paths_to_snap.push(SnapCandidatePath {
 				document_curve,
 				layer,
@@ -70,7 +76,7 @@ impl LayerSnapper {
 			if document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::IntersectionPoint)) || document.snapping_state.target_enabled(SnapTarget::Path(PathSnapTarget::AlongPath)) {
 				for subpath in document.metadata().layer_outline(layer) {
 					for (start_index, curve) in subpath.iter().enumerate() {
-						let document_curve = curve.apply_transformation(|p| transform.transform_point2(p));
+						let document_curve = Affine::new(transform.to_cols_array()) * curve;
 						let start = subpath.manipulator_groups()[start_index].id;
 						if snap_data.ignore_manipulator(layer, start) || snap_data.ignore_manipulator(layer, subpath.manipulator_groups()[(start_index + 1) % subpath.len()].id) {
 							continue;
@@ -98,13 +104,12 @@ impl LayerSnapper {
 
 		for path in &self.paths_to_snap {
 			// Skip very short paths
-			if path.document_curve.start.distance_squared(path.document_curve.end) < tolerance * tolerance * 2. {
+			if path.document_curve.start().distance_squared(path.document_curve.end()) < tolerance * tolerance * 2. {
 				continue;
 			}
-			let time = path.document_curve.project(point.document_point);
-			let snapped_point_document = path.document_curve.evaluate(bezier_rs::TValue::Parametric(time));
-
-			let distance = snapped_point_document.distance(point.document_point);
+			let Nearest { distance_sq, t } = path.document_curve.nearest(dvec2_to_point(point.document_point), DEFAULT_ACCURACY);
+			let snapped_point_document = point_to_dvec2(path.document_curve.eval(t));
+			let distance = distance_sq.sqrt();
 
 			if distance < tolerance {
 				snap_results.curves.push(SnappedCurve {
@@ -144,8 +149,8 @@ impl LayerSnapper {
 
 		for path in &self.paths_to_snap {
 			for constraint_path in constraint_path.iter() {
-				for time in path.document_curve.intersections(&constraint_path, None, None) {
-					let snapped_point_document = path.document_curve.evaluate(bezier_rs::TValue::Parametric(time));
+				for time in filtered_segment_intersections(path.document_curve, constraint_path, None, None) {
+					let snapped_point_document = point_to_dvec2(path.document_curve.eval(time));
 
 					let distance = snapped_point_document.distance(point.document_point);
 
@@ -266,8 +271,8 @@ impl LayerSnapper {
 fn normals_and_tangents(path: &SnapCandidatePath, normals: bool, tangents: bool, point: &SnapCandidatePoint, tolerance: f64, snap_results: &mut SnapResults) {
 	if normals && path.bounds.is_none() {
 		for &neighbor in &point.neighbors {
-			for t in path.document_curve.normals_to_point(neighbor) {
-				let normal_point = path.document_curve.evaluate(TValue::Parametric(t));
+			for t in pathseg_normals_to_point(path.document_curve, dvec2_to_point(neighbor)) {
+				let normal_point = point_to_dvec2(path.document_curve.eval(t));
 				let distance = normal_point.distance(point.document_point);
 				if distance > tolerance {
 					continue;
@@ -287,8 +292,8 @@ fn normals_and_tangents(path: &SnapCandidatePath, normals: bool, tangents: bool,
 	}
 	if tangents && path.bounds.is_none() {
 		for &neighbor in &point.neighbors {
-			for t in path.document_curve.tangents_to_point(neighbor) {
-				let tangent_point = path.document_curve.evaluate(TValue::Parametric(t));
+			for t in pathseg_tangents_to_point(path.document_curve, dvec2_to_point(neighbor)) {
+				let tangent_point = point_to_dvec2(path.document_curve.eval(t));
 				let distance = tangent_point.distance(point.document_point);
 				if distance > tolerance {
 					continue;
@@ -310,7 +315,7 @@ fn normals_and_tangents(path: &SnapCandidatePath, normals: bool, tangents: bool,
 
 #[derive(Clone, Debug)]
 struct SnapCandidatePath {
-	document_curve: Bezier,
+	document_curve: PathSeg,
 	layer: LayerNodeIdentifier,
 	start: PointId,
 	target: SnapTarget,
@@ -440,12 +445,13 @@ fn subpath_anchor_snap_points(layer: LayerNodeIdentifier, subpath: &Subpath<Poin
 			if points.len() >= crate::consts::MAX_LAYER_SNAP_POINTS {
 				return;
 			}
+			let curve = pathseg_points(curve);
 
-			let in_handle = curve.handle_start().map(|handle| handle - curve.start).filter(handle_not_under(to_document));
-			let out_handle = curve.handle_end().map(|handle| handle - curve.end).filter(handle_not_under(to_document));
+			let in_handle = curve.p1.map(|handle| handle - curve.p0).filter(handle_not_under(to_document));
+			let out_handle = curve.p2.map(|handle| handle - curve.p3).filter(handle_not_under(to_document));
 			if in_handle.is_none() && out_handle.is_none() {
 				points.push(SnapCandidatePoint::new(
-					to_document.transform_point2(curve.start() * 0.5 + curve.end * 0.5),
+					to_document.transform_point2(curve.p0 * 0.5 + curve.p3 * 0.5),
 					SnapSource::Path(PathSnapSource::LineMidpoint),
 					SnapTarget::Path(PathSnapTarget::LineMidpoint),
 					Some(layer),
@@ -487,7 +493,7 @@ fn subpath_anchor_snap_points(layer: LayerNodeIdentifier, subpath: &Subpath<Poin
 	}
 }
 
-pub fn are_manipulator_handles_colinear(manipulators: &bezier_rs::ManipulatorGroup<PointId>, to_document: DAffine2, subpath: &Subpath<PointId>, index: usize) -> bool {
+pub fn are_manipulator_handles_colinear(manipulators: &ManipulatorGroup<PointId>, to_document: DAffine2, subpath: &Subpath<PointId>, index: usize) -> bool {
 	let anchor = manipulators.anchor;
 	let handle_in = manipulators.in_handle.map(|handle| anchor - handle).filter(handle_not_under(to_document));
 	let handle_out = manipulators.out_handle.map(|handle| handle - anchor).filter(handle_not_under(to_document));

editor/src/messages/tool/common_functionality/snapping/snap_results.rs

@@ -2,11 +2,11 @@ use super::DistributionMatch;
 use crate::messages::portfolio::document::utility_types::document_metadata::LayerNodeIdentifier;
 use crate::messages::portfolio::document::utility_types::misc::{DistributionSnapTarget, SnapSource, SnapTarget};
 use crate::messages::tool::common_functionality::snapping::SnapCandidatePoint;
-use bezier_rs::Bezier;
 use glam::DVec2;
 use graphene_std::renderer::Quad;
 use graphene_std::renderer::Rect;
 use graphene_std::vector::PointId;
+use kurbo::PathSeg;
 use std::collections::VecDeque;
 
 #[derive(Clone, Debug, Default)]
@@ -120,5 +120,5 @@ pub struct SnappedCurve {
 	pub layer: LayerNodeIdentifier,
 	pub start: PointId,
 	pub point: SnappedPoint,
-	pub document_curve: Bezier,
+	pub document_curve: PathSeg,
 }

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

@@ -9,16 +9,17 @@ use crate::messages::tool::common_functionality::graph_modification_utils::{Node
 use crate::messages::tool::common_functionality::transformation_cage::SelectedEdges;
 use crate::messages::tool::tool_messages::path_tool::PathOverlayMode;
 use crate::messages::tool::utility_types::ToolType;
-use bezier_rs::{Bezier, BezierHandles};
 use glam::{DAffine2, DVec2};
 use graph_craft::concrete;
 use graph_craft::document::value::TaggedValue;
 use graphene_std::renderer::Quad;
+use graphene_std::subpath::{Bezier, BezierHandles};
 use graphene_std::table::Table;
 use graphene_std::text::{FontCache, load_font};
-use graphene_std::vector::misc::{HandleId, ManipulatorPointId};
+use graphene_std::vector::algorithms::bezpath_algorithms::pathseg_compute_lookup_table;
+use graphene_std::vector::misc::{HandleId, ManipulatorPointId, dvec2_to_point};
 use graphene_std::vector::{HandleExt, PointId, SegmentId, Vector, VectorModification, VectorModificationType};
-use kurbo::{CubicBez, Line, ParamCurveExtrema, PathSeg, Point, QuadBez};
+use kurbo::{CubicBez, DEFAULT_ACCURACY, Line, ParamCurve, PathSeg, Point, QuadBez, Shape};
 
 /// Determines if a path should be extended. Goal in viewport space. Returns the path and if it is extending from the start, if applicable.
 pub fn should_extend(
@@ -208,25 +209,6 @@ pub fn is_visible_point(
 	}
 }
 
-/// Function to find the bounding box of bezier (uses method from kurbo)
-pub fn calculate_bezier_bbox(bezier: Bezier) -> [DVec2; 2] {
-	let start = Point::new(bezier.start.x, bezier.start.y);
-	let end = Point::new(bezier.end.x, bezier.end.y);
-	let bbox = match bezier.handles {
-		BezierHandles::Cubic { handle_start, handle_end } => {
-			let p1 = Point::new(handle_start.x, handle_start.y);
-			let p2 = Point::new(handle_end.x, handle_end.y);
-			CubicBez::new(start, p1, p2, end).bounding_box()
-		}
-		BezierHandles::Quadratic { handle } => {
-			let p1 = Point::new(handle.x, handle.y);
-			QuadBez::new(start, p1, end).bounding_box()
-		}
-		BezierHandles::Linear => Line::new(start, end).bounding_box(),
-	};
-	[DVec2::new(bbox.x0, bbox.y0), DVec2::new(bbox.x1, bbox.y1)]
-}
-
 pub fn is_intersecting(bezier: Bezier, quad: [DVec2; 2], transform: DAffine2) -> bool {
 	let to_layerspace = transform.inverse();
 	let quad = [to_layerspace.transform_point2(quad[0]), to_layerspace.transform_point2(quad[1])];
@@ -496,19 +478,19 @@ pub fn log_optimization(a: f64, b: f64, p1: DVec2, p3: DVec2, d1: DVec2, d2: DVe
 	let c1 = p1 + d1 * start_handle_length;
 	let c2 = p3 + d2 * end_handle_length;
 
-	let new_curve = Bezier::from_cubic_coordinates(p1.x, p1.y, c1.x, c1.y, c2.x, c2.y, p3.x, p3.y);
+	let new_curve = PathSeg::Cubic(CubicBez::new(Point::new(p1.x, p1.y), Point::new(c1.x, c1.y), Point::new(c2.x, c2.y), Point::new(p3.x, p3.y)));
 
 	// Sample 2*n points from new curve and get the L2 metric between all of points
-	let points = new_curve.compute_lookup_table(Some(2 * n), None).collect::<Vec<_>>();
+	let points = pathseg_compute_lookup_table(new_curve, Some(2 * n), false);
 
-	let dist = points1.iter().zip(points.iter()).map(|(p1, p2)| (p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sum::<f64>();
+	let dist = points1.iter().zip(points).map(|(p1, p2)| (p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sum::<f64>();
 
 	dist / (2 * n) as f64
 }
 
 /// Calculates optimal handle lengths with adam optimization.
 #[allow(clippy::too_many_arguments)]
-pub fn find_two_param_best_approximate(p1: DVec2, p3: DVec2, d1: DVec2, d2: DVec2, min_len1: f64, min_len2: f64, farther_segment: Bezier, other_segment: Bezier) -> (DVec2, DVec2) {
+pub fn find_two_param_best_approximate(p1: DVec2, p3: DVec2, d1: DVec2, d2: DVec2, min_len1: f64, min_len2: f64, further_segment: PathSeg, other_segment: PathSeg) -> (DVec2, DVec2) {
 	let h = 1e-6;
 	let tol = 1e-6;
 	let max_iter = 200;
@@ -530,21 +512,25 @@ pub fn find_two_param_best_approximate(p1: DVec2, p3: DVec2, d1: DVec2, d2: DVec
 
 	let n = 20;
 
-	let farther_segment = if farther_segment.start.distance(p1) >= f64::EPSILON {
-		farther_segment.reverse()
+	let further_segment = if further_segment.start().distance(dvec2_to_point(p1)) >= f64::EPSILON {
+		further_segment.reverse()
 	} else {
-		farther_segment
+		further_segment
 	};
 
-	let other_segment = if other_segment.end.distance(p3) >= f64::EPSILON { other_segment.reverse() } else { other_segment };
+	let other_segment = if other_segment.end().distance(dvec2_to_point(p3)) >= f64::EPSILON {
+		other_segment.reverse()
+	} else {
+		other_segment
+	};
 
 	// Now we sample points proportional to the lengths of the beziers
-	let l1 = farther_segment.length(None);
-	let l2 = other_segment.length(None);
+	let l1 = further_segment.perimeter(DEFAULT_ACCURACY);
+	let l2 = other_segment.perimeter(DEFAULT_ACCURACY);
 	let ratio = l1 / (l1 + l2);
 	let n_points1 = ((2 * n) as f64 * ratio).floor() as usize;
-	let mut points1 = farther_segment.compute_lookup_table(Some(n_points1), None).collect::<Vec<_>>();
-	let mut points2 = other_segment.compute_lookup_table(Some(n), None).collect::<Vec<_>>();
+	let mut points1 = pathseg_compute_lookup_table(further_segment, Some(n_points1), false).collect::<Vec<_>>();
+	let mut points2 = pathseg_compute_lookup_table(other_segment, Some(n), false).collect::<Vec<_>>();
 	points1.append(&mut points2);
 
 	let f = |a: f64, b: f64| -> f64 { log_optimization(a, b, p1, p3, d1, d2, &points1, n) };