Replace functions in path segment with methods and add documentation

Author: TrueDoctor

libraries/path-bool/src/aabb.rs

@@ -2,21 +2,21 @@
 //
 // SPDX-License-Identifier: MIT
 
-use crate::vector::Vector;
+use glam::DVec2;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct AaBb {
+pub(crate) struct AaBb {
 	pub top: f64,
 	pub right: f64,
 	pub bottom: f64,
 	pub left: f64,
 }
 
-pub fn bounding_boxes_overlap(a: &AaBb, b: &AaBb) -> bool {
+pub(crate) fn bounding_boxes_overlap(a: &AaBb, b: &AaBb) -> bool {
 	a.left <= b.right && b.left <= a.right && a.top <= b.bottom && b.top <= a.bottom
 }
 
-pub fn merge_bounding_boxes(a: Option<AaBb>, b: &AaBb) -> AaBb {
+pub(crate) fn merge_bounding_boxes(a: Option<AaBb>, b: &AaBb) -> AaBb {
 	match a {
 		Some(a) => AaBb {
 			top: a.top.min(b.top),
@@ -28,7 +28,7 @@ pub fn merge_bounding_boxes(a: Option<AaBb>, b: &AaBb) -> AaBb {
 	}
 }
 
-pub fn extend_bounding_box(bounding_box: Option<AaBb>, point: Vector) -> AaBb {
+pub(crate) fn extend_bounding_box(bounding_box: Option<AaBb>, point: DVec2) -> AaBb {
 	match bounding_box {
 		Some(bb) => AaBb {
 			top: bb.top.min(point.y),
@@ -45,12 +45,11 @@ pub fn extend_bounding_box(bounding_box: Option<AaBb>, point: Vector) -> AaBb {
 	}
 }
 
-#[inline(never)]
-pub fn bounding_box_max_extent(bounding_box: &AaBb) -> f64 {
+pub(crate) fn bounding_box_max_extent(bounding_box: &AaBb) -> f64 {
 	(bounding_box.right - bounding_box.left).max(bounding_box.bottom - bounding_box.top)
 }
 
-pub fn bounding_box_around_point(point: Vector, padding: f64) -> AaBb {
+pub(crate) fn bounding_box_around_point(point: DVec2, padding: f64) -> AaBb {
 	AaBb {
 		top: point.y - padding,
 		right: point.x + padding,
@@ -59,7 +58,7 @@ pub fn bounding_box_around_point(point: Vector, padding: f64) -> AaBb {
 	}
 }
 
-pub fn expand_bounding_box(bounding_box: &AaBb, padding: f64) -> AaBb {
+pub(crate) fn expand_bounding_box(bounding_box: &AaBb, padding: f64) -> AaBb {
 	AaBb {
 		top: bounding_box.top - padding,
 		right: bounding_box.right + padding,

libraries/path-bool/src/intersection_path_segment.rs

@@ -2,13 +2,14 @@
 //
 // SPDX-License-Identifier: MIT
 
+use glam::DVec2;
+
 use crate::aabb::{bounding_box_max_extent, bounding_boxes_overlap, AaBb};
 use crate::epsilons::Epsilons;
 use crate::line_segment::{line_segment_intersection, line_segments_intersect};
 use crate::line_segment_aabb::line_segment_aabb_intersect;
 use crate::math::lerp;
-use crate::path_segment::{get_end_point, get_start_point, path_segment_bounding_box, sample_path_segment_at, split_segment_at, PathSegment};
-use crate::vector::{vectors_equal, Vector};
+use crate::path_segment::PathSegment;
 
 #[derive(Clone)]
 struct IntersectionSegment {
@@ -20,26 +21,26 @@ struct IntersectionSegment {
 
 #[inline(never)]
 fn subdivide_intersection_segment(int_seg: &IntersectionSegment) -> [IntersectionSegment; 2] {
-	let (seg0, seg1) = split_segment_at(&int_seg.seg, 0.5);
+	let (seg0, seg1) = int_seg.seg.split_at(0.5);
 	let mid_param = (int_seg.start_param + int_seg.end_param) / 2.0;
 	[
 		IntersectionSegment {
 			seg: seg0,
 			start_param: int_seg.start_param,
 			end_param: mid_param,
-			bounding_box: path_segment_bounding_box(&seg0),
+			bounding_box: seg0.bounding_box(),
 		},
 		IntersectionSegment {
 			seg: seg1,
 			start_param: mid_param,
 			end_param: int_seg.end_param,
-			bounding_box: path_segment_bounding_box(&seg1),
+			bounding_box: seg1.bounding_box(),
 		},
 	]
 }
 
 #[inline(never)]
-fn path_segment_to_line_segment(seg: &PathSegment) -> [Vector; 2] {
+fn path_segment_to_line_segment(seg: &PathSegment) -> [DVec2; 2] {
 	match seg {
 		PathSegment::Line(start, end) => [*start, *end],
 		PathSegment::Cubic(start, _, _, end) => [*start, *end],
@@ -63,13 +64,13 @@ fn intersection_segments_overlap(seg0: &IntersectionSegment, seg1: &Intersection
 #[inline(never)]
 pub fn segments_equal(seg0: &PathSegment, seg1: &PathSegment, point_epsilon: f64) -> bool {
 	match (*seg0, *seg1) {
-		(PathSegment::Line(start0, end0), PathSegment::Line(start1, end1)) => vectors_equal(start0, start1, point_epsilon) && vectors_equal(end0, end1, point_epsilon),
+		(PathSegment::Line(start0, end0), PathSegment::Line(start1, end1)) => start0.abs_diff_eq(start1, point_epsilon) && end0.abs_diff_eq(end1, point_epsilon),
 		(PathSegment::Cubic(p00, p01, p02, p03), PathSegment::Cubic(p10, p11, p12, p13)) => {
-			let start_and_end_equal = vectors_equal(p00, p10, point_epsilon) && vectors_equal(p03, p13, point_epsilon);
+			let start_and_end_equal = p00.abs_diff_eq(p10, point_epsilon) && p03.abs_diff_eq(p13, point_epsilon);
 
-			let parameter_equal = vectors_equal(p01, p11, point_epsilon) && vectors_equal(p02, p12, point_epsilon);
-			let direction1 = sample_path_segment_at(seg0, 0.1);
-			let direction2 = sample_path_segment_at(seg1, 0.1);
+			let parameter_equal = p01.abs_diff_eq(p11, point_epsilon) && p02.abs_diff_eq(p12, point_epsilon);
+			let direction1 = seg0.sample_at(0.1);
+			let direction2 = seg1.sample_at(0.1);
 			let angles_equal = (direction1 - p00).angle_to(direction2 - p00).abs() < point_epsilon * 4.;
 			if angles_equal {
 				// eprintln!("deduplicating {:?} {:?} because the angles are equal", seg0, seg1);
@@ -78,16 +79,16 @@ pub fn segments_equal(seg0: &PathSegment, seg1: &PathSegment, point_epsilon: f64
 			start_and_end_equal && (parameter_equal || angles_equal)
 		}
 		(PathSegment::Quadratic(p00, p01, p02), PathSegment::Quadratic(p10, p11, p12)) => {
-			vectors_equal(p00, p10, point_epsilon) && vectors_equal(p01, p11, point_epsilon) && vectors_equal(p02, p12, point_epsilon)
+			p00.abs_diff_eq(p10, point_epsilon) && p01.abs_diff_eq(p11, point_epsilon) && p02.abs_diff_eq(p12, point_epsilon)
 		}
 		(PathSegment::Arc(p00, rx0, ry0, angle0, large_arc0, sweep0, p01), PathSegment::Arc(p10, rx1, ry1, angle1, large_arc1, sweep1, p11)) => {
-			vectors_equal(p00, p10, point_epsilon) &&
+			p00.abs_diff_eq(p10, point_epsilon) &&
             (rx0 - rx1).abs() < point_epsilon &&
             (ry0 - ry1).abs() < point_epsilon &&
             (angle0 - angle1).abs() < point_epsilon && // TODO: Phi can be anything if rx = ry. Also, handle rotations by Pi/2.
             large_arc0 == large_arc1 &&
             sweep0 == sweep1 &&
-            vectors_equal(p01, p11, point_epsilon)
+            p01.abs_diff_eq(p11, point_epsilon)
 		}
 		_ => false,
 	}
@@ -111,13 +112,13 @@ pub fn path_segment_intersection(seg0: &PathSegment, seg1: &PathSegment, endpoin
 			seg: *seg0,
 			start_param: 0.0,
 			end_param: 1.0,
-			bounding_box: path_segment_bounding_box(seg0),
+			bounding_box: seg0.bounding_box(),
 		},
 		IntersectionSegment {
 			seg: *seg1,
 			start_param: 0.0,
 			end_param: 1.0,
-			bounding_box: path_segment_bounding_box(seg1),
+			bounding_box: seg1.bounding_box(),
 		},
 	)];
 	let mut next_pairs = Vec::new();
@@ -188,10 +189,10 @@ pub fn path_segment_intersection(seg0: &PathSegment, seg1: &PathSegment, endpoin
 }
 
 fn calculate_overlap_intersections(seg0: &PathSegment, seg1: &PathSegment, eps: &Epsilons) -> Vec<[f64; 2]> {
-	let start0 = get_start_point(seg0);
-	let end0 = get_end_point(seg0);
-	let start1 = get_start_point(seg1);
-	let end1 = get_end_point(seg1);
+	let start0 = seg0.start();
+	let end0 = seg0.end();
+	let start1 = seg1.start();
+	let end1 = seg1.end();
 
 	let mut intersections = Vec::new();
 
@@ -217,12 +218,12 @@ fn calculate_overlap_intersections(seg0: &PathSegment, seg1: &PathSegment, eps:
 
 	// Remove duplicates and sort intersections
 	intersections.sort_unstable_by(|a, b| a[0].partial_cmp(&b[0]).unwrap());
-	intersections.dedup_by(|a, b| vectors_equal(Vector::new(a[0], a[1]), Vector::new(b[0], b[1]), eps.param));
+	intersections.dedup_by(|a, b| DVec2::from(*a).abs_diff_eq(DVec2::from(*b), eps.param));
 
 	// Handle special cases
 	if intersections.is_empty() {
 		// Check if segments are identical
-		if vectors_equal(start0, start1, eps.point) && vectors_equal(end0, end1, eps.point) {
+		if (start0.abs_diff_eq(start1, eps.point)) && end0.abs_diff_eq(end1, eps.point) {
 			return vec![[0.0, 0.0], [1.0, 1.0]];
 		}
 	} else if intersections.len() > 2 {
@@ -233,21 +234,21 @@ fn calculate_overlap_intersections(seg0: &PathSegment, seg1: &PathSegment, eps:
 	intersections
 }
 
-fn find_point_on_segment(seg: &PathSegment, point: Vector, eps: &Epsilons) -> Option<f64> {
+fn find_point_on_segment(seg: &PathSegment, point: DVec2, eps: &Epsilons) -> Option<f64> {
 	let start = 0.0;
 	let end = 1.0;
 	let mut t = 0.5;
 
 	for _ in 0..32 {
 		// Limit iterations to prevent infinite loops
-		let current_point = sample_path_segment_at(seg, t);
+		let current_point = seg.sample_at(t);
 
-		if vectors_equal(current_point, point, eps.point) {
+		if current_point.abs_diff_eq(point, eps.point) {
 			return Some(t);
 		}
 
-		let start_point = sample_path_segment_at(seg, start);
-		let end_point = sample_path_segment_at(seg, end);
+		let start_point = seg.sample_at(start);
+		let end_point = seg.sample_at(end);
 
 		let dist_start = (point - start_point).length_squared();
 		let dist_end = (point - end_point).length_squared();

libraries/path-bool/src/lib.rs

@@ -6,17 +6,19 @@ mod line_segment_aabb;
 mod math;
 mod path;
 mod path_boolean;
+#[cfg(feature = "parsing")]
 mod path_command;
 mod path_cubic_segment_self_intersection;
+#[cfg(feature = "parsing")]
 mod path_data;
 mod path_segment;
 mod quad_tree;
-mod vector;
 #[cfg(test)]
 mod visual_tests;
 
 pub use intersection_path_segment::path_segment_intersection;
-pub use path_boolean::{path_boolean, FillRule, PathBooleanOperation, EPS};
+pub use path_boolean::{path_boolean, BooleanError, FillRule, PathBooleanOperation, EPS};
+#[cfg(feature = "parsing")]
 pub use path_data::{path_from_path_data, path_to_path_data};
 pub use path_segment::PathSegment;
 
@@ -30,16 +32,8 @@ mod test {
 
 	#[test]
 	fn square() {
-		// let a = path_from_path_data(
-		//     "M 39,20 A 19,19 0 0 1 20,39 19,19 0 0 1 1,20 19,19 0 0 1 20,1 19,19 0 0 1 39,20 Z",
-		// );
-		// let b = path_from_path_data(
-		//     "M 47,28 A 19,19 0 0 1 28,47 19,19 0 0 1 9,28 19,19 0 0 1 28,9 19,19 0 0 1 47,28 Z",
-		// );
 		let a = path_from_path_data("M 10 10 L 50 10 L 30 40 Z");
 		let b = path_from_path_data("M 20 30 L 60 30 L 60 50 L 20 50 Z");
-		// let a = path_from_path_data("M 0 0 L 10 0 L 5 10 Z");
-		// let b = path_from_path_data("M 0 5 L 10  5 L 5 15  Z");
 		let union = path_boolean(
 			&a,
 			path_boolean::FillRule::NonZero,

libraries/path-bool/src/line_segment.rs

@@ -2,9 +2,9 @@
 //
 // SPDX-License-Identifier: MIT
 
-use crate::vector::Vector;
+use glam::DVec2;
 
-pub type LineSegment = [Vector; 2];
+pub type LineSegment = [DVec2; 2];
 
 const COLLINEAR_EPS: f64 = f64::EPSILON * 64.0;
 

libraries/path-bool/src/line_segment_aabb.rs

@@ -29,7 +29,7 @@ fn out_code(x: f64, y: f64, bounding_box: &AaBb) -> u8 {
 	code
 }
 
-pub fn line_segment_aabb_intersect(seg: LineSegment, bounding_box: &AaBb) -> bool {
+pub(crate) fn line_segment_aabb_intersect(seg: LineSegment, bounding_box: &AaBb) -> bool {
 	let [mut p0, mut p1] = seg;
 
 	let mut outcode0 = out_code(p0.x, p0.y, bounding_box);

libraries/path-bool/src/math.rs

@@ -4,7 +4,7 @@
 
 // TODO(@TrueDoctor) check math
 
-use crate::vector::Vector;
+use glam::DVec2;
 pub use std::f64::consts::PI;
 
 pub fn lin_map(value: f64, in_min: f64, in_max: f64, out_min: f64, out_max: f64) -> f64 {
@@ -15,11 +15,7 @@ pub fn lerp(a: f64, b: f64, t: f64) -> f64 {
 	a + (b - a) * t
 }
 
-pub fn deg2rad(deg: f64) -> f64 {
-	(deg / 180.0) * PI
-}
-
-pub fn vector_angle(u: Vector, v: Vector) -> f64 {
+pub fn vector_angle(u: DVec2, v: DVec2) -> f64 {
 	const EPS: f64 = 1e-12;
 
 	let sign = u.x * v.y - u.y * v.x;

libraries/path-bool/src/path.rs

@@ -6,21 +6,20 @@ use glam::DVec2;
 
 use crate::path_command::{to_absolute_commands, AbsolutePathCommand, PathCommand};
 use crate::path_segment::PathSegment;
-use crate::vector::{vectors_equal, Vector};
 
 pub type Path = Vec<PathSegment>;
 
-fn reflect_control_point(point: Vector, control_point: Vector) -> Vector {
+fn reflect_control_point(point: DVec2, control_point: DVec2) -> DVec2 {
 	point * 2.0 - control_point
 }
 
 pub fn path_from_commands<I>(commands: I) -> impl Iterator<Item = PathSegment>
 where
 	I: IntoIterator<Item = PathCommand>,
 {
-	let mut first_point: Option<Vector> = None;
-	let mut last_point: Option<Vector> = None;
-	let mut last_control_point: Option<Vector> = None;
+	let mut first_point: Option<DVec2> = None;
+	let mut last_point: Option<DVec2> = None;
+	let mut last_control_point: Option<DVec2> = None;
 
 	to_absolute_commands(commands).filter_map(move |cmd| match cmd {
 		AbsolutePathCommand::M(point) => {
@@ -95,13 +94,13 @@ pub fn path_to_commands<'a, I>(segments: I, eps: f64) -> impl Iterator<Item = Pa
 where
 	I: IntoIterator<Item = &'a PathSegment> + 'a,
 {
-	let mut last_point: Option<Vector> = None;
+	let mut last_point: Option<DVec2> = None;
 
 	segments.into_iter().flat_map(move |seg| {
-		let start = crate::path_segment::get_start_point(seg);
+		let start = seg.start();
 		let mut commands = Vec::new();
 
-		if last_point.map_or(true, |lp| !vectors_equal(start, lp, eps)) {
+		if last_point.map_or(true, |lp| !start.abs_diff_eq(lp, eps)) {
 			commands.push(PathCommand::Absolute(AbsolutePathCommand::M(start)));
 		}