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>

node-graph/gcore/Cargo.toml

@@ -29,7 +29,6 @@ rustc-hash = { workspace = true }
 dyn-any = { workspace = true }
 ctor = { workspace = true }
 rand_chacha = { workspace = true }
-bezier-rs = { workspace = true }
 specta = { workspace = true }
 image = { workspace = true }
 tinyvec = { workspace = true }
@@ -38,6 +37,7 @@ skrifa = { workspace = true }
 kurbo = { workspace = true }
 log = { workspace = true }
 base64 = { workspace = true }
+poly-cool = { workspace = true }
 
 # Optional workspace dependencies
 serde = { workspace = true, optional = true }

node-graph/gcore/src/lib.rs

@@ -22,6 +22,7 @@ pub mod raster_types;
 pub mod registry;
 pub mod render_complexity;
 pub mod structural;
+pub mod subpath;
 pub mod table;
 pub mod text;
 pub mod transform;

node-graph/gcore/src/math/math_ext.rs

@@ -1,16 +1,23 @@
 use crate::math::quad::Quad;
 use crate::math::rect::Rect;
-use bezier_rs::Bezier;
+use crate::subpath::Bezier;
+use crate::vector::misc::dvec2_to_point;
+use kurbo::{Line, PathSeg};
 
 pub trait QuadExt {
 	/// Get all the edges in the rect as linear bezier curves
 	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_;
+	fn to_lines(&self) -> impl Iterator<Item = PathSeg>;
 }
 
 impl QuadExt for Quad {
 	fn bezier_lines(&self) -> impl Iterator<Item = Bezier> + '_ {
 		self.all_edges().into_iter().map(|[start, end]| Bezier::from_linear_dvec2(start, end))
 	}
+
+	fn to_lines(&self) -> impl Iterator<Item = PathSeg> {
+		self.all_edges().into_iter().map(|[start, end]| PathSeg::Line(Line::new(dvec2_to_point(start), dvec2_to_point(end))))
+	}
 }
 
 pub trait RectExt {

node-graph/gcore/src/math/mod.rs

@@ -1,4 +1,5 @@
 pub mod bbox;
 pub mod math_ext;
+pub mod polynomial;
 pub mod quad;
 pub mod rect;

node-graph/gcore/src/math/polynomial.rs

@@ -0,0 +1,292 @@
+use kurbo::PathSeg;
+use std::fmt::{self, Display, Formatter};
+use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+
+/// A struct that represents a polynomial with a maximum degree of `N-1`.
+///
+/// It provides basic mathematical operations for polynomials like addition, multiplication, differentiation, integration, etc.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Polynomial<const N: usize> {
+	coefficients: [f64; N],
+}
+
+impl<const N: usize> Polynomial<N> {
+	/// Create a new polynomial from the coefficients given in the array.
+	///
+	/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
+	pub fn new(coefficients: [f64; N]) -> Polynomial<N> {
+		Polynomial { coefficients }
+	}
+
+	/// Create a polynomial where all its coefficients are zero.
+	pub fn zero() -> Polynomial<N> {
+		Polynomial { coefficients: [0.; N] }
+	}
+
+	/// Return an immutable reference to the coefficients.
+	///
+	/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
+	pub fn coefficients(&self) -> &[f64; N] {
+		&self.coefficients
+	}
+
+	/// Return a mutable reference to the coefficients.
+	///
+	/// The coefficient for nth degree is at the nth index in array. Therefore the order of coefficients are reversed than the usual order for writing polynomials mathematically.
+	pub fn coefficients_mut(&mut self) -> &mut [f64; N] {
+		&mut self.coefficients
+	}
+
+	/// Evaluate the polynomial at `value`.
+	pub fn eval(&self, value: f64) -> f64 {
+		self.coefficients.iter().rev().copied().reduce(|acc, x| acc * value + x).unwrap()
+	}
+
+	/// Return the same polynomial but with a different maximum degree of `M-1`.\
+	///
+	/// Returns `None` if the polynomial cannot fit in the specified size.
+	pub fn as_size<const M: usize>(&self) -> Option<Polynomial<M>> {
+		let mut coefficients = [0.; M];
+
+		if M >= N {
+			coefficients[..N].copy_from_slice(&self.coefficients);
+		} else if self.coefficients.iter().rev().take(N - M).all(|&x| x == 0.) {
+			coefficients.copy_from_slice(&self.coefficients[..M])
+		} else {
+			return None;
+		}
+
+		Some(Polynomial { coefficients })
+	}
+
+	/// Computes the derivative in place.
+	pub fn derivative_mut(&mut self) {
+		self.coefficients.iter_mut().enumerate().for_each(|(index, x)| *x *= index as f64);
+		self.coefficients.rotate_left(1);
+	}
+
+	/// Computes the antiderivative at `C = 0` in place.
+	///
+	/// Returns `None` if the polynomial is not big enough to accommodate the extra degree.
+	pub fn antiderivative_mut(&mut self) -> Option<()> {
+		if self.coefficients[N - 1] != 0. {
+			return None;
+		}
+		self.coefficients.rotate_right(1);
+		self.coefficients.iter_mut().enumerate().skip(1).for_each(|(index, x)| *x /= index as f64);
+		Some(())
+	}
+
+	/// Computes the polynomial's derivative.
+	pub fn derivative(&self) -> Polynomial<N> {
+		let mut ans = *self;
+		ans.derivative_mut();
+		ans
+	}
+
+	/// Computes the antiderivative at `C = 0`.
+	///
+	/// Returns `None` if the polynomial is not big enough to accommodate the extra degree.
+	pub fn antiderivative(&self) -> Option<Polynomial<N>> {
+		let mut ans = *self;
+		ans.antiderivative_mut()?;
+		Some(ans)
+	}
+}
+
+impl<const N: usize> Default for Polynomial<N> {
+	fn default() -> Self {
+		Self::zero()
+	}
+}
+
+impl<const N: usize> Display for Polynomial<N> {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		let mut first = true;
+		for (index, coefficient) in self.coefficients.iter().enumerate().rev().filter(|&(_, &coefficient)| coefficient != 0.) {
+			if first {
+				first = false;
+			} else {
+				f.write_str(" + ")?
+			}
+
+			coefficient.fmt(f)?;
+			if index == 0 {
+				continue;
+			}
+			f.write_str("x")?;
+			if index == 1 {
+				continue;
+			}
+			f.write_str("^")?;
+			index.fmt(f)?;
+		}
+
+		Ok(())
+	}
+}
+
+impl<const N: usize> AddAssign<&Polynomial<N>> for Polynomial<N> {
+	fn add_assign(&mut self, rhs: &Polynomial<N>) {
+		self.coefficients.iter_mut().zip(rhs.coefficients.iter()).for_each(|(a, b)| *a += b);
+	}
+}
+
+impl<const N: usize> Add for &Polynomial<N> {
+	type Output = Polynomial<N>;
+
+	fn add(self, other: &Polynomial<N>) -> Polynomial<N> {
+		let mut output = *self;
+		output += other;
+		output
+	}
+}
+
+impl<const N: usize> Neg for &Polynomial<N> {
+	type Output = Polynomial<N>;
+
+	fn neg(self) -> Polynomial<N> {
+		let mut output = *self;
+		output.coefficients.iter_mut().for_each(|x| *x = -*x);
+		output
+	}
+}
+
+impl<const N: usize> Neg for Polynomial<N> {
+	type Output = Polynomial<N>;
+
+	fn neg(mut self) -> Polynomial<N> {
+		self.coefficients.iter_mut().for_each(|x| *x = -*x);
+		self
+	}
+}
+
+impl<const N: usize> SubAssign<&Polynomial<N>> for Polynomial<N> {
+	fn sub_assign(&mut self, rhs: &Polynomial<N>) {
+		self.coefficients.iter_mut().zip(rhs.coefficients.iter()).for_each(|(a, b)| *a -= b);
+	}
+}
+
+impl<const N: usize> Sub for &Polynomial<N> {
+	type Output = Polynomial<N>;
+
+	fn sub(self, other: &Polynomial<N>) -> Polynomial<N> {
+		let mut output = *self;
+		output -= other;
+		output
+	}
+}
+
+impl<const N: usize> MulAssign<&Polynomial<N>> for Polynomial<N> {
+	fn mul_assign(&mut self, rhs: &Polynomial<N>) {
+		for i in (0..N).rev() {
+			self.coefficients[i] = self.coefficients[i] * rhs.coefficients[0];
+			for j in 0..i {
+				self.coefficients[i] += self.coefficients[j] * rhs.coefficients[i - j];
+			}
+		}
+	}
+}
+
+impl<const N: usize> Mul for &Polynomial<N> {
+	type Output = Polynomial<N>;
+
+	fn mul(self, other: &Polynomial<N>) -> Polynomial<N> {
+		let mut output = *self;
+		output *= other;
+		output
+	}
+}
+
+/// Returns two [`Polynomial`]s representing the parametric equations for x and y coordinates of the bezier curve respectively.
+/// The domain of both the equations are from t=0.0 representing the start and t=1.0 representing the end of the bezier curve.
+pub fn pathseg_to_parametric_polynomial(segment: PathSeg) -> (Polynomial<4>, Polynomial<4>) {
+	match segment {
+		PathSeg::Line(line) => {
+			let term1 = line.p0 - line.p1;
+			(Polynomial::new([line.p0.x, term1.x, 0., 0.]), Polynomial::new([line.p0.y, term1.y, 0., 0.]))
+		}
+		PathSeg::Quad(quad_bez) => {
+			let term1 = 2. * (quad_bez.p1 - quad_bez.p0);
+			let term2 = quad_bez.p0 - 2. * quad_bez.p1.to_vec2() + quad_bez.p2.to_vec2();
+
+			(Polynomial::new([quad_bez.p0.x, term1.x, term2.x, 0.]), Polynomial::new([quad_bez.p0.y, term1.y, term2.y, 0.]))
+		}
+		PathSeg::Cubic(cubic_bez) => {
+			let term1 = 3. * (cubic_bez.p1 - cubic_bez.p0);
+			let term2 = 3. * (cubic_bez.p2 - cubic_bez.p1) - term1;
+			let term3 = cubic_bez.p3 - cubic_bez.p0 - term2 - term1;
+
+			(
+				Polynomial::new([cubic_bez.p0.x, term1.x, term2.x, term3.x]),
+				Polynomial::new([cubic_bez.p0.y, term1.y, term2.y, term3.y]),
+			)
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn evaluation() {
+		let p = Polynomial::new([1., 2., 3.]);
+
+		assert_eq!(p.eval(1.), 6.);
+		assert_eq!(p.eval(2.), 17.);
+	}
+
+	#[test]
+	fn size_change() {
+		let p1 = Polynomial::new([1., 2., 3.]);
+		let p2 = Polynomial::new([1., 2., 3., 0.]);
+
+		assert_eq!(p1.as_size(), Some(p2));
+		assert_eq!(p2.as_size(), Some(p1));
+
+		assert_eq!(p2.as_size::<2>(), None);
+	}
+
+	#[test]
+	fn addition_and_subtaction() {
+		let p1 = Polynomial::new([1., 2., 3.]);
+		let p2 = Polynomial::new([4., 5., 6.]);
+
+		let addition = Polynomial::new([5., 7., 9.]);
+		let subtraction = Polynomial::new([-3., -3., -3.]);
+
+		assert_eq!(&p1 + &p2, addition);
+		assert_eq!(&p1 - &p2, subtraction);
+	}
+
+	#[test]
+	fn multiplication() {
+		let p1 = Polynomial::new([1., 2., 3.]).as_size().unwrap();
+		let p2 = Polynomial::new([4., 5., 6.]).as_size().unwrap();
+
+		let multiplication = Polynomial::new([4., 13., 28., 27., 18.]);
+
+		assert_eq!(&p1 * &p2, multiplication);
+	}
+
+	#[test]
+	fn derivative_and_antiderivative() {
+		let mut p = Polynomial::new([1., 2., 3.]);
+		let p_deriv = Polynomial::new([2., 6., 0.]);
+
+		assert_eq!(p.derivative(), p_deriv);
+
+		p.coefficients_mut()[0] = 0.;
+		assert_eq!(p_deriv.antiderivative().unwrap(), p);
+
+		assert_eq!(p.antiderivative(), None);
+	}
+
+	#[test]
+	fn display() {
+		let p = Polynomial::new([1., 2., 0., 3.]);
+
+		assert_eq!(format!("{:.2}", p), "3.00x^3 + 2.00x + 1.00");
+	}
+}

node-graph/gcore/src/subpath/consts.rs

@@ -0,0 +1,4 @@
+// Implementation constants
+
+/// Constant used to determine if `f64`s are equivalent.
+pub const MAX_ABSOLUTE_DIFFERENCE: f64 = 1e-3;

node-graph/gcore/src/subpath/core.rs

@@ -0,0 +1,318 @@
+use super::consts::*;
+use super::*;
+use crate::vector::misc::point_to_dvec2;
+use glam::DVec2;
+use kurbo::PathSeg;
+
+pub struct PathSegPoints {
+	pub p0: DVec2,
+	pub p1: Option<DVec2>,
+	pub p2: Option<DVec2>,
+	pub p3: DVec2,
+}
+
+impl PathSegPoints {
+	pub fn new(p0: DVec2, p1: Option<DVec2>, p2: Option<DVec2>, p3: DVec2) -> Self {
+		Self { p0, p1, p2, p3 }
+	}
+}
+
+pub fn pathseg_points(segment: PathSeg) -> PathSegPoints {
+	match segment {
+		PathSeg::Line(line) => PathSegPoints::new(point_to_dvec2(line.p0), None, None, point_to_dvec2(line.p1)),
+		PathSeg::Quad(quad) => PathSegPoints::new(point_to_dvec2(quad.p0), None, Some(point_to_dvec2(quad.p1)), point_to_dvec2(quad.p2)),
+		PathSeg::Cubic(cube) => PathSegPoints::new(point_to_dvec2(cube.p0), Some(point_to_dvec2(cube.p1)), Some(point_to_dvec2(cube.p2)), point_to_dvec2(cube.p3)),
+	}
+}
+
+/// Functionality relating to core `Subpath` operations, such as constructors and `iter`.
+impl<PointId: Identifier> Subpath<PointId> {
+	/// Create a new `Subpath` using a list of [ManipulatorGroup]s.
+	/// A `Subpath` with less than 2 [ManipulatorGroup]s may not be closed.
+	#[track_caller]
+	pub fn new(manipulator_groups: Vec<ManipulatorGroup<PointId>>, closed: bool) -> Self {
+		assert!(!closed || !manipulator_groups.is_empty(), "A closed Subpath must contain more than 0 ManipulatorGroups.");
+		Self { manipulator_groups, closed }
+	}
+
+	/// Create a `Subpath` consisting of 2 manipulator groups from a `Bezier`.
+	pub fn from_bezier(segment: PathSeg) -> Self {
+		let PathSegPoints { p0, p1, p2, p3 } = pathseg_points(segment);
+		Subpath::new(vec![ManipulatorGroup::new(p0, None, p1), ManipulatorGroup::new(p3, p2, None)], false)
+	}
+
+	/// Creates a subpath from a slice of [Bezier]. When two consecutive Beziers do not share an end and start point, this function
+	/// resolves the discrepancy by simply taking the start-point of the second Bezier as the anchor of the Manipulator Group.
+	pub fn from_beziers(beziers: &[PathSeg], closed: bool) -> Self {
+		assert!(!closed || beziers.len() > 1, "A closed Subpath must contain at least 1 Bezier.");
+		if beziers.is_empty() {
+			return Subpath::new(vec![], closed);
+		}
+
+		let beziers: Vec<_> = beziers.iter().map(|b| pathseg_points(*b)).collect();
+
+		let first = beziers.first().unwrap();
+		let mut manipulator_groups = vec![ManipulatorGroup {
+			anchor: first.p0,
+			in_handle: None,
+			out_handle: first.p1,
+			id: PointId::new(),
+		}];
+		let mut inner_groups: Vec<ManipulatorGroup<PointId>> = beziers
+			.windows(2)
+			.map(|bezier_pair| ManipulatorGroup {
+				anchor: bezier_pair[1].p0,
+				in_handle: bezier_pair[0].p2,
+				out_handle: bezier_pair[1].p1,
+				id: PointId::new(),
+			})
+			.collect::<Vec<ManipulatorGroup<PointId>>>();
+		manipulator_groups.append(&mut inner_groups);
+
+		let last = beziers.last().unwrap();
+		if !closed {
+			manipulator_groups.push(ManipulatorGroup {
+				anchor: last.p3,
+				in_handle: last.p2,
+				out_handle: None,
+				id: PointId::new(),
+			});
+			return Subpath::new(manipulator_groups, false);
+		}
+
+		manipulator_groups[0].in_handle = last.p2;
+		Subpath::new(manipulator_groups, true)
+	}
+
+	/// Returns true if the `Subpath` contains no [ManipulatorGroup].
+	pub fn is_empty(&self) -> bool {
+		self.manipulator_groups.is_empty()
+	}
+
+	/// Returns the number of [ManipulatorGroup]s contained within the `Subpath`.
+	pub fn len(&self) -> usize {
+		self.manipulator_groups.len()
+	}
+
+	/// Returns the number of segments contained within the `Subpath`.
+	pub fn len_segments(&self) -> usize {
+		let mut number_of_curves = self.len();
+		if !self.closed && number_of_curves > 0 {
+			number_of_curves -= 1
+		}
+		number_of_curves
+	}
+
+	/// Returns a copy of the bezier segment at the given segment index, if this segment exists.
+	pub fn get_segment(&self, segment_index: usize) -> Option<PathSeg> {
+		if segment_index >= self.len_segments() {
+			return None;
+		}
+		Some(self[segment_index].to_bezier(&self[(segment_index + 1) % self.len()]))
+	}
+
+	/// Returns an iterator of the [Bezier]s along the `Subpath`.
+	pub fn iter(&self) -> SubpathIter<'_, PointId> {
+		SubpathIter {
+			subpath: self,
+			index: 0,
+			is_always_closed: false,
+		}
+	}
+
+	/// Returns an iterator of the [Bezier]s along the `Subpath` always considering it as a closed subpath.
+	pub fn iter_closed(&self) -> SubpathIter<'_, PointId> {
+		SubpathIter {
+			subpath: self,
+			index: 0,
+			is_always_closed: true,
+		}
+	}
+
+	/// Returns a slice of the [ManipulatorGroup]s in the `Subpath`.
+	pub fn manipulator_groups(&self) -> &[ManipulatorGroup<PointId>] {
+		&self.manipulator_groups
+	}
+
+	/// Returns a mutable reference to the [ManipulatorGroup]s in the `Subpath`.
+	pub fn manipulator_groups_mut(&mut self) -> &mut Vec<ManipulatorGroup<PointId>> {
+		&mut self.manipulator_groups
+	}
+
+	/// Returns a vector of all the anchors (DVec2) for this `Subpath`.
+	pub fn anchors(&self) -> Vec<DVec2> {
+		self.manipulator_groups().iter().map(|group| group.anchor).collect()
+	}
+
+	/// Returns if the Subpath is equivalent to a single point.
+	pub fn is_point(&self) -> bool {
+		if self.is_empty() {
+			return false;
+		}
+		let point = self.manipulator_groups[0].anchor;
+		self.manipulator_groups
+			.iter()
+			.all(|manipulator_group| manipulator_group.anchor.abs_diff_eq(point, MAX_ABSOLUTE_DIFFERENCE))
+	}
+
+	/// Construct a [Subpath] from an iter of anchor positions.
+	pub fn from_anchors(anchor_positions: impl IntoIterator<Item = DVec2>, closed: bool) -> Self {
+		Self::new(anchor_positions.into_iter().map(|anchor| ManipulatorGroup::new_anchor(anchor)).collect(), closed)
+	}
+
+	pub fn from_anchors_linear(anchor_positions: impl IntoIterator<Item = DVec2>, closed: bool) -> Self {
+		Self::new(anchor_positions.into_iter().map(|anchor| ManipulatorGroup::new_anchor_linear(anchor)).collect(), closed)
+	}
+
+	/// Constructs a rectangle with `corner1` and `corner2` as the two corners.
+	pub fn new_rect(corner1: DVec2, corner2: DVec2) -> Self {
+		Self::from_anchors_linear([corner1, DVec2::new(corner2.x, corner1.y), corner2, DVec2::new(corner1.x, corner2.y)], true)
+	}
+
+	/// Constructs a rounded rectangle with `corner1` and `corner2` as the two corners and `corner_radii` as the radii of the corners: `[top_left, top_right, bottom_right, bottom_left]`.
+	pub fn new_rounded_rect(corner1: DVec2, corner2: DVec2, corner_radii: [f64; 4]) -> Self {
+		if corner_radii.iter().all(|radii| radii.abs() < f64::EPSILON * 100.) {
+			return Self::new_rect(corner1, corner2);
+		}
+
+		use std::f64::consts::{FRAC_1_SQRT_2, PI};
+
+		let new_arc = |center: DVec2, corner: DVec2, radius: f64| -> Vec<ManipulatorGroup<PointId>> {
+			let point1 = center + DVec2::from_angle(-PI * 0.25).rotate(corner - center) * FRAC_1_SQRT_2;
+			let point2 = center + DVec2::from_angle(PI * 0.25).rotate(corner - center) * FRAC_1_SQRT_2;
+			if radius == 0. {
+				return vec![ManipulatorGroup::new_anchor(point1), ManipulatorGroup::new_anchor(point2)];
+			}
+
+			// Based on https://pomax.github.io/bezierinfo/#circles_cubic
+			const HANDLE_OFFSET_FACTOR: f64 = 0.551784777779014;
+			let handle_offset = radius * HANDLE_OFFSET_FACTOR;
+			vec![
+				ManipulatorGroup::new(point1, None, Some(point1 + handle_offset * (corner - point1).normalize())),
+				ManipulatorGroup::new(point2, Some(point2 + handle_offset * (corner - point2).normalize()), None),
+			]
+		};
+		Self::new(
+			[
+				new_arc(DVec2::new(corner1.x + corner_radii[0], corner1.y + corner_radii[0]), DVec2::new(corner1.x, corner1.y), corner_radii[0]),
+				new_arc(DVec2::new(corner2.x - corner_radii[1], corner1.y + corner_radii[1]), DVec2::new(corner2.x, corner1.y), corner_radii[1]),
+				new_arc(DVec2::new(corner2.x - corner_radii[2], corner2.y - corner_radii[2]), DVec2::new(corner2.x, corner2.y), corner_radii[2]),
+				new_arc(DVec2::new(corner1.x + corner_radii[3], corner2.y - corner_radii[3]), DVec2::new(corner1.x, corner2.y), corner_radii[3]),
+			]
+			.concat(),
+			true,
+		)
+	}
+
+	/// Constructs an ellipse with `corner1` and `corner2` as the two corners of the bounding box.
+	pub fn new_ellipse(corner1: DVec2, corner2: DVec2) -> Self {
+		let size = (corner1 - corner2).abs();
+		let center = (corner1 + corner2) / 2.;
+		let top = DVec2::new(center.x, corner1.y);
+		let bottom = DVec2::new(center.x, corner2.y);
+		let left = DVec2::new(corner1.x, center.y);
+		let right = DVec2::new(corner2.x, center.y);
+
+		// Based on https://pomax.github.io/bezierinfo/#circles_cubic
+		const HANDLE_OFFSET_FACTOR: f64 = 0.551784777779014;
+		let handle_offset = size * HANDLE_OFFSET_FACTOR * 0.5;
+
+		let manipulator_groups = vec![
+			ManipulatorGroup::new(top, Some(top - handle_offset * DVec2::X), Some(top + handle_offset * DVec2::X)),
+			ManipulatorGroup::new(right, Some(right - handle_offset * DVec2::Y), Some(right + handle_offset * DVec2::Y)),
+			ManipulatorGroup::new(bottom, Some(bottom + handle_offset * DVec2::X), Some(bottom - handle_offset * DVec2::X)),
+			ManipulatorGroup::new(left, Some(left + handle_offset * DVec2::Y), Some(left - handle_offset * DVec2::Y)),
+		];
+		Self::new(manipulator_groups, true)
+	}
+
+	/// Constructs an arc by a `radius`, `angle_start` and `angle_size`. Angles must be in radians. Slice option makes it look like pie or pacman.
+	pub fn new_arc(radius: f64, start_angle: f64, sweep_angle: f64, arc_type: ArcType) -> Self {
+		// Prevents glitches from numerical imprecision that have been observed during animation playback after about a minute
+		let start_angle = start_angle % (std::f64::consts::TAU * 2.);
+		let sweep_angle = sweep_angle % (std::f64::consts::TAU * 2.);
+
+		let original_start_angle = start_angle;
+		let sweep_angle_sign = sweep_angle.signum();
+
+		let mut start_angle = 0.;
+		let mut sweep_angle = sweep_angle.abs();
+
+		if (sweep_angle / std::f64::consts::TAU).floor() as u32 % 2 == 0 {
+			sweep_angle %= std::f64::consts::TAU;
+		} else {
+			start_angle = sweep_angle % std::f64::consts::TAU;
+			sweep_angle = std::f64::consts::TAU - start_angle;
+		}
+
+		sweep_angle *= sweep_angle_sign;
+		start_angle *= sweep_angle_sign;
+		start_angle += original_start_angle;
+
+		let closed = arc_type == ArcType::Closed;
+		let slice = arc_type == ArcType::PieSlice;
+
+		let center = DVec2::new(0., 0.);
+		let segments = (sweep_angle.abs() / (std::f64::consts::PI / 4.)).ceil().max(1.) as usize;
+		let step = sweep_angle / segments as f64;
+		let factor = 4. / 3. * (step / 2.).sin() / (1. + (step / 2.).cos());
+
+		let mut manipulator_groups = Vec::with_capacity(segments);
+		let mut prev_in_handle = None;
+		let mut prev_end = DVec2::new(0., 0.);
+
+		for i in 0..segments {
+			let start_angle = start_angle + step * i as f64;
+			let end_angle = start_angle + step;
+			let start_vec = DVec2::from_angle(start_angle);
+			let end_vec = DVec2::from_angle(end_angle);
+
+			let start = center + radius * start_vec;
+			let end = center + radius * end_vec;
+
+			let handle_start = start + start_vec.perp() * radius * factor;
+			let handle_end = end - end_vec.perp() * radius * factor;
+
+			manipulator_groups.push(ManipulatorGroup::new(start, prev_in_handle, Some(handle_start)));
+			prev_in_handle = Some(handle_end);
+			prev_end = end;
+		}
+		manipulator_groups.push(ManipulatorGroup::new(prev_end, prev_in_handle, None));
+
+		if slice {
+			manipulator_groups.push(ManipulatorGroup::new(center, None, None));
+		}
+
+		Self::new(manipulator_groups, closed || slice)
+	}
+
+	/// Constructs a regular polygon (ngon). Based on `sides` and `radius`, which is the distance from the center to any vertex.
+	pub fn new_regular_polygon(center: DVec2, sides: u64, radius: f64) -> Self {
+		let sides = sides.max(3);
+		let angle_increment = std::f64::consts::TAU / (sides as f64);
+		let anchor_positions = (0..sides).map(|i| {
+			let angle = (i as f64) * angle_increment - std::f64::consts::FRAC_PI_2;
+			let center = center + DVec2::ONE * radius;
+			DVec2::new(center.x + radius * f64::cos(angle), center.y + radius * f64::sin(angle)) * 0.5
+		});
+		Self::from_anchors(anchor_positions, true)
+	}
+
+	/// Constructs a star polygon (n-star). See [new_regular_polygon], but with interspersed vertices at an `inner_radius`.
+	pub fn new_star_polygon(center: DVec2, sides: u64, radius: f64, inner_radius: f64) -> Self {
+		let sides = sides.max(2);
+		let angle_increment = 0.5 * std::f64::consts::TAU / (sides as f64);
+		let anchor_positions = (0..sides * 2).map(|i| {
+			let angle = (i as f64) * angle_increment - std::f64::consts::FRAC_PI_2;
+			let center = center + DVec2::ONE * radius;
+			let r = if i % 2 == 0 { radius } else { inner_radius };
+			DVec2::new(center.x + r * f64::cos(angle), center.y + r * f64::sin(angle)) * 0.5
+		});
+		Self::from_anchors(anchor_positions, true)
+	}
+
+	/// Constructs a line from `p1` to `p2`
+	pub fn new_line(p1: DVec2, p2: DVec2) -> Self {
+		Self::from_anchors([p1, p2], false)
+	}
+}

node-graph/gcore/src/subpath/lookup.rs

@@ -0,0 +1,114 @@
+use super::consts::MAX_ABSOLUTE_DIFFERENCE;
+use super::*;
+use crate::math::polynomial::pathseg_to_parametric_polynomial;
+use crate::vector::algorithms::bezpath_algorithms::pathseg_length_centroid_and_length;
+use crate::vector::algorithms::intersection::{filtered_all_segment_intersections, pathseg_self_intersections};
+use glam::DVec2;
+
+impl<PointId: Identifier> Subpath<PointId> {
+	/// Returns a list of `t` values that correspond to all the self intersection points of the subpath always considering it as a closed subpath. The index and `t` value of both will be returned that corresponds to a point.
+	/// The points will be sorted based on their index and `t` repsectively.
+	/// - `error` - For intersections with non-linear beziers, `error` defines the threshold for bounding boxes to be considered an intersection point.
+	/// - `minimum_separation`: the minimum difference two adjacent `t`-values must have when comparing adjacent `t`-values in sorted order.
+	///
+	/// If the comparison condition is not satisfied, the function takes the larger `t`-value of the two
+	///
+	/// **NOTE**: if an intersection were to occur within an `error` distance away from an anchor point, the algorithm will filter that intersection out.
+	pub fn all_self_intersections(&self, accuracy: Option<f64>, minimum_separation: Option<f64>) -> Vec<(usize, f64)> {
+		let mut intersections_vec = Vec::new();
+		let err = accuracy.unwrap_or(MAX_ABSOLUTE_DIFFERENCE);
+		let num_curves = self.len();
+		// TODO: optimization opportunity - this for-loop currently compares all intersections with all curve-segments in the subpath collection
+		self.iter_closed().enumerate().for_each(|(i, other)| {
+			intersections_vec.extend(pathseg_self_intersections(other, accuracy, minimum_separation).iter().flat_map(|value| [(i, value.0), (i, value.1)]));
+			self.iter_closed().enumerate().skip(i + 1).for_each(|(j, curve)| {
+				intersections_vec.extend(
+					filtered_all_segment_intersections(curve, other, accuracy, minimum_separation)
+						.iter()
+						.filter(|&value| (j != i + 1 || value.0 > err || (1. - value.1) > err) && (j != num_curves - 1 || i != 0 || value.1 > err || (1. - value.0) > err))
+						.flat_map(|value| [(j, value.0), (i, value.1)]),
+				);
+			});
+		});
+
+		intersections_vec.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+		intersections_vec
+	}
+
+	/// Return the area centroid, together with the area, of the `Subpath` always considering it as a closed subpath. The area will always be a positive value.
+	///
+	/// The area centroid is the center of mass for the area of a solid shape's interior.
+	/// An infinitely flat material forming the subpath's closed shape would balance at this point.
+	///
+	/// It will return `None` if no manipulator is present. If the area is less than `error`, it will return `Some((DVec2::NAN, 0.))`.
+	///
+	/// Because the calculation of area and centroid for self-intersecting path requires finding the intersections, the following parameters are used:
+	/// - `error` - For intersections with non-linear beziers, `error` defines the threshold for bounding boxes to be considered an intersection point.
+	/// - `minimum_separation` - the minimum difference two adjacent `t`-values must have when comparing adjacent `t`-values in sorted order.
+	///
+	/// If the comparison condition is not satisfied, the function takes the larger `t`-value of the two.
+	///
+	/// **NOTE**: if an intersection were to occur within an `error` distance away from an anchor point, the algorithm will filter that intersection out.
+	pub fn area_centroid_and_area(&self, error: Option<f64>, minimum_separation: Option<f64>) -> Option<(DVec2, f64)> {
+		let all_intersections = self.all_self_intersections(error, minimum_separation);
+		let mut current_sign: f64 = 1.;
+
+		let (x_sum, y_sum, area) = self
+			.iter_closed()
+			.enumerate()
+			.map(|(index, bezier)| {
+				let (f_x, f_y) = pathseg_to_parametric_polynomial(bezier);
+				let (f_x, f_y) = (f_x.as_size::<10>().unwrap(), f_y.as_size::<10>().unwrap());
+				let f_y_prime = f_y.derivative();
+				let f_x_prime = f_x.derivative();
+				let f_xy = &f_x * &f_y;
+
+				let mut x_part = &f_xy * &f_x_prime;
+				let mut y_part = &f_xy * &f_y_prime;
+				let mut area_part = &f_x * &f_y_prime;
+				x_part.antiderivative_mut();
+				y_part.antiderivative_mut();
+				area_part.antiderivative_mut();
+
+				let mut curve_sum_x = -current_sign * x_part.eval(0.);
+				let mut curve_sum_y = -current_sign * y_part.eval(0.);
+				let mut curve_sum_area = -current_sign * area_part.eval(0.);
+				for (_, t) in all_intersections.iter().filter(|(i, _)| *i == index) {
+					curve_sum_x += 2. * current_sign * x_part.eval(*t);
+					curve_sum_y += 2. * current_sign * y_part.eval(*t);
+					curve_sum_area += 2. * current_sign * area_part.eval(*t);
+					current_sign *= -1.;
+				}
+				curve_sum_x += current_sign * x_part.eval(1.);
+				curve_sum_y += current_sign * y_part.eval(1.);
+				curve_sum_area += current_sign * area_part.eval(1.);
+
+				(-curve_sum_x, curve_sum_y, curve_sum_area)
+			})
+			.reduce(|(x1, y1, area1), (x2, y2, area2)| (x1 + x2, y1 + y2, area1 + area2))?;
+
+		if area.abs() < error.unwrap_or(MAX_ABSOLUTE_DIFFERENCE) {
+			return Some((DVec2::NAN, 0.));
+		}
+
+		Some((DVec2::new(x_sum / area, y_sum / area), area.abs()))
+	}
+
+	/// Return the approximation of the length centroid, together with the length, of the `Subpath`.
+	///
+	/// The length centroid is the center of mass for the arc length of the solid shape's perimeter.
+	/// An infinitely thin wire forming the subpath's closed shape would balance at this point.
+	///
+	/// It will return `None` if no manipulator is present.
+	/// - `accuracy` is used to approximate the curve.
+	/// - `always_closed` is to consider the subpath as closed always.
+	pub fn length_centroid_and_length(&self, accuracy: Option<f64>, always_closed: bool) -> Option<(DVec2, f64)> {
+		if always_closed { self.iter_closed() } else { self.iter() }
+			.map(|bezier| pathseg_length_centroid_and_length(bezier, accuracy))
+			.map(|(centroid, length)| (centroid * length, length))
+			.reduce(|(centroid_part1, length1), (centroid_part2, length2)| (centroid_part1 + centroid_part2, length1 + length2))
+			.map(|(centroid_part, length)| (centroid_part / length, length))
+			.map(|(centroid_part, length)| (DVec2::new(centroid_part.x, centroid_part.y), length))
+	}
+}

node-graph/gcore/src/subpath/manipulators.rs

@@ -0,0 +1,52 @@
+// use super::consts::MAX_ABSOLUTE_DIFFERENCE;
+// use super::utils::{SubpathTValue};
+use super::*;
+
+impl<PointId: super::structs::Identifier> Subpath<PointId> {
+	/// Get whether the subpath is closed.
+	pub fn closed(&self) -> bool {
+		self.closed
+	}
+
+	/// Set whether the subpath is closed.
+	pub fn set_closed(&mut self, new_closed: bool) {
+		self.closed = new_closed;
+	}
+
+	/// Access a [ManipulatorGroup] from a PointId.
+	pub fn manipulator_from_id(&self, id: PointId) -> Option<&ManipulatorGroup<PointId>> {
+		self.manipulator_groups.iter().find(|manipulator_group| manipulator_group.id == id)
+	}
+
+	/// Access a mutable [ManipulatorGroup] from a PointId.
+	pub fn manipulator_mut_from_id(&mut self, id: PointId) -> Option<&mut ManipulatorGroup<PointId>> {
+		self.manipulator_groups.iter_mut().find(|manipulator_group| manipulator_group.id == id)
+	}
+
+	/// Access the index of a [ManipulatorGroup] from a PointId.
+	pub fn manipulator_index_from_id(&self, id: PointId) -> Option<usize> {
+		self.manipulator_groups.iter().position(|manipulator_group| manipulator_group.id == id)
+	}
+
+	/// Insert a manipulator group at an index.
+	pub fn insert_manipulator_group(&mut self, index: usize, group: ManipulatorGroup<PointId>) {
+		assert!(group.is_finite(), "Inserting non finite manipulator group");
+		self.manipulator_groups.insert(index, group)
+	}
+
+	/// Push a manipulator group to the end.
+	pub fn push_manipulator_group(&mut self, group: ManipulatorGroup<PointId>) {
+		assert!(group.is_finite(), "Pushing non finite manipulator group");
+		self.manipulator_groups.push(group)
+	}
+
+	/// Get a mutable reference to the last manipulator
+	pub fn last_manipulator_group_mut(&mut self) -> Option<&mut ManipulatorGroup<PointId>> {
+		self.manipulator_groups.last_mut()
+	}
+
+	/// Remove a manipulator group at an index.
+	pub fn remove_manipulator_group(&mut self, index: usize) -> ManipulatorGroup<PointId> {
+		self.manipulator_groups.remove(index)
+	}
+}

node-graph/gcore/src/subpath/mod.rs

@@ -0,0 +1,71 @@
+mod consts;
+mod core;
+mod lookup;
+mod manipulators;
+mod solvers;
+mod structs;
+mod transform;
+
+pub use core::*;
+use kurbo::PathSeg;
+use std::fmt::{Debug, Formatter, Result};
+use std::ops::{Index, IndexMut};
+pub use structs::*;
+
+/// Structure used to represent a path composed of [Bezier] curves.
+#[derive(Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Subpath<PointId: Identifier> {
+	manipulator_groups: Vec<ManipulatorGroup<PointId>>,
+	pub closed: bool,
+}
+
+/// Iteration structure for iterating across each curve of a `Subpath`, using an intermediate `Bezier` representation.
+pub struct SubpathIter<'a, PointId: Identifier> {
+	index: usize,
+	subpath: &'a Subpath<PointId>,
+	is_always_closed: bool,
+}
+
+impl<PointId: Identifier> Index<usize> for Subpath<PointId> {
+	type Output = ManipulatorGroup<PointId>;
+
+	fn index(&self, index: usize) -> &Self::Output {
+		assert!(index < self.len(), "Index out of bounds in trait Index of SubPath.");
+		&self.manipulator_groups[index]
+	}
+}
+
+impl<PointId: Identifier> IndexMut<usize> for Subpath<PointId> {
+	fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+		assert!(index < self.len(), "Index out of bounds in trait IndexMut of SubPath.");
+		&mut self.manipulator_groups[index]
+	}
+}
+
+impl<PointId: Identifier> Iterator for SubpathIter<'_, PointId> {
+	type Item = PathSeg;
+
+	// Returns the Bezier representation of each `Subpath` segment, defined between a pair of adjacent manipulator points.
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.subpath.is_empty() {
+			return None;
+		}
+		let closed = if self.is_always_closed { true } else { self.subpath.closed };
+		let len = self.subpath.len() - 1 + if closed { 1 } else { 0 };
+		if self.index >= len {
+			return None;
+		}
+		let start_index = self.index;
+		let end_index = (self.index + 1) % self.subpath.len();
+		self.index += 1;
+
+		Some(self.subpath[start_index].to_bezier(&self.subpath[end_index]))
+	}
+}
+
+impl<PointId: Identifier> Debug for Subpath<PointId> {
+	fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+		f.debug_struct("Subpath").field("closed", &self.closed).field("manipulator_groups", &self.manipulator_groups).finish()
+	}
+}

node-graph/gcore/src/subpath/solvers.rs

@@ -0,0 +1,83 @@
+use crate::subpath::{Identifier, Subpath};
+use crate::vector::algorithms::bezpath_algorithms::bezpath_is_inside_bezpath;
+use crate::vector::misc::dvec2_to_point;
+use glam::DVec2;
+use kurbo::{Affine, BezPath, Shape};
+
+impl<PointId: Identifier> Subpath<PointId> {
+	pub fn contains_point(&self, point: DVec2) -> bool {
+		self.to_bezpath().contains(dvec2_to_point(point))
+	}
+
+	pub fn to_bezpath(&self) -> BezPath {
+		let mut bezpath = kurbo::BezPath::new();
+		let mut out_handle;
+
+		let Some(first) = self.manipulator_groups.first() else { return bezpath };
+		bezpath.move_to(dvec2_to_point(first.anchor));
+		out_handle = first.out_handle;
+
+		for manipulator in self.manipulator_groups.iter().skip(1) {
+			match (out_handle, manipulator.in_handle) {
+				(Some(handle_start), Some(handle_end)) => bezpath.curve_to(dvec2_to_point(handle_start), dvec2_to_point(handle_end), dvec2_to_point(manipulator.anchor)),
+				(None, None) => bezpath.line_to(dvec2_to_point(manipulator.anchor)),
+				(None, Some(handle)) => bezpath.quad_to(dvec2_to_point(handle), dvec2_to_point(manipulator.anchor)),
+				(Some(handle), None) => bezpath.quad_to(dvec2_to_point(handle), dvec2_to_point(manipulator.anchor)),
+			}
+			out_handle = manipulator.out_handle;
+		}
+
+		if self.closed {
+			match (out_handle, first.in_handle) {
+				(Some(handle_start), Some(handle_end)) => bezpath.curve_to(dvec2_to_point(handle_start), dvec2_to_point(handle_end), dvec2_to_point(first.anchor)),
+				(None, None) => bezpath.line_to(dvec2_to_point(first.anchor)),
+				(None, Some(handle)) => bezpath.quad_to(dvec2_to_point(handle), dvec2_to_point(first.anchor)),
+				(Some(handle), None) => bezpath.quad_to(dvec2_to_point(handle), dvec2_to_point(first.anchor)),
+			}
+			bezpath.close_path();
+		}
+		bezpath
+	}
+
+	/// Returns `true` if this subpath is completely inside the `other` subpath.
+	pub fn is_inside_subpath(&self, other: &Subpath<PointId>, accuracy: Option<f64>, minimum_separation: Option<f64>) -> bool {
+		bezpath_is_inside_bezpath(&self.to_bezpath(), &other.to_bezpath(), accuracy, minimum_separation)
+	}
+
+	/// Return the min and max corners that represent the bounding box of the subpath. Return `None` if the subpath is empty.
+	pub fn bounding_box(&self) -> Option<[DVec2; 2]> {
+		self.iter()
+			.map(|bezier| bezier.bounding_box())
+			.map(|bbox| [DVec2::new(bbox.min_x(), bbox.min_y()), DVec2::new(bbox.max_x(), bbox.max_y())])
+			.reduce(|bbox1, bbox2| [bbox1[0].min(bbox2[0]), bbox1[1].max(bbox2[1])])
+	}
+
+	/// Return the min and max corners that represent the bounding box of the subpath, after a given affine transform.
+	pub fn bounding_box_with_transform(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {
+		self.iter()
+			.map(|bezier| (Affine::new(transform.to_cols_array()) * bezier).bounding_box())
+			.map(|bbox| [DVec2::new(bbox.min_x(), bbox.min_y()), DVec2::new(bbox.max_x(), bbox.max_y())])
+			.reduce(|bbox1, bbox2| [bbox1[0].min(bbox2[0]), bbox1[1].max(bbox2[1])])
+	}
+
+	/// Return the min and max corners that represent the loose bounding box of the subpath (bounding box of all handles and anchors).
+	pub fn loose_bounding_box(&self) -> Option<[DVec2; 2]> {
+		self.manipulator_groups
+			.iter()
+			.flat_map(|group| [group.in_handle, group.out_handle, Some(group.anchor)])
+			.flatten()
+			.map(|pos| [pos, pos])
+			.reduce(|bbox1, bbox2| [bbox1[0].min(bbox2[0]), bbox1[1].max(bbox2[1])])
+	}
+
+	/// Return the min and max corners that represent the loose bounding box of the subpath, after a given affine transform.
+	pub fn loose_bounding_box_with_transform(&self, transform: glam::DAffine2) -> Option<[DVec2; 2]> {
+		self.manipulator_groups
+			.iter()
+			.flat_map(|group| [group.in_handle, group.out_handle, Some(group.anchor)])
+			.flatten()
+			.map(|pos| transform.transform_point2(pos))
+			.map(|pos| [pos, pos])
+			.reduce(|bbox1, bbox2| [bbox1[0].min(bbox2[0]), bbox1[1].max(bbox2[1])])
+	}
+}

node-graph/gcore/src/subpath/structs.rs

@@ -0,0 +1,427 @@
+use crate::vector::algorithms::intersection::filtered_segment_intersections;
+use crate::vector::misc::{dvec2_to_point, handles_to_segment};
+use glam::{DAffine2, DVec2};
+use kurbo::{CubicBez, Line, PathSeg, QuadBez, Shape};
+use std::fmt::{Debug, Formatter, Result};
+use std::hash::Hash;
+
+/// An id type used for each [ManipulatorGroup].
+pub trait Identifier: Sized + Clone + PartialEq + Hash + 'static {
+	fn new() -> Self;
+}
+
+/// An empty id type for use in tests
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+#[cfg(test)]
+pub(crate) struct EmptyId;
+
+#[cfg(test)]
+impl Identifier for EmptyId {
+	fn new() -> Self {
+		Self
+	}
+}
+
+/// Structure used to represent a single anchor with up to two optional associated handles along a `Subpath`
+#[derive(Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct ManipulatorGroup<PointId: Identifier> {
+	pub anchor: DVec2,
+	pub in_handle: Option<DVec2>,
+	pub out_handle: Option<DVec2>,
+	pub id: PointId,
+}
+
+// TODO: Remove once we no longer need to hash floats in Graphite
+impl<PointId: Identifier> Hash for ManipulatorGroup<PointId> {
+	fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+		self.anchor.to_array().iter().for_each(|x| x.to_bits().hash(state));
+		self.in_handle.is_some().hash(state);
+		if let Some(in_handle) = self.in_handle {
+			in_handle.to_array().iter().for_each(|x| x.to_bits().hash(state));
+		}
+		self.out_handle.is_some().hash(state);
+		if let Some(out_handle) = self.out_handle {
+			out_handle.to_array().iter().for_each(|x| x.to_bits().hash(state));
+		}
+		self.id.hash(state);
+	}
+}
+
+impl<PointId: Identifier> Debug for ManipulatorGroup<PointId> {
+	fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+		f.debug_struct("ManipulatorGroup")
+			.field("anchor", &self.anchor)
+			.field("in_handle", &self.in_handle)
+			.field("out_handle", &self.out_handle)
+			.finish()
+	}
+}
+
+impl<PointId: Identifier> ManipulatorGroup<PointId> {
+	/// Construct a new manipulator group from an anchor, in handle and out handle
+	pub fn new(anchor: DVec2, in_handle: Option<DVec2>, out_handle: Option<DVec2>) -> Self {
+		let id = PointId::new();
+		Self { anchor, in_handle, out_handle, id }
+	}
+
+	/// Construct a new manipulator point with just an anchor position
+	pub fn new_anchor(anchor: DVec2) -> Self {
+		Self::new(anchor, Some(anchor), Some(anchor))
+	}
+
+	pub fn new_anchor_linear(anchor: DVec2) -> Self {
+		Self::new(anchor, None, None)
+	}
+
+	/// Construct a new manipulator group from an anchor, in handle, out handle and an id
+	pub fn new_with_id(anchor: DVec2, in_handle: Option<DVec2>, out_handle: Option<DVec2>, id: PointId) -> Self {
+		Self { anchor, in_handle, out_handle, id }
+	}
+
+	/// Construct a new manipulator point with just an anchor position and an id
+	pub fn new_anchor_with_id(anchor: DVec2, id: PointId) -> Self {
+		Self::new_with_id(anchor, Some(anchor), Some(anchor), id)
+	}
+
+	/// Create a bezier curve that starts at the current manipulator group and finishes in the `end_group` manipulator group.
+	pub fn to_bezier(&self, end_group: &ManipulatorGroup<PointId>) -> PathSeg {
+		let start = self.anchor;
+		let end = end_group.anchor;
+		let out_handle = self.out_handle;
+		let in_handle = end_group.in_handle;
+
+		match (out_handle, in_handle) {
+			(Some(handle1), Some(handle2)) => PathSeg::Cubic(CubicBez::new(dvec2_to_point(start), dvec2_to_point(handle1), dvec2_to_point(handle2), dvec2_to_point(end))),
+			(Some(handle), None) | (None, Some(handle)) => PathSeg::Quad(QuadBez::new(dvec2_to_point(start), dvec2_to_point(handle), dvec2_to_point(end))),
+			(None, None) => PathSeg::Line(Line::new(dvec2_to_point(start), dvec2_to_point(end))),
+		}
+	}
+
+	/// Apply a transformation to all of the [ManipulatorGroup] points
+	pub fn apply_transform(&mut self, affine_transform: DAffine2) {
+		self.anchor = affine_transform.transform_point2(self.anchor);
+		self.in_handle = self.in_handle.map(|in_handle| affine_transform.transform_point2(in_handle));
+		self.out_handle = self.out_handle.map(|out_handle| affine_transform.transform_point2(out_handle));
+	}
+
+	/// Are all handles at finite positions
+	pub fn is_finite(&self) -> bool {
+		self.anchor.is_finite() && self.in_handle.is_none_or(|handle| handle.is_finite()) && self.out_handle.is_none_or(|handle| handle.is_finite())
+	}
+
+	/// Reverse directions of handles
+	pub fn flip(mut self) -> Self {
+		std::mem::swap(&mut self.in_handle, &mut self.out_handle);
+		self
+	}
+
+	pub fn has_in_handle(&self) -> bool {
+		self.in_handle.map(|handle| Self::has_handle(self.anchor, handle)).unwrap_or(false)
+	}
+
+	pub fn has_out_handle(&self) -> bool {
+		self.out_handle.map(|handle| Self::has_handle(self.anchor, handle)).unwrap_or(false)
+	}
+
+	fn has_handle(anchor: DVec2, handle: DVec2) -> bool {
+		!((handle.x - anchor.x).abs() < f64::EPSILON && (handle.y - anchor.y).abs() < f64::EPSILON)
+	}
+}
+
+#[derive(Copy, Clone)]
+pub enum AppendType {
+	IgnoreStart,
+	SmoothJoin(f64),
+}
+
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub enum ArcType {
+	Open,
+	Closed,
+	PieSlice,
+}
+
+/// Representation of the handle point(s) in a bezier segment.
+#[derive(Copy, Clone, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum BezierHandles {
+	Linear,
+	/// Handles for a quadratic curve.
+	Quadratic {
+		/// Point representing the location of the single handle.
+		handle: DVec2,
+	},
+	/// Handles for a cubic curve.
+	Cubic {
+		/// Point representing the location of the handle associated to the start point.
+		handle_start: DVec2,
+		/// Point representing the location of the handle associated to the end point.
+		handle_end: DVec2,
+	},
+}
+
+impl std::hash::Hash for BezierHandles {
+	fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+		std::mem::discriminant(self).hash(state);
+		match self {
+			BezierHandles::Linear => {}
+			BezierHandles::Quadratic { handle } => handle.to_array().map(|v| v.to_bits()).hash(state),
+			BezierHandles::Cubic { handle_start, handle_end } => [handle_start, handle_end].map(|handle| handle.to_array().map(|v| v.to_bits())).hash(state),
+		}
+	}
+}
+
+impl BezierHandles {
+	pub fn is_cubic(&self) -> bool {
+		matches!(self, Self::Cubic { .. })
+	}
+
+	pub fn is_finite(&self) -> bool {
+		match self {
+			BezierHandles::Linear => true,
+			BezierHandles::Quadratic { handle } => handle.is_finite(),
+			BezierHandles::Cubic { handle_start, handle_end } => handle_start.is_finite() && handle_end.is_finite(),
+		}
+	}
+
+	/// Get the coordinates of the bezier segment's first handle point. This represents the only handle in a quadratic segment.
+	pub fn start(&self) -> Option<DVec2> {
+		match *self {
+			BezierHandles::Cubic { handle_start, .. } | BezierHandles::Quadratic { handle: handle_start } => Some(handle_start),
+			_ => None,
+		}
+	}
+
+	/// Get the coordinates of the second handle point. This will return `None` for a quadratic segment.
+	pub fn end(&self) -> Option<DVec2> {
+		match *self {
+			BezierHandles::Cubic { handle_end, .. } => Some(handle_end),
+			_ => None,
+		}
+	}
+
+	pub fn move_start(&mut self, delta: DVec2) {
+		if let BezierHandles::Cubic { handle_start, .. } | BezierHandles::Quadratic { handle: handle_start } = self {
+			*handle_start += delta
+		}
+	}
+
+	pub fn move_end(&mut self, delta: DVec2) {
+		if let BezierHandles::Cubic { handle_end, .. } = self {
+			*handle_end += delta
+		}
+	}
+
+	/// Returns a Bezier curve that results from applying the transformation function to each handle point in the Bezier.
+	#[must_use]
+	pub fn apply_transformation(&self, transformation_function: impl Fn(DVec2) -> DVec2) -> Self {
+		match *self {
+			BezierHandles::Linear => Self::Linear,
+			BezierHandles::Quadratic { handle } => {
+				let handle = transformation_function(handle);
+				Self::Quadratic { handle }
+			}
+			BezierHandles::Cubic { handle_start, handle_end } => {
+				let handle_start = transformation_function(handle_start);
+				let handle_end = transformation_function(handle_end);
+				Self::Cubic { handle_start, handle_end }
+			}
+		}
+	}
+
+	#[must_use]
+	pub fn reversed(self) -> Self {
+		match self {
+			BezierHandles::Cubic { handle_start, handle_end } => Self::Cubic {
+				handle_start: handle_end,
+				handle_end: handle_start,
+			},
+			_ => self,
+		}
+	}
+}
+
+/// Representation of a bezier curve with 2D points.
+#[derive(Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Bezier {
+	/// Start point of the bezier curve.
+	pub start: DVec2,
+	/// End point of the bezier curve.
+	pub end: DVec2,
+	/// Handles of the bezier curve.
+	pub handles: BezierHandles,
+}
+
+impl Debug for Bezier {
+	fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+		let mut debug_struct = f.debug_struct("Bezier");
+		let mut debug_struct_ref = debug_struct.field("start", &self.start);
+		debug_struct_ref = match self.handles {
+			BezierHandles::Linear => debug_struct_ref,
+			BezierHandles::Quadratic { handle } => debug_struct_ref.field("handle", &handle),
+			BezierHandles::Cubic { handle_start, handle_end } => debug_struct_ref.field("handle_start", &handle_start).field("handle_end", &handle_end),
+		};
+		debug_struct_ref.field("end", &self.end).finish()
+	}
+}
+
+/// Functionality for the getters and setters of the various points in a Bezier
+impl Bezier {
+	/// Set the coordinates of the start point.
+	pub fn set_start(&mut self, s: DVec2) {
+		self.start = s;
+	}
+
+	/// Set the coordinates of the end point.
+	pub fn set_end(&mut self, e: DVec2) {
+		self.end = e;
+	}
+
+	/// Set the coordinates of the first handle point. This represents the only handle in a quadratic segment. If used on a linear segment, it will be changed to a quadratic.
+	pub fn set_handle_start(&mut self, h1: DVec2) {
+		match self.handles {
+			BezierHandles::Linear => {
+				self.handles = BezierHandles::Quadratic { handle: h1 };
+			}
+			BezierHandles::Quadratic { ref mut handle } => {
+				*handle = h1;
+			}
+			BezierHandles::Cubic { ref mut handle_start, .. } => {
+				*handle_start = h1;
+			}
+		};
+	}
+
+	/// Set the coordinates of the second handle point. This will convert both linear and quadratic segments into cubic ones. For a linear segment, the first handle will be set to the start point.
+	pub fn set_handle_end(&mut self, h2: DVec2) {
+		match self.handles {
+			BezierHandles::Linear => {
+				self.handles = BezierHandles::Cubic {
+					handle_start: self.start,
+					handle_end: h2,
+				};
+			}
+			BezierHandles::Quadratic { handle } => {
+				self.handles = BezierHandles::Cubic { handle_start: handle, handle_end: h2 };
+			}
+			BezierHandles::Cubic { ref mut handle_end, .. } => {
+				*handle_end = h2;
+			}
+		};
+	}
+
+	/// Get the coordinates of the bezier segment's start point.
+	pub fn start(&self) -> DVec2 {
+		self.start
+	}
+
+	/// Get the coordinates of the bezier segment's end point.
+	pub fn end(&self) -> DVec2 {
+		self.end
+	}
+
+	/// Get the coordinates of the bezier segment's first handle point. This represents the only handle in a quadratic segment.
+	pub fn handle_start(&self) -> Option<DVec2> {
+		self.handles.start()
+	}
+
+	/// Get the coordinates of the second handle point. This will return `None` for a quadratic segment.
+	pub fn handle_end(&self) -> Option<DVec2> {
+		self.handles.end()
+	}
+
+	/// Get an iterator over the coordinates of all points in a vector.
+	/// - For a linear segment, the order of the points will be: `start`, `end`.
+	/// - For a quadratic segment, the order of the points will be: `start`, `handle`, `end`.
+	/// - For a cubic segment, the order of the points will be: `start`, `handle_start`, `handle_end`, `end`.
+	pub fn get_points(&self) -> impl Iterator<Item = DVec2> + use<> {
+		match self.handles {
+			BezierHandles::Linear => [self.start, self.end, DVec2::ZERO, DVec2::ZERO].into_iter().take(2),
+			BezierHandles::Quadratic { handle } => [self.start, handle, self.end, DVec2::ZERO].into_iter().take(3),
+			BezierHandles::Cubic { handle_start, handle_end } => [self.start, handle_start, handle_end, self.end].into_iter().take(4),
+		}
+	}
+
+	// TODO: Consider removing this function
+	/// Create a linear bezier using the provided coordinates as the start and end points.
+	pub fn from_linear_coordinates(x1: f64, y1: f64, x2: f64, y2: f64) -> Self {
+		Bezier {
+			start: DVec2::new(x1, y1),
+			handles: BezierHandles::Linear,
+			end: DVec2::new(x2, y2),
+		}
+	}
+
+	/// Create a linear bezier using the provided DVec2s as the start and end points.
+	pub fn from_linear_dvec2(p1: DVec2, p2: DVec2) -> Self {
+		Bezier {
+			start: p1,
+			handles: BezierHandles::Linear,
+			end: p2,
+		}
+	}
+
+	// TODO: Consider removing this function
+	/// Create a quadratic bezier using the provided coordinates as the start, handle, and end points.
+	pub fn from_quadratic_coordinates(x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64) -> Self {
+		Bezier {
+			start: DVec2::new(x1, y1),
+			handles: BezierHandles::Quadratic { handle: DVec2::new(x2, y2) },
+			end: DVec2::new(x3, y3),
+		}
+	}
+
+	/// Create a quadratic bezier using the provided DVec2s as the start, handle, and end points.
+	pub fn from_quadratic_dvec2(p1: DVec2, p2: DVec2, p3: DVec2) -> Self {
+		Bezier {
+			start: p1,
+			handles: BezierHandles::Quadratic { handle: p2 },
+			end: p3,
+		}
+	}
+
+	// TODO: Consider removing this function
+	/// Create a cubic bezier using the provided coordinates as the start, handles, and end points.
+	#[allow(clippy::too_many_arguments)]
+	pub fn from_cubic_coordinates(x1: f64, y1: f64, x2: f64, y2: f64, x3: f64, y3: f64, x4: f64, y4: f64) -> Self {
+		Bezier {
+			start: DVec2::new(x1, y1),
+			handles: BezierHandles::Cubic {
+				handle_start: DVec2::new(x2, y2),
+				handle_end: DVec2::new(x3, y3),
+			},
+			end: DVec2::new(x4, y4),
+		}
+	}
+
+	/// Create a cubic bezier using the provided DVec2s as the start, handles, and end points.
+	pub fn from_cubic_dvec2(p1: DVec2, p2: DVec2, p3: DVec2, p4: DVec2) -> Self {
+		Bezier {
+			start: p1,
+			handles: BezierHandles::Cubic { handle_start: p2, handle_end: p3 },
+			end: p4,
+		}
+	}
+
+	/// Returns a Bezier curve that results from applying the transformation function to each point in the Bezier.
+	pub fn apply_transformation(&self, transformation_function: impl Fn(DVec2) -> DVec2) -> Bezier {
+		Self {
+			start: transformation_function(self.start),
+			end: transformation_function(self.end),
+			handles: self.handles.apply_transformation(transformation_function),
+		}
+	}
+
+	pub fn intersections(&self, other: &Bezier, accuracy: Option<f64>, minimum_separation: Option<f64>) -> Vec<f64> {
+		let this = handles_to_segment(self.start, self.handles, self.end);
+		let other = handles_to_segment(other.start, other.handles, other.end);
+		filtered_segment_intersections(this, other, accuracy, minimum_separation)
+	}
+
+	pub fn winding(&self, point: DVec2) -> i32 {
+		let this = handles_to_segment(self.start, self.handles, self.end);
+		this.winding(dvec2_to_point(point))
+	}
+}

node-graph/gcore/src/subpath/transform.rs

@@ -0,0 +1,62 @@
+use super::structs::Identifier;
+use super::*;
+use glam::{DAffine2, DVec2};
+
+/// Functionality that transforms Subpaths, such as split, reduce, offset, etc.
+impl<PointId: Identifier> Subpath<PointId> {
+	/// Returns [ManipulatorGroup]s with a reversed winding order.
+	fn reverse_manipulator_groups(manipulator_groups: &[ManipulatorGroup<PointId>]) -> Vec<ManipulatorGroup<PointId>> {
+		manipulator_groups
+			.iter()
+			.rev()
+			.map(|group| ManipulatorGroup {
+				anchor: group.anchor,
+				in_handle: group.out_handle,
+				out_handle: group.in_handle,
+				id: PointId::new(),
+			})
+			.collect::<Vec<ManipulatorGroup<PointId>>>()
+	}
+
+	/// Returns a [Subpath] with a reversed winding order.
+	/// Note that a reversed closed subpath will start on the same manipulator group and simply wind the other direction
+	pub fn reverse(&self) -> Subpath<PointId> {
+		let mut reversed = Subpath::reverse_manipulator_groups(self.manipulator_groups());
+		if self.closed {
+			reversed.rotate_right(1);
+		};
+		Subpath {
+			manipulator_groups: reversed,
+			closed: self.closed,
+		}
+	}
+
+	/// Apply a transformation to all of the [ManipulatorGroup]s in the [Subpath].
+	pub fn apply_transform(&mut self, affine_transform: DAffine2) {
+		for manipulator_group in &mut self.manipulator_groups {
+			manipulator_group.apply_transform(affine_transform);
+		}
+	}
+
+	/// Returns a subpath that results from rotating this subpath around the origin by the given angle (in radians).
+	pub fn rotate(&self, angle: f64) -> Subpath<PointId> {
+		let mut rotated_subpath = self.clone();
+
+		let affine_transform: DAffine2 = DAffine2::from_angle(angle);
+		rotated_subpath.apply_transform(affine_transform);
+
+		rotated_subpath
+	}
+
+	/// Returns a subpath that results from rotating this subpath around the provided point by the given angle (in radians).
+	pub fn rotate_about_point(&self, angle: f64, pivot: DVec2) -> Subpath<PointId> {
+		// Translate before and after the rotation to account for the pivot
+		let translate: DAffine2 = DAffine2::from_translation(pivot);
+		let rotate: DAffine2 = DAffine2::from_angle(angle);
+		let translate_inverse = translate.inverse();
+
+		let mut rotated_subpath = self.clone();
+		rotated_subpath.apply_transform(translate * rotate * translate_inverse);
+		rotated_subpath
+	}
+}

node-graph/gcore/src/text/to_path.rs

@@ -1,7 +1,7 @@
 use super::TextAlign;
+use crate::subpath::{ManipulatorGroup, Subpath};
 use crate::table::{Table, TableRow};
 use crate::vector::{PointId, Vector};
-use bezier_rs::{ManipulatorGroup, Subpath};
 use core::cell::RefCell;
 use glam::{DAffine2, DVec2};
 use parley::fontique::Blob;

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

@@ -1,10 +1,12 @@
 use super::intersection::bezpath_intersections;
 use super::poisson_disk::poisson_disk_sample;
-use super::util::segment_tangent;
+use super::util::pathseg_tangent;
+use crate::math::polynomial::pathseg_to_parametric_polynomial;
 use crate::vector::algorithms::offset_subpath::MAX_ABSOLUTE_DIFFERENCE;
 use crate::vector::misc::{PointSpacingType, dvec2_to_point, point_to_dvec2};
 use glam::{DMat2, DVec2};
-use kurbo::{BezPath, CubicBez, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveDeriv, PathEl, PathSeg, Point, QuadBez, Rect, Shape};
+use kurbo::common::{solve_cubic, solve_quadratic};
+use kurbo::{BezPath, CubicBez, DEFAULT_ACCURACY, Line, ParamCurve, ParamCurveDeriv, PathEl, PathSeg, Point, QuadBez, Rect, Shape, Vec2};
 use std::f64::consts::{FRAC_PI_2, PI};
 
 /// Splits the [`BezPath`] at segment index at `t` value which lie in the range of [0, 1].
@@ -187,6 +189,82 @@ pub enum TValue {
 	Euclidean(f64),
 }
 
+/// Default LUT step size in `compute_lookup_table` function.
+pub const DEFAULT_LUT_STEP_SIZE: usize = 10;
+
+/// 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 pathseg_compute_lookup_table(segment: PathSeg, steps: Option<usize>, eucliean: bool) -> impl Iterator<Item = DVec2> {
+	let steps = steps.unwrap_or(DEFAULT_LUT_STEP_SIZE);
+
+	(0..=steps).map(move |t| {
+		let tvalue = if eucliean {
+			TValue::Euclidean(t as f64 / steps as f64)
+		} else {
+			TValue::Parametric(t as f64 / steps as f64)
+		};
+		let t = eval_pathseg(segment, tvalue);
+		point_to_dvec2(segment.eval(t))
+	})
+}
+
+/// Returns an `Iterator` containing all possible parametric `t`-values at the given `x`-coordinate.
+pub fn pathseg_find_tvalues_for_x(segment: PathSeg, x: f64) -> impl Iterator<Item = f64> + use<> {
+	match segment {
+		PathSeg::Line(Line { p0, p1 }) => {
+			// If the transformed linear bezier is on the x-axis, `a` and `b` will both be zero and `solve_linear` will return no roots
+			let a = p1.x - p0.x;
+			let b = p0.x - x;
+
+			// Find the roots of the linear equation `ax + b`.
+			// There exist roots when `a` is not 0
+			if a.abs() > MAX_ABSOLUTE_DIFFERENCE { [Some(-b / a), None, None] } else { [None; 3] }
+		}
+		PathSeg::Quad(QuadBez { p0, p1, p2 }) => {
+			let a = p2.x - 2.0 * p1.x + p0.x;
+			let b = 2.0 * (p1.x - p0.x);
+			let c = p0.x - x;
+			let r = solve_quadratic(c, b, a);
+			[r.get(0).map(|t| *t), r.get(1).map(|t| *t), None]
+		}
+		PathSeg::Cubic(CubicBez { p0, p1, p2, p3 }) => {
+			let a = p3.x - 3.0 * p2.x + 3.0 * p1.x - p0.x;
+			let b = 3.0 * (p2.x - 2.0 * p1.x + p0.x);
+			let c = 3.0 * (p1.x - p0.x);
+			let d = p0.x - x;
+			let r = solve_cubic(d, c, b, a);
+			[r.get(0).map(|t| *t), r.get(1).map(|t| *t), r.get(2).map(|t| *t)]
+		}
+	}
+	.into_iter()
+	.flatten()
+	.filter(|&t| (0.0..1.).contains(&t))
+}
+
+/// Find the `t`-value(s) such that the normal(s) at `t` pass through the specified point.
+pub fn pathseg_normals_to_point(segment: PathSeg, point: Point) -> Vec<f64> {
+	// We solve deriv(t) dot (self(t) - point) = 0.
+	let (mut x, mut y) = pathseg_to_parametric_polynomial(segment);
+	let x = x.coefficients_mut();
+	let y = y.coefficients_mut();
+	x[0] -= point.x;
+	y[0] -= point.y;
+	let poly = poly_cool::Poly::new([
+		x[0] * x[1] + y[0] * y[1],
+		x[1] * x[1] + y[1] * y[1] + 2. * (x[0] * x[2] + y[0] * y[2]),
+		3. * (x[2] * x[1] + y[2] * y[1]) + 3. * (x[0] * x[3] + y[0] * y[3]),
+		4. * (x[3] * x[1] + y[3] * y[1]) + 2. * (x[2] * x[2] + y[2] * y[2]),
+		5. * (x[3] * x[2] + y[3] * y[2]),
+		3. * (x[3] * x[3] + y[3] * y[3]),
+	]);
+	poly.roots_between(0., 1., 1e-8)
+}
+
+/// Find the `t`-value(s) such that the tangent(s) at `t` pass through the given point.
+pub fn pathseg_tangents_to_point(segment: PathSeg, point: Point) -> Vec<f64> {
+	segment.to_cubic().tangents_to_point(point).to_vec()
+}
+
 /// Return the subsegment for the given [TValue] range. Returns None if parametric value of `t1` is greater than `t2`.
 pub fn trim_pathseg(segment: PathSeg, t1: TValue, t2: TValue) -> Option<PathSeg> {
 	let t1 = eval_pathseg(segment, t1);
@@ -202,6 +280,68 @@ pub fn eval_pathseg(segment: PathSeg, t_value: TValue) -> f64 {
 	}
 }
 
+/// Return an approximation of the length centroid, together with the length, of the bezier curve.
+///
+/// The length centroid is the center of mass for the arc length of the Bezier segment.
+/// An infinitely thin wire forming the Bezier segment's shape would balance at this point.
+///
+/// - `accuracy` is used to approximate the curve.
+pub(crate) fn pathseg_length_centroid_and_length(segment: PathSeg, accuracy: Option<f64>) -> (Vec2, f64) {
+	match segment {
+		PathSeg::Line(line) => ((line.start().to_vec2() + line.end().to_vec2()) / 2., (line.start().to_vec2() - line.end().to_vec2()).length()),
+		PathSeg::Quad(quad_bez) => {
+			let QuadBez { p0, p1, p2 } = quad_bez;
+			// Use Casteljau subdivision, noting that the length is more than the straight line distance from start to end but less than the straight line distance through the handles
+			fn recurse(a0: Vec2, a1: Vec2, a2: Vec2, accuracy: f64, level: u8) -> (f64, Vec2) {
+				let lower = (a2 - a1).length();
+				let upper = (a1 - a0).length() + (a2 - a1).length();
+				if upper - lower <= 2. * accuracy || level >= 8 {
+					let length = (lower + upper) / 2.;
+					return (length, length * (a0 + a1 + a2) / 3.);
+				}
+
+				let b1 = 0.5 * (a0 + a1);
+				let c1 = 0.5 * (a1 + a2);
+				let b2 = 0.5 * (b1 + c1);
+
+				let (length1, centroid_part1) = recurse(a0, b1, b2, 0.5 * accuracy, level + 1);
+				let (length2, centroid_part2) = recurse(b2, c1, a2, 0.5 * accuracy, level + 1);
+				(length1 + length2, centroid_part1 + centroid_part2)
+			}
+
+			let (length, centroid_parts) = recurse(p0.to_vec2(), p1.to_vec2(), p2.to_vec2(), accuracy.unwrap_or_default(), 0);
+			(centroid_parts / length, length)
+		}
+		PathSeg::Cubic(cubic_bez) => {
+			let CubicBez { p0, p1, p2, p3 } = cubic_bez;
+
+			// Use Casteljau subdivision, noting that the length is more than the straight line distance from start to end but less than the straight line distance through the handles
+			fn recurse(a0: Vec2, a1: Vec2, a2: Vec2, a3: Vec2, accuracy: f64, level: u8) -> (f64, Vec2) {
+				let lower = (a3 - a0).length();
+				let upper = (a1 - a0).length() + (a2 - a1).length() + (a3 - a2).length();
+				if upper - lower <= 2. * accuracy || level >= 8 {
+					let length = (lower + upper) / 2.;
+					return (length, length * (a0 + a1 + a2 + a3) / 4.);
+				}
+
+				let b1 = 0.5 * (a0 + a1);
+				let t0 = 0.5 * (a1 + a2);
+				let c1 = 0.5 * (a2 + a3);
+				let b2 = 0.5 * (b1 + t0);
+				let c2 = 0.5 * (t0 + c1);
+				let b3 = 0.5 * (b2 + c2);
+
+				let (length1, centroid_part1) = recurse(a0, b1, b2, b3, 0.5 * accuracy, level + 1);
+				let (length2, centroid_part2) = recurse(b3, c2, c1, a3, 0.5 * accuracy, level + 1);
+				(length1 + length2, centroid_part1 + centroid_part2)
+			}
+
+			let (length, centroid_parts) = recurse(p0.to_vec2(), p1.to_vec2(), p2.to_vec2(), p3.to_vec2(), accuracy.unwrap_or_default(), 0);
+			(centroid_parts / length, length)
+		}
+	}
+}
+
 /// Finds the t value of 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_up_to_t / total_length` approximates the input `distance`.
 pub fn eval_pathseg_euclidean(segment: PathSeg, distance: f64, accuracy: f64) -> f64 {
@@ -392,8 +532,8 @@ pub fn miter_line_join(bezpath1: &BezPath, bezpath2: &BezPath, miter_limit: Opti
 	let in_segment = bezpath1.segments().last()?;
 	let out_segment = bezpath2.segments().next()?;
 
-	let in_tangent = segment_tangent(in_segment, 1.);
-	let out_tangent = segment_tangent(out_segment, 0.);
+	let in_tangent = pathseg_tangent(in_segment, 1.);
+	let out_tangent = pathseg_tangent(out_segment, 0.);
 
 	if in_tangent == DVec2::ZERO || out_tangent == DVec2::ZERO {
 		// Avoid panic from normalizing zero vectors
@@ -454,7 +594,7 @@ pub fn round_line_join(bezpath1: &BezPath, bezpath2: &BezPath, center: DVec2) ->
 	let center_to_left = left - center;
 
 	let in_segment = bezpath1.segments().last();
-	let in_tangent = in_segment.map(|in_segment| segment_tangent(in_segment, 1.));
+	let in_tangent = in_segment.map(|in_segment| pathseg_tangent(in_segment, 1.));
 
 	let mut angle = center_to_right.angle_to(center_to_left) / 2.;
 	let mut arc_point = center + DMat2::from_angle(angle).mul_vec2(center_to_right);

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

@@ -105,8 +105,8 @@ mod test {
 	use super::*;
 	use crate::Node;
 	use crate::extract_xy::{ExtractXyNode, XY};
+	use crate::subpath::Subpath;
 	use crate::vector::Vector;
-	use bezier_rs::Subpath;
 	use glam::DVec2;
 	use std::pin::Pin;
 

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

@@ -45,12 +45,26 @@ pub fn segment_intersections(segment1: PathSeg, segment2: PathSeg, accuracy: Opt
 	}
 }
 
+pub fn subsegment_intersections(segment1: PathSeg, min_t1: f64, max_t1: f64, segment2: PathSeg, min_t2: f64, max_t2: f64, accuracy: Option<f64>) -> Vec<(f64, f64)> {
+	let accuracy = accuracy.unwrap_or(DEFAULT_ACCURACY);
+
+	match (segment1, segment2) {
+		(PathSeg::Line(line), segment2) => segment2.intersect_line(line).iter().map(|i| (i.line_t, i.segment_t)).collect(),
+		(segment1, PathSeg::Line(line)) => segment1.intersect_line(line).iter().map(|i| (i.segment_t, i.line_t)).collect(),
+		(segment1, segment2) => {
+			let mut intersections = Vec::new();
+			segment_intersections_inner(segment1, min_t1, max_t1, segment2, min_t2, max_t2, accuracy, &mut intersections);
+			intersections
+		}
+	}
+}
+
 /// Implements [https://pomax.github.io/bezierinfo/#curveintersection] to find intersection between two Bezier segments
 /// by splitting the segment recursively until the size of the subsegment's bounding box is smaller than the accuracy.
 #[allow(clippy::too_many_arguments)]
 fn segment_intersections_inner(segment1: PathSeg, min_t1: f64, max_t1: f64, segment2: PathSeg, min_t2: f64, max_t2: f64, accuracy: f64, intersections: &mut Vec<(f64, f64)>) {
-	let bbox1 = segment1.bounding_box();
-	let bbox2 = segment2.bounding_box();
+	let bbox1 = segment1.subsegment(min_t1..max_t1).bounding_box();
+	let bbox2 = segment2.subsegment(min_t2..max_t2).bounding_box();
 
 	let mid_t1 = (min_t1 + max_t1) / 2.;
 	let mid_t2 = (min_t2 + max_t2) / 2.;
@@ -58,7 +72,7 @@ fn segment_intersections_inner(segment1: PathSeg, min_t1: f64, max_t1: f64, segm
 	// Check if the bounding boxes overlap
 	if bbox1.overlaps(bbox2) {
 		// If bounding boxes overlap and they are small enough, we have found an intersection
-		if bbox1.width() < accuracy && bbox1.height() < accuracy && bbox2.width() < accuracy && bbox2.height() < accuracy {
+		if bbox1.width().abs() < accuracy && bbox1.height().abs() < accuracy && bbox2.width().abs() < accuracy && bbox2.height().abs() < accuracy {
 			// Use the middle `t` value, append the corresponding `t` value
 			intersections.push((mid_t1, mid_t2));
 			return;
@@ -125,6 +139,66 @@ pub fn filtered_all_segment_intersections(segment1: PathSeg, segment2: PathSeg,
 	})
 }
 
+/// Helper function to compute intersections between lists of subcurves.
+/// This function uses the algorithm implemented in `intersections_between_subcurves`.
+fn intersections_between_vectors_of_path_segments(subcurves1: &[(f64, f64, PathSeg)], subcurves2: &[(f64, f64, PathSeg)], accuracy: Option<f64>) -> Vec<(f64, f64)> {
+	let segment_pairs = subcurves1.iter().flat_map(move |(t11, t12, curve1)| {
+		subcurves2
+			.iter()
+			.filter_map(move |(t21, t22, curve2)| curve1.bounding_box().overlaps(curve2.bounding_box()).then_some((t11, t12, curve1, t21, t22, curve2)))
+	});
+
+	segment_pairs
+		.flat_map(|(&t11, &t12, &curve1, &t21, &t22, &curve2)| subsegment_intersections(curve1, t11, t12, curve2, t21, t22, accuracy))
+		.collect::<Vec<(f64, f64)>>()
+}
+
+fn pathseg_self_intersection(segment: PathSeg, accuracy: Option<f64>) -> Vec<(f64, f64)> {
+	let cubic_bez = match segment {
+		PathSeg::Line(_) | PathSeg::Quad(_) => return vec![],
+		PathSeg::Cubic(cubic_bez) => cubic_bez,
+	};
+
+	// Get 2 copies of the reduced curves
+	let quads1 = cubic_bez.to_quads(DEFAULT_ACCURACY).map(|(t1, t2, quad_bez)| (t1, t2, PathSeg::Quad(quad_bez))).collect::<Vec<_>>();
+	let quads2 = quads1.clone();
+
+	let num_curves = quads1.len();
+
+	// Adjacent reduced curves cannot intersect
+	if num_curves <= 2 {
+		return vec![];
+	}
+
+	// For each curve, look for intersections with every curve that is at least 2 indices away
+	quads1
+		.iter()
+		.take(num_curves - 2)
+		.enumerate()
+		.flat_map(|(index, &subsegment)| intersections_between_vectors_of_path_segments(&[subsegment], &quads2[index + 2..], accuracy))
+		.collect()
+}
+
+/// Returns a list of parametric `t` values that correspond to the self intersection points of the current bezier curve. For each intersection point, the returned `t` value is the smaller of the two that correspond to the point.
+/// If the difference between 2 adjacent `t` values is less than the minimum difference, the filtering takes the larger `t` value and discards the smaller `t` value.
+/// - `error` - For intersections with non-linear beziers, `error` defines the threshold for bounding boxes to be considered an intersection point.
+/// - `minimum_separation` - The minimum difference between adjacent `t` values in sorted order
+pub fn pathseg_self_intersections(segment: PathSeg, accuracy: Option<f64>, minimum_separation: Option<f64>) -> Vec<(f64, f64)> {
+	let mut intersection_t_values = pathseg_self_intersection(segment, accuracy);
+	intersection_t_values.sort_by(|a, b| (a.0 + a.1).partial_cmp(&(b.0 + b.1)).unwrap());
+
+	intersection_t_values.iter().fold(Vec::new(), |mut accumulator, t| {
+		if !accumulator.is_empty()
+			&& (accumulator.last().unwrap().0 - t.0).abs() < minimum_separation.unwrap_or(MIN_SEPARATION_VALUE)
+			&& (accumulator.last().unwrap().1 - t.1).abs() < minimum_separation.unwrap_or(MIN_SEPARATION_VALUE)
+		{
+			accumulator.pop();
+		}
+		accumulator.push(*t);
+		accumulator
+	})
+}
+
 #[cfg(test)]
 mod tests {
 	use super::{bezpath_and_segment_intersections, filtered_segment_intersections};

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

@@ -1,7 +1,7 @@
 use glam::DVec2;
 use kurbo::{ParamCurve, ParamCurveDeriv, PathSeg};
 
-pub fn segment_tangent(segment: PathSeg, t: f64) -> DVec2 {
+pub fn pathseg_tangent(segment: PathSeg, t: f64) -> DVec2 {
 	// NOTE: .deriv() method gives inaccurate result when it is 1.
 	let t = if t == 1. { 1. - f64::EPSILON } else { t };
 

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

@@ -1,8 +1,12 @@
+use super::algorithms::intersection::filtered_segment_intersections;
+use super::misc::dvec2_to_point;
 use crate::math::math_ext::QuadExt;
 use crate::math::quad::Quad;
+use crate::subpath::Subpath;
 use crate::vector::PointId;
-use bezier_rs::Subpath;
+use crate::vector::misc::point_to_dvec2;
 use glam::{DAffine2, DMat2, DVec2};
+use kurbo::{Affine, ParamCurve, PathSeg, Point, Shape};
 
 #[derive(Copy, Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 pub struct FreePoint {
@@ -99,7 +103,7 @@ impl ClickTarget {
 	}
 
 	/// Does the click target intersect the path
-	pub fn intersect_path<It: Iterator<Item = bezier_rs::Bezier>>(&self, mut bezier_iter: impl FnMut() -> It, layer_transform: DAffine2) -> bool {
+	pub fn intersect_path<It: Iterator<Item = PathSeg>>(&self, mut bezier_iter: impl FnMut() -> It, layer_transform: DAffine2) -> bool {
 		// Check if the matrix is not invertible
 		let mut layer_transform = layer_transform;
 		if layer_transform.matrix2.determinant().abs() <= f64::EPSILON {
@@ -107,25 +111,25 @@ impl ClickTarget {
 		}
 
 		let inverse = layer_transform.inverse();
-		let mut bezier_iter = || bezier_iter().map(|bezier| bezier.apply_transformation(|point| inverse.transform_point2(point)));
+		let mut bezier_iter = || bezier_iter().map(|bezier| Affine::new(inverse.to_cols_array()) * bezier);
 
 		match self.target_type() {
 			ClickTargetType::Subpath(subpath) => {
 				// Check if outlines intersect
-				let outline_intersects = |path_segment: bezier_rs::Bezier| bezier_iter().any(|line| !path_segment.intersections(&line, None, None).is_empty());
+				let outline_intersects = |path_segment: PathSeg| bezier_iter().any(|line| !filtered_segment_intersections(path_segment, line, None, None).is_empty());
 				if subpath.iter().any(outline_intersects) {
 					return true;
 				}
 				// Check if selection is entirely within the shape
-				if subpath.closed() && bezier_iter().next().is_some_and(|bezier| subpath.contains_point(bezier.start)) {
+				if subpath.closed() && bezier_iter().next().is_some_and(|bezier| subpath.contains_point(point_to_dvec2(bezier.start()))) {
 					return true;
 				}
 
 				// Check if shape is entirely within selection
 				let any_point_from_subpath = subpath.manipulator_groups().first().map(|manipulators| manipulators.anchor);
-				any_point_from_subpath.is_some_and(|shape_point| bezier_iter().map(|bezier| bezier.winding(shape_point)).sum::<i32>() != 0)
+				any_point_from_subpath.is_some_and(|shape_point| bezier_iter().map(|bezier| bezier.winding(Point::new(shape_point.x, shape_point.y))).sum::<i32>() != 0)
 			}
-			ClickTargetType::FreePoint(point) => bezier_iter().map(|bezier: bezier_rs::Bezier| bezier.winding(point.position)).sum::<i32>() != 0,
+			ClickTargetType::FreePoint(point) => bezier_iter().map(|bezier: PathSeg| bezier.winding(dvec2_to_point(point.position))).sum::<i32>() != 0,
 		}
 	}
 
@@ -144,7 +148,7 @@ impl ClickTarget {
 		// Allows for selecting lines
 		// TODO: actual intersection of stroke
 		let inflated_quad = Quad::from_box(target_bounds);
-		self.intersect_path(|| inflated_quad.bezier_lines(), layer_transform)
+		self.intersect_path(|| inflated_quad.to_lines(), layer_transform)
 	}
 
 	/// Does the click target intersect the point (not accounting for stroke size)

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

@@ -2,10 +2,10 @@ use super::misc::{ArcType, AsU64, GridType};
 use super::{PointId, SegmentId, StrokeId};
 use crate::Ctx;
 use crate::registry::types::{Angle, PixelSize};
+use crate::subpath;
 use crate::table::Table;
 use crate::vector::Vector;
 use crate::vector::misc::HandleId;
-use bezier_rs::Subpath;
 use glam::DVec2;
 
 trait CornerRadius {
@@ -14,7 +14,7 @@ trait CornerRadius {
 impl CornerRadius for f64 {
 	fn generate(self, size: DVec2, clamped: bool) -> Table<Vector> {
 		let clamped_radius = if clamped { self.clamp(0., size.x.min(size.y).max(0.) / 2.) } else { self };
-		Table::new_from_element(Vector::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., [clamped_radius; 4])))
+		Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_rounded_rect(size / -2., size / 2., [clamped_radius; 4])))
 	}
 }
 impl CornerRadius for [f64; 4] {
@@ -34,7 +34,7 @@ impl CornerRadius for [f64; 4] {
 		} else {
 			self
 		};
-		Table::new_from_element(Vector::from_subpath(Subpath::new_rounded_rect(size / -2., size / 2., clamped_radius)))
+		Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_rounded_rect(size / -2., size / 2., clamped_radius)))
 	}
 }
 
@@ -47,7 +47,7 @@ fn circle(
 	radius: f64,
 ) -> Table<Vector> {
 	let radius = radius.abs();
-	Table::new_from_element(Vector::from_subpath(Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
+	Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_ellipse(DVec2::splat(-radius), DVec2::splat(radius))))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
@@ -63,14 +63,14 @@ fn arc(
 	sweep_angle: Angle,
 	arc_type: ArcType,
 ) -> Table<Vector> {
-	Table::new_from_element(Vector::from_subpath(Subpath::new_arc(
+	Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_arc(
 		radius,
 		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,
 		},
 	)))
 }
@@ -90,7 +90,7 @@ fn ellipse(
 	let corner1 = -radius;
 	let corner2 = radius;
 
-	let mut ellipse = Vector::from_subpath(Subpath::new_ellipse(corner1, corner2));
+	let mut ellipse = Vector::from_subpath(subpath::Subpath::new_ellipse(corner1, corner2));
 
 	let len = ellipse.segment_domain.ids().len();
 	for i in 0..len {
@@ -133,7 +133,7 @@ fn regular_polygon<T: AsU64>(
 ) -> Table<Vector> {
 	let points = sides.as_u64();
 	let radius: f64 = radius * 2.;
-	Table::new_from_element(Vector::from_subpath(Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius)))
+	Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_regular_polygon(DVec2::splat(-radius), points, radius)))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
@@ -155,12 +155,12 @@ fn star<T: AsU64>(
 	let diameter: f64 = radius_1 * 2.;
 	let inner_diameter = radius_2 * 2.;
 
-	Table::new_from_element(Vector::from_subpath(Subpath::new_star_polygon(DVec2::splat(-diameter), points, diameter, inner_diameter)))
+	Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_star_polygon(DVec2::splat(-diameter), points, diameter, inner_diameter)))
 }
 
 #[node_macro::node(category("Vector: Shape"))]
 fn line(_: impl Ctx, _primary: (), #[default(0., 0.)] start: PixelSize, #[default(100., 100.)] end: PixelSize) -> Table<Vector> {
-	Table::new_from_element(Vector::from_subpath(Subpath::new_line(start, end)))
+	Table::new_from_element(Vector::from_subpath(subpath::Subpath::new_line(start, end)))
 }
 
 trait GridSpacing {
@@ -212,7 +212,7 @@ fn grid<T: GridSpacing>(
 						if let Some(other_index) = to_index {
 							vector
 								.segment_domain
-								.push(segment_id.next_id(), other_index, current_index, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
+								.push(segment_id.next_id(), other_index, current_index, subpath::BezierHandles::Linear, StrokeId::ZERO);
 						}
 					};
 
@@ -249,7 +249,7 @@ fn grid<T: GridSpacing>(
 						if let Some(other_index) = to_index {
 							vector
 								.segment_domain
-								.push(segment_id.next_id(), other_index, current_index, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
+								.push(segment_id.next_id(), other_index, current_index, subpath::BezierHandles::Linear, StrokeId::ZERO);
 						}
 					};
 
@@ -289,7 +289,7 @@ mod tests {
 		assert_eq!(grid.iter().next().unwrap().element.point_domain.ids().len(), 5 * 5);
 		assert_eq!(grid.iter().next().unwrap().element.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
 		for (_, bezier, _, _) in grid.iter().next().unwrap().element.segment_bezier_iter() {
-			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
+			assert_eq!(bezier.handles, subpath::BezierHandles::Linear);
 			assert!(
 				((bezier.start - bezier.end).length() - 10.).abs() < 1e-5,
 				"Length of {} should be 10",
@@ -304,7 +304,7 @@ mod tests {
 		assert_eq!(grid.iter().next().unwrap().element.point_domain.ids().len(), 5 * 5);
 		assert_eq!(grid.iter().next().unwrap().element.segment_bezier_iter().count(), 4 * 5 + 4 * 9);
 		for (_, bezier, _, _) in grid.iter().next().unwrap().element.segment_bezier_iter() {
-			assert_eq!(bezier.handles, bezier_rs::BezierHandles::Linear);
+			assert_eq!(bezier.handles, subpath::BezierHandles::Linear);
 			let vector = bezier.start - bezier.end;
 			let angle = (vector.angle_to(DVec2::X).to_degrees() + 180.) % 180.;
 			assert!([90., 150., 40.].into_iter().any(|target| (target - angle).abs() < 1e-10), "unexpected angle of {}", angle)

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

@@ -1,7 +1,7 @@
 use super::PointId;
 use super::algorithms::offset_subpath::MAX_ABSOLUTE_DIFFERENCE;
+use crate::subpath::{BezierHandles, ManipulatorGroup};
 use crate::vector::{SegmentId, Vector};
-use bezier_rs::{BezierHandles, ManipulatorGroup};
 use dyn_any::DynAny;
 use glam::DVec2;
 use kurbo::{BezPath, CubicBez, Line, ParamCurve, PathSeg, Point, QuadBez};
@@ -115,18 +115,18 @@ pub fn segment_to_handles(segment: &PathSeg) -> BezierHandles {
 
 pub fn handles_to_segment(start: DVec2, handles: BezierHandles, end: DVec2) -> PathSeg {
 	match handles {
-		bezier_rs::BezierHandles::Linear => {
+		BezierHandles::Linear => {
 			let p0 = dvec2_to_point(start);
 			let p1 = dvec2_to_point(end);
 			PathSeg::Line(Line::new(p0, p1))
 		}
-		bezier_rs::BezierHandles::Quadratic { handle } => {
+		BezierHandles::Quadratic { handle } => {
 			let p0 = dvec2_to_point(start);
 			let p1 = dvec2_to_point(handle);
 			let p2 = dvec2_to_point(end);
 			PathSeg::Quad(QuadBez::new(p0, p1, p2))
 		}
-		bezier_rs::BezierHandles::Cubic { handle_start, handle_end } => {
+		BezierHandles::Cubic { handle_start, handle_end } => {
 			let p0 = dvec2_to_point(start);
 			let p1 = dvec2_to_point(handle_start);
 			let p2 = dvec2_to_point(handle_end);
@@ -211,8 +211,8 @@ pub fn is_linear(segment: PathSeg) -> bool {
 	}
 }
 
-/// Get an iterator over the coordinates of all points in a path segment.
-pub fn get_segment_points(segment: PathSeg) -> Vec<Point> {
+/// Get an vec of all the points in a path segment.
+pub fn pathseg_points_vec(segment: PathSeg) -> Vec<Point> {
 	match segment {
 		PathSeg::Line(line) => [line.p0, line.p1].to_vec(),
 		PathSeg::Quad(quad_bez) => [quad_bez.p0, quad_bez.p1, quad_bez.p2].to_vec(),
@@ -225,8 +225,8 @@ pub fn pathseg_abs_diff_eq(seg1: PathSeg, seg2: PathSeg, max_abs_diff: f64) -> b
 	let seg1 = if is_linear(seg1) { PathSeg::Line(Line::new(seg1.start(), seg1.end())) } else { seg1 };
 	let seg2 = if is_linear(seg2) { PathSeg::Line(Line::new(seg2.start(), seg2.end())) } else { seg2 };
 
-	let seg1_points = get_segment_points(seg1);
-	let seg2_points = get_segment_points(seg2);
+	let seg1_points = pathseg_points_vec(seg1);
+	let seg2_points = pathseg_points_vec(seg2);
 
 	let cmp = |a: f64, b: f64| a.sub(b).abs() < max_abs_diff;
 

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

@@ -9,7 +9,6 @@ mod vector_modification;
 mod vector_nodes;
 mod vector_types;
 
-pub use bezier_rs;
 pub use reference_point::*;
 pub use style::PathStyle;
 pub use vector_nodes::*;

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

@@ -1,6 +1,6 @@
+use crate::subpath::{Bezier, BezierHandles, Identifier, ManipulatorGroup, Subpath};
 use crate::vector::misc::{HandleId, dvec2_to_point};
 use crate::vector::vector_types::Vector;
-use bezier_rs::{BezierHandles, ManipulatorGroup};
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 use kurbo::{CubicBez, Line, PathSeg, QuadBez};
@@ -442,11 +442,7 @@ impl SegmentDomain {
 		zip(ids, zip(start_point, zip(end_point, handles))).map(|(id, (start_point, (end_point, handles)))| (id, start_point, end_point, handles))
 	}
 
-	pub(crate) fn pair_handles_and_points_mut_by_index(
-		&mut self,
-		index1: usize,
-		index2: usize,
-	) -> (&mut bezier_rs::BezierHandles, &mut usize, &mut usize, &mut bezier_rs::BezierHandles, &mut usize, &mut usize) {
+	pub(crate) fn pair_handles_and_points_mut_by_index(&mut self, index1: usize, index2: usize) -> (&mut BezierHandles, &mut usize, &mut usize, &mut BezierHandles, &mut usize, &mut usize) {
 		// Use split_at_mut to avoid multiple mutable borrows of the same slice
 		let (handles_first, handles_second) = self.handles.split_at_mut(index2.max(index1));
 		let (start_first, start_second) = self.start_point.split_at_mut(index2.max(index1));
@@ -686,25 +682,25 @@ impl Vector {
 		}
 	}
 
-	/// Construct a [`bezier_rs::Bezier`] curve spanning from the resolved position of the start and end points with the specified handles.
-	fn segment_to_bezier_with_index(&self, start: usize, end: usize, handles: BezierHandles) -> bezier_rs::Bezier {
+	/// Construct a [`Bezier`] curve spanning from the resolved position of the start and end points with the specified handles.
+	fn segment_to_bezier_with_index(&self, start: usize, end: usize, handles: BezierHandles) -> Bezier {
 		let start = self.point_domain.positions()[start];
 		let end = self.point_domain.positions()[end];
-		bezier_rs::Bezier { start, end, handles }
+		Bezier { start, end, handles }
 	}
 
-	/// Tries to convert a segment with the specified id to a [`bezier_rs::Bezier`], returning None if the id is invalid.
-	pub fn segment_from_id(&self, id: SegmentId) -> Option<bezier_rs::Bezier> {
+	/// Tries to convert a segment with the specified id to a [`Bezier`], returning None if the id is invalid.
+	pub fn segment_from_id(&self, id: SegmentId) -> Option<Bezier> {
 		self.segment_points_from_id(id).map(|(_, _, bezier)| bezier)
 	}
 
-	/// Tries to convert a segment with the specified id to the start and end points and a [`bezier_rs::Bezier`], returning None if the id is invalid.
-	pub fn segment_points_from_id(&self, id: SegmentId) -> Option<(PointId, PointId, bezier_rs::Bezier)> {
+	/// Tries to convert a segment with the specified id to the start and end points and a [`Bezier`], returning None if the id is invalid.
+	pub fn segment_points_from_id(&self, id: SegmentId) -> Option<(PointId, PointId, Bezier)> {
 		Some(self.segment_points_from_index(self.segment_domain.id_to_index(id)?))
 	}
 
-	/// Tries to convert a segment with the specified index to the start and end points and a [`bezier_rs::Bezier`].
-	pub fn segment_points_from_index(&self, index: usize) -> (PointId, PointId, bezier_rs::Bezier) {
+	/// Tries to convert a segment with the specified index to the start and end points and a [`Bezier`].
+	pub fn segment_points_from_index(&self, index: usize) -> (PointId, PointId, Bezier) {
 		let start = self.segment_domain.start_point[index];
 		let end = self.segment_domain.end_point[index];
 		let start_id = self.point_domain.ids()[start];
@@ -712,7 +708,7 @@ impl Vector {
 		(start_id, end_id, self.segment_to_bezier_with_index(start, end, self.segment_domain.handles[index]))
 	}
 
-	/// Iterator over all of the [`bezier_rs::Bezier`] following the order that they are stored in the segment domain, skipping invalid segments.
+	/// Iterator over all of the [`Bezier`] following the order that they are stored in the segment domain, skipping invalid segments.
 	pub fn segment_iter(&self) -> impl Iterator<Item = (SegmentId, PathSeg, PointId, PointId)> {
 		let to_segment = |(((&handles, &id), &start), &end)| (id, self.path_segment_from_index(start, end, handles), self.point_domain.ids()[start], self.point_domain.ids()[end]);
 
@@ -725,8 +721,8 @@ impl Vector {
 			.map(to_segment)
 	}
 
-	/// Iterator over all of the [`bezier_rs::Bezier`] following the order that they are stored in the segment domain, skipping invalid segments.
-	pub fn segment_bezier_iter(&self) -> impl Iterator<Item = (SegmentId, bezier_rs::Bezier, PointId, PointId)> + '_ {
+	/// Iterator over all of the [`Bezier`] following the order that they are stored in the segment domain, skipping invalid segments.
+	pub fn segment_bezier_iter(&self) -> impl Iterator<Item = (SegmentId, Bezier, PointId, PointId)> + '_ {
 		let to_bezier = |(((&handles, &id), &start), &end)| (id, self.segment_to_bezier_with_index(start, end, handles), self.point_domain.ids()[start], self.point_domain.ids()[end]);
 		self.segment_domain
 			.handles
@@ -808,8 +804,8 @@ impl Vector {
 		}
 	}
 
-	/// Construct a [`bezier_rs::Bezier`] curve from an iterator of segments with (handles, start point, end point) independently of discontinuities.
-	pub fn subpath_from_segments_ignore_discontinuities(&self, segments: impl Iterator<Item = (BezierHandles, usize, usize)>) -> Option<bezier_rs::Subpath<PointId>> {
+	/// Construct a [`Bezier`] curve from an iterator of segments with (handles, start point, end point) independently of discontinuities.
+	pub fn subpath_from_segments_ignore_discontinuities(&self, segments: impl Iterator<Item = (BezierHandles, usize, usize)>) -> Option<Subpath<PointId>> {
 		let mut first_point = None;
 		let mut manipulators_list = Vec::new();
 		let mut last: Option<(usize, BezierHandles)> = None;
@@ -842,10 +838,10 @@ impl Vector {
 			}
 		}
 
-		Some(bezier_rs::Subpath::new(manipulators_list, closed))
+		Some(Subpath::new(manipulators_list, closed))
 	}
 
-	/// Construct a [`bezier_rs::Bezier`] curve for each region, skipping invalid regions.
+	/// Construct a [`Bezier`] curve for each region, skipping invalid regions.
 	pub fn region_manipulator_groups(&self) -> impl Iterator<Item = (RegionId, Vec<ManipulatorGroup<PointId>>)> + '_ {
 		self.region_domain
 			.id
@@ -903,12 +899,12 @@ impl Vector {
 		}
 	}
 
-	/// Construct a [`bezier_rs::Bezier`] curve for stroke.
-	pub fn stroke_bezier_paths(&self) -> impl Iterator<Item = bezier_rs::Subpath<PointId>> {
-		self.build_stroke_path_iter().map(|(manipulators_list, closed)| bezier_rs::Subpath::new(manipulators_list, closed))
+	/// Construct a [`Bezier`] curve for stroke.
+	pub fn stroke_bezier_paths(&self) -> impl Iterator<Item = Subpath<PointId>> {
+		self.build_stroke_path_iter().map(|(manipulators_list, closed)| Subpath::new(manipulators_list, closed))
 	}
 
-	/// Construct and return an iterator of Vec of `(bezier_rs::ManipulatorGroup<PointId>], bool)` for stroke.
+	/// Construct and return an iterator of Vec of `(ManipulatorGroup<PointId>], bool)` for stroke.
 	/// The boolean in the tuple indicates if the path is closed.
 	pub fn stroke_manipulator_groups(&self) -> impl Iterator<Item = (Vec<ManipulatorGroup<PointId>>, bool)> {
 		self.build_stroke_path_iter()
@@ -1094,7 +1090,7 @@ impl Iterator for StrokePathIter<'_> {
 	}
 }
 
-impl bezier_rs::Identifier for PointId {
+impl Identifier for PointId {
 	fn new() -> Self {
 		Self::generate()
 	}

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

@@ -1,9 +1,9 @@
 use super::*;
 use crate::Ctx;
+use crate::subpath::BezierHandles;
 use crate::table::{Table, TableRow};
 use crate::uuid::{NodeId, generate_uuid};
 use crate::vector::misc::{HandleId, HandleType, point_to_dvec2};
-use bezier_rs::BezierHandles;
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 use kurbo::{BezPath, PathEl, Point};
@@ -684,14 +684,15 @@ impl HandleExt for HandleId {
 
 #[cfg(test)]
 mod tests {
+	use kurbo::{PathSeg, QuadBez};
+
 	use super::*;
 
+	use crate::subpath::{Bezier, Subpath};
+
 	#[test]
 	fn modify_new() {
-		let vector = Vector::from_subpaths(
-			[bezier_rs::Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE), bezier_rs::Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO)],
-			false,
-		);
+		let vector = Vector::from_subpaths([Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE), Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO)], false);
 
 		let modify = VectorModification::create_from_vector(&vector);
 
@@ -702,14 +703,13 @@ mod tests {
 
 	#[test]
 	fn modify_existing() {
-		use bezier_rs::{Bezier, Subpath};
 		let subpaths = [
 			Subpath::new_ellipse(DVec2::ZERO, DVec2::ONE),
 			Subpath::new_rect(DVec2::NEG_ONE, DVec2::ZERO),
 			Subpath::from_beziers(
 				&[
-					Bezier::from_quadratic_dvec2(DVec2::new(0., 0.), DVec2::new(5., 10.), DVec2::new(10., 0.)),
-					Bezier::from_quadratic_dvec2(DVec2::new(10., 0.), DVec2::new(15., 10.), DVec2::new(20., 0.)),
+					PathSeg::Quad(QuadBez::new(Point::new(0., 0.), Point::new(5., 10.), Point::new(10., 0.))),
+					PathSeg::Quad(QuadBez::new(Point::new(10., 0.), Point::new(15., 10.), Point::new(20., 0.))),
 				],
 				false,
 			),

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

@@ -7,6 +7,7 @@ use super::{PointId, SegmentDomain, SegmentId, StrokeId, Vector, VectorExt};
 use crate::bounds::{BoundingBox, RenderBoundingBox};
 use crate::raster_types::{CPU, GPU, Raster};
 use crate::registry::types::{Angle, Fraction, IntegerCount, Length, Multiplier, Percentage, PixelLength, PixelSize, SeedValue};
+use crate::subpath::{BezierHandles, ManipulatorGroup};
 use crate::table::{Table, TableRow, TableRowMut};
 use crate::transform::{Footprint, ReferencePoint, Transform};
 use crate::vector::PointDomain;
@@ -17,7 +18,6 @@ use crate::vector::misc::{handles_to_segment, segment_to_handles};
 use crate::vector::style::{PaintOrder, StrokeAlign, StrokeCap, StrokeJoin};
 use crate::vector::{FillId, RegionId};
 use crate::{CloneVarArgs, Color, Context, Ctx, ExtractAll, Graphic, OwnedContextImpl};
-use bezier_rs::ManipulatorGroup;
 use core::f64::consts::PI;
 use core::hash::{Hash, Hasher};
 use glam::{DAffine2, DVec2};
@@ -827,11 +827,11 @@ async fn points_to_polyline(_: impl Ctx, mut points: Table<Vector>, #[default(tr
 
 		if points_count > 2 {
 			(0..points_count - 1).for_each(|i| {
-				segment_domain.push(SegmentId::generate(), i, i + 1, bezier_rs::BezierHandles::Linear, StrokeId::generate());
+				segment_domain.push(SegmentId::generate(), i, i + 1, BezierHandles::Linear, StrokeId::generate());
 			});
 
 			if closed {
-				segment_domain.push(SegmentId::generate(), points_count - 1, 0, bezier_rs::BezierHandles::Linear, StrokeId::generate());
+				segment_domain.push(SegmentId::generate(), points_count - 1, 0, BezierHandles::Linear, StrokeId::generate());
 
 				row.element
 					.region_domain
@@ -1351,7 +1351,7 @@ async fn spline(_: impl Ctx, content: Table<Vector>) -> Table<Vector> {
 
 					let handle_start = first_handles[i];
 					let handle_end = positions[next_index] * 2. - first_handles[next_index];
-					let handles = bezier_rs::BezierHandles::Cubic { handle_start, handle_end };
+					let handles = BezierHandles::Cubic { handle_start, handle_end };
 
 					segment_domain.push(SegmentId::generate(), start_index, end_index, handles, stroke_id);
 				}
@@ -1405,14 +1405,14 @@ async fn jitter_points(
 				}
 
 				match handles {
-					bezier_rs::BezierHandles::Cubic { handle_start, handle_end } => {
+					BezierHandles::Cubic { handle_start, handle_end } => {
 						*handle_start += start_delta;
 						*handle_end += end_delta;
 					}
-					bezier_rs::BezierHandles::Quadratic { handle } => {
+					BezierHandles::Quadratic { handle } => {
 						*handle = row.transform.transform_point2(*handle) + (start_delta + end_delta) / 2.;
 					}
-					bezier_rs::BezierHandles::Linear => {}
+					BezierHandles::Linear => {}
 				}
 			}
 
@@ -1846,7 +1846,7 @@ fn bevel_algorithm(mut vector: Vector, transform: DAffine2, distance: f64) -> Ve
 		let mut next_id = vector.segment_domain.next_id();
 
 		for &[start, end] in new_segments {
-			let handles = bezier_rs::BezierHandles::Linear;
+			let handles = BezierHandles::Linear;
 			vector.segment_domain.push(next_id.next_id(), start, end, handles, StrokeId::ZERO);
 		}
 	}

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

@@ -4,12 +4,12 @@ pub use super::vector_attributes::*;
 pub use super::vector_modification::*;
 use crate::bounds::{BoundingBox, RenderBoundingBox};
 use crate::math::quad::Quad;
+use crate::subpath::{BezierHandles, ManipulatorGroup, Subpath};
 use crate::table::Table;
 use crate::transform::Transform;
 use crate::vector::click_target::{ClickTargetType, FreePoint};
 use crate::vector::misc::{HandleId, ManipulatorPointId};
 use crate::{AlphaBlending, Color, Graphic};
-use bezier_rs::{BezierHandles, ManipulatorGroup};
 use core::borrow::Borrow;
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
@@ -60,15 +60,15 @@ impl std::hash::Hash for Vector {
 
 impl Vector {
 	/// Add a Bezier-rs subpath to this path.
-	pub fn append_subpath(&mut self, subpath: impl Borrow<bezier_rs::Subpath<PointId>>, preserve_id: bool) {
-		let subpath: &bezier_rs::Subpath<PointId> = subpath.borrow();
+	pub fn append_subpath(&mut self, subpath: impl Borrow<Subpath<PointId>>, preserve_id: bool) {
+		let subpath: &Subpath<PointId> = subpath.borrow();
 		let stroke_id = StrokeId::ZERO;
 		let mut point_id = self.point_domain.next_id();
 
 		let handles = |a: &ManipulatorGroup<_>, b: &ManipulatorGroup<_>| match (a.out_handle, b.in_handle) {
-			(None, None) => bezier_rs::BezierHandles::Linear,
-			(Some(handle), None) | (None, Some(handle)) => bezier_rs::BezierHandles::Quadratic { handle },
-			(Some(handle_start), Some(handle_end)) => bezier_rs::BezierHandles::Cubic { handle_start, handle_end },
+			(None, None) => BezierHandles::Linear,
+			(Some(handle), None) | (None, Some(handle)) => BezierHandles::Quadratic { handle },
+			(Some(handle_start), Some(handle_end)) => BezierHandles::Cubic { handle_start, handle_end },
 		};
 		let [mut first_seg, mut last_seg] = [None, None];
 		let mut segment_id = self.segment_domain.next_id();
@@ -132,7 +132,7 @@ impl Vector {
 	}
 
 	/// Construct some new vector path from a single Bezier-rs subpath with an identity transform and black fill.
-	pub fn from_subpath(subpath: impl Borrow<bezier_rs::Subpath<PointId>>) -> Self {
+	pub fn from_subpath(subpath: impl Borrow<Subpath<PointId>>) -> Self {
 		Self::from_subpaths([subpath], false)
 	}
 
@@ -144,7 +144,7 @@ impl Vector {
 	}
 
 	/// Construct some new vector path from Bezier-rs subpaths with an identity transform and black fill.
-	pub fn from_subpaths(subpaths: impl IntoIterator<Item = impl Borrow<bezier_rs::Subpath<PointId>>>, preserve_id: bool) -> Self {
+	pub fn from_subpaths(subpaths: impl IntoIterator<Item = impl Borrow<Subpath<PointId>>>, preserve_id: bool) -> Self {
 		let mut vector = Self::default();
 
 		for subpath in subpaths.into_iter() {
@@ -185,7 +185,7 @@ impl Vector {
 
 		for (start, end) in segments_to_add {
 			let segment_id = self.segment_domain.next_id().next_id();
-			self.segment_domain.push(segment_id, start, end, bezier_rs::BezierHandles::Linear, StrokeId::ZERO);
+			self.segment_domain.push(segment_id, start, end, BezierHandles::Linear, StrokeId::ZERO);
 		}
 	}
 
@@ -244,14 +244,19 @@ impl Vector {
 		self.segment_domain.end_point().iter().map(|&index| self.point_domain.ids()[index])
 	}
 
-	pub fn push(&mut self, id: SegmentId, start: PointId, end: PointId, handles: bezier_rs::BezierHandles, stroke: StrokeId) {
+	pub fn push(&mut self, id: SegmentId, start: PointId, end: PointId, handles: (Option<DVec2>, Option<DVec2>), stroke: StrokeId) {
 		let [Some(start), Some(end)] = [start, end].map(|id| self.point_domain.resolve_id(id)) else {
 			return;
 		};
+		let handles = match handles {
+			(None, None) => BezierHandles::Linear,
+			(None, Some(handle)) | (Some(handle), None) => BezierHandles::Quadratic { handle },
+			(Some(handle_start), Some(handle_end)) => BezierHandles::Cubic { handle_start, handle_end },
+		};
 		self.segment_domain.push(id, start, end, handles, stroke)
 	}
 
-	pub fn handles_mut(&mut self) -> impl Iterator<Item = (SegmentId, &mut bezier_rs::BezierHandles, PointId, PointId)> {
+	pub fn handles_mut(&mut self) -> impl Iterator<Item = (SegmentId, &mut BezierHandles, PointId, PointId)> {
 		self.segment_domain
 			.handles_mut()
 			.map(|(id, handles, start, end)| (id, handles, self.point_domain.ids()[start], self.point_domain.ids()[end]))
@@ -515,9 +520,11 @@ pub fn migrate_vector<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Resu
 
 #[cfg(test)]
 mod tests {
+	use kurbo::{CubicBez, PathSeg, Point};
+
 	use super::*;
 
-	fn assert_subpath_eq(generated: &[bezier_rs::Subpath<PointId>], expected: &[bezier_rs::Subpath<PointId>]) {
+	fn assert_subpath_eq(generated: &[Subpath<PointId>], expected: &[Subpath<PointId>]) {
 		assert_eq!(generated.len(), expected.len());
 		for (generated, expected) in generated.iter().zip(expected) {
 			assert_eq!(generated.manipulator_groups().len(), expected.manipulator_groups().len());
@@ -532,10 +539,10 @@ mod tests {
 
 	#[test]
 	fn construct_closed_subpath() {
-		let circle = bezier_rs::Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
+		let circle = Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
 		let vector = Vector::from_subpath(&circle);
 		assert_eq!(vector.point_domain.ids().len(), 4);
-		let bezier_paths = vector.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
+		let bezier_paths = vector.segment_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
 		assert_eq!(bezier_paths.len(), 4);
 		assert!(bezier_paths.iter().all(|&bezier| circle.iter().any(|original_bezier| original_bezier == bezier)));
 
@@ -545,11 +552,11 @@ mod tests {
 
 	#[test]
 	fn construct_open_subpath() {
-		let bezier = bezier_rs::Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::NEG_ONE, DVec2::ONE, DVec2::X);
-		let subpath = bezier_rs::Subpath::from_bezier(&bezier);
+		let bezier = PathSeg::Cubic(CubicBez::new(Point::ZERO, Point::new(-1., -1.), Point::new(1., 1.), Point::new(1., 0.)));
+		let subpath = Subpath::from_bezier(bezier);
 		let vector = Vector::from_subpath(&subpath);
 		assert_eq!(vector.point_domain.ids().len(), 2);
-		let bezier_paths = vector.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
+		let bezier_paths = vector.segment_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
 		assert_eq!(bezier_paths, vec![bezier]);
 
 		let generated = vector.stroke_bezier_paths().collect::<Vec<_>>();
@@ -558,14 +565,14 @@ mod tests {
 
 	#[test]
 	fn construct_many_subpath() {
-		let curve = bezier_rs::Bezier::from_cubic_dvec2(DVec2::ZERO, DVec2::NEG_ONE, DVec2::ONE, DVec2::X);
-		let curve = bezier_rs::Subpath::from_bezier(&curve);
-		let circle = bezier_rs::Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
+		let curve = PathSeg::Cubic(CubicBez::new(Point::ZERO, Point::new(-1., -1.), Point::new(1., 1.), Point::new(1., 0.)));
+		let curve = Subpath::from_bezier(curve);
+		let circle = Subpath::new_ellipse(DVec2::NEG_ONE, DVec2::ONE);
 
 		let vector = Vector::from_subpaths([&curve, &circle], false);
 		assert_eq!(vector.point_domain.ids().len(), 6);
 
-		let bezier_paths = vector.segment_bezier_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
+		let bezier_paths = vector.segment_iter().map(|(_, bezier, _, _)| bezier).collect::<Vec<_>>();
 		assert_eq!(bezier_paths.len(), 5);
 		assert!(bezier_paths.iter().all(|&bezier| circle.iter().chain(curve.iter()).any(|original_bezier| original_bezier == bezier)));
 

node-graph/gpath-bool/Cargo.toml

@@ -9,7 +9,6 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 # Local dependencies
 dyn-any = { workspace = true }
-bezier-rs = { workspace = true }
 graphene-core = { workspace = true }
 node-macro = { workspace = true }
 glam = { workspace = true }
@@ -17,3 +16,4 @@ specta = { workspace = true }
 log = { workspace = true }
 path-bool = { workspace = true }
 serde = { workspace = true }
+kurbo = { workspace = true }

node-graph/gpath-bool/src/lib.rs

@@ -1,6 +1,6 @@
-use bezier_rs::{ManipulatorGroup, Subpath};
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
+use graphene_core::subpath::{ManipulatorGroup, PathSegPoints, Subpath, pathseg_points};
 use graphene_core::table::{Table, TableRow, TableRowRef};
 use graphene_core::vector::algorithms::merge_by_distance::MergeByDistanceExt;
 use graphene_core::vector::style::Fill;
@@ -330,20 +330,29 @@ fn to_path_segments(path: &mut Vec<path_bool::PathSegment>, subpath: &Subpath<Po
 	use path_bool::PathSegment;
 	let mut global_start = None;
 	let mut global_end = DVec2::ZERO;
+
 	for bezier in subpath.iter() {
 		const EPS: f64 = 1e-8;
-		let transformed = bezier.apply_transformation(|pos| transform.transform_point2(pos).mul(EPS.recip()).round().mul(EPS));
-		let start = transformed.start;
-		let end = transformed.end;
+		let transform_point = |pos: DVec2| transform.transform_point2(pos).mul(EPS.recip()).round().mul(EPS);
+
+		let PathSegPoints { p0, p1, p2, p3 } = pathseg_points(bezier);
+
+		let p0 = transform_point(p0);
+		let p1 = p1.map(|p1| transform_point(p1));
+		let p2 = p2.map(|p2| transform_point(p2));
+		let p3 = transform_point(p3);
+
 		if global_start.is_none() {
-			global_start = Some(start);
+			global_start = Some(p0);
 		}
-		global_end = end;
-		let segment = match transformed.handles {
-			bezier_rs::BezierHandles::Linear => PathSegment::Line(start, end),
-			bezier_rs::BezierHandles::Quadratic { handle } => PathSegment::Quadratic(start, handle, end),
-			bezier_rs::BezierHandles::Cubic { handle_start, handle_end } => PathSegment::Cubic(start, handle_start, handle_end, end),
+		global_end = p3;
+
+		let segment = match (p1, p2) {
+			(None, None) => PathSegment::Line(p0, p3),
+			(None, Some(p2)) | (Some(p2), None) => PathSegment::Quadratic(p0, p2, p3),
+			(Some(p1), Some(p2)) => PathSegment::Cubic(p0, p1, p2, p3),
 		};
+
 		path.push(segment);
 	}
 	if let Some(start) = global_start {

node-graph/graph-craft/Cargo.toml

@@ -25,7 +25,6 @@ graphene-raster-nodes = { workspace = true }
 # Workspace dependencies
 log = { workspace = true }
 glam = { workspace = true }
-bezier-rs = { workspace = true }
 specta = { workspace = true }
 rustc-hash = { workspace = true }
 url = { workspace = true }
@@ -39,10 +38,7 @@ serde_json = { workspace = true, optional = true }
 
 # Workspace dependencies
 [target.'cfg(target_family = "wasm")'.dependencies]
-web-sys = { workspace = true, features = [
-	"Navigator",
-	"Gpu",
-] }
+web-sys = { workspace = true, features = ["Navigator", "Gpu"] }
 js-sys = { workspace = true }
 wasm-bindgen = { workspace = true }
 

node-graph/graster-nodes/Cargo.toml

@@ -13,13 +13,12 @@ std = [
 	"dep:dyn-any",
 	"dep:image",
 	"dep:ndarray",
-	"dep:bezier-rs",
 	"dep:rand",
 	"dep:rand_chacha",
 	"dep:fastnoise-lite",
 	"dep:serde",
 	"dep:specta",
-	"dep:glam"
+	"dep:glam",
 ]
 
 [dependencies]
@@ -40,11 +39,11 @@ glam = { workspace = true, optional = true }
 specta = { workspace = true, optional = true }
 image = { workspace = true, optional = true }
 ndarray = { workspace = true, optional = true }
-bezier-rs = { workspace = true, optional = true }
 rand = { workspace = true, optional = true }
 rand_chacha = { workspace = true, optional = true }
 fastnoise-lite = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }
+kurbo = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }

node-graph/graster-nodes/src/generate_curves.rs

@@ -1,9 +1,10 @@
 //! requires bezier-rs
 
 use crate::curve::{Curve, CurveManipulatorGroup, ValueMapperNode};
-use bezier_rs::{Bezier, TValue};
 use graphene_core::color::{Channel, Linear};
 use graphene_core::context::Ctx;
+use graphene_core::vector::algorithms::bezpath_algorithms::pathseg_find_tvalues_for_x;
+use kurbo::{CubicBez, ParamCurve, PathSeg, Point};
 
 const WINDOW_SIZE: usize = 1024;
 
@@ -18,7 +19,7 @@ fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementat
 	for sample in curve.manipulator_groups.iter().chain(std::iter::once(&end)) {
 		let [x0, y0, x1, y1, x2, y2, x3, y3] = [pos[0], pos[1], param[0], param[1], sample.handles[0][0], sample.handles[0][1], sample.anchor[0], sample.anchor[1]].map(f64::from);
 
-		let bezier = Bezier::from_cubic_coordinates(x0, y0, x1, y1, x2, y2, x3, y3);
+		let segment = PathSeg::Cubic(CubicBez::new(Point::new(x0, y0), Point::new(x1, y1), Point::new(x2, y2), Point::new(x3, y3)));
 
 		let [left, right] = [pos[0], sample.anchor[0]].map(|c| c.clamp(0., 1.));
 		let lut_index_left: usize = (left * (lut.len() - 1) as f32).floor() as _;
@@ -30,9 +31,9 @@ fn generate_curves<C: Channel + Linear>(_: impl Ctx, curve: Curve, #[implementat
 			} else if x >= x3 {
 				y3
 			} else {
-				bezier.find_tvalues_for_x(x)
+				pathseg_find_tvalues_for_x(segment, x)
 					.next()
-					.map(|t| bezier.evaluate(TValue::Parametric(t.clamp(0., 1.))).y)
+					.map(|t| segment.eval(t.clamp(0., 1.)).y)
 					// Fall back to a very bad approximation if Bezier-rs fails
 					.unwrap_or_else(|| (x - x0) / (x3 - x0) * (y3 - y0) + y0)
 			};

node-graph/gsvg-renderer/Cargo.toml

@@ -6,14 +6,10 @@ description = "graphene svg renderer"
 authors = ["Graphite Authors <contact@graphite.rs>"]
 license = "MIT OR Apache-2.0"
 
-[features]
-vello = ["dep:vello", "bezier-rs/kurbo"]
-
 [dependencies]
 # Local dependencies
 dyn-any = { workspace = true }
 graphene-core = { workspace = true }
-bezier-rs = { workspace = true }
 
 # Workspace dependencies
 glam = { workspace = true }
@@ -22,6 +18,7 @@ base64 = { workspace = true }
 log = { workspace = true }
 num-traits = { workspace = true }
 usvg = { workspace = true }
+kurbo = { workspace = true }
 
 # Optional workspace dependencies
 vello = { workspace = true, optional = true }

node-graph/gsvg-renderer/src/convert_usvg_path.rs

@@ -1,5 +1,5 @@
-use bezier_rs::{ManipulatorGroup, Subpath};
 use glam::DVec2;
+use graphene_core::subpath::{ManipulatorGroup, Subpath};
 use graphene_core::vector::PointId;
 
 pub fn convert_usvg_path(path: &usvg::Path) -> Vec<Subpath<PointId>> {

node-graph/gsvg-renderer/src/renderer.rs

@@ -1,6 +1,5 @@
 use crate::render_ext::RenderExt;
 use crate::to_peniko::BlendModeExt;
-use bezier_rs::Subpath;
 use dyn_any::DynAny;
 use glam::{DAffine2, DVec2};
 use graphene_core::blending::BlendMode;
@@ -14,6 +13,7 @@ use graphene_core::raster::BitmapMut;
 use graphene_core::raster::Image;
 use graphene_core::raster_types::{CPU, GPU, Raster};
 use graphene_core::render_complexity::RenderComplexity;
+use graphene_core::subpath::Subpath;
 use graphene_core::table::{Table, TableRow};
 use graphene_core::transform::{Footprint, Transform};
 use graphene_core::uuid::{NodeId, generate_uuid};
@@ -21,6 +21,7 @@ use graphene_core::vector::Vector;
 use graphene_core::vector::click_target::{ClickTarget, FreePoint};
 use graphene_core::vector::style::{Fill, Stroke, StrokeAlign, ViewMode};
 use graphene_core::{Artboard, Graphic};
+use kurbo::Affine;
 use num_traits::Zero;
 use std::collections::{HashMap, HashSet};
 use std::fmt::Write;
@@ -678,8 +679,10 @@ impl Render for Table<Vector> {
 			let transformed_bounds_matrix = element_transform * DAffine2::from_scale_angle_translation(transformed_bounds[1] - transformed_bounds[0], 0., transformed_bounds[0]);
 
 			let mut path = String::new();
-			for subpath in row.element.stroke_bezier_paths() {
-				let _ = subpath.subpath_to_svg(&mut path, applied_stroke_transform);
+
+			for mut bezpath in row.element.stroke_bezpath_iter() {
+				bezpath.apply_affine(Affine::new(applied_stroke_transform.to_cols_array()));
+				path.push_str(bezpath.to_svg().as_str());
 			}
 
 			let mask_type = if vector.style.stroke().map(|x| x.align) == Some(StrokeAlign::Inside) {
@@ -780,8 +783,11 @@ impl Render for Table<Vector> {
 
 			let to_point = |p: DVec2| kurbo::Point::new(p.x, p.y);
 			let mut path = kurbo::BezPath::new();
-			for subpath in row.element.stroke_bezier_paths() {
-				subpath.to_vello_path(applied_stroke_transform, &mut path);
+			for mut bezpath in row.element.stroke_bezpath_iter() {
+				bezpath.apply_affine(Affine::new(applied_stroke_transform.to_cols_array()));
+				for element in bezpath {
+					path.push(element);
+				}
 			}
 
 			// If we're using opacity or a blend mode, we need to push a layer