Implement support for overlapping path segments

Author: TrueDoctor

libraries/path-bool/src/intersection_path_segment.rs

@@ -7,7 +7,7 @@ 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::{path_segment_bounding_box, sample_path_segment_at, split_segment_at, PathSegment};
+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};
 
 #[derive(Clone)]
@@ -65,7 +65,17 @@ pub fn segments_equal(seg0: &PathSegment, seg1: &PathSegment, point_epsilon: f64
 	match (*seg0, *seg1) {
 		(PathSegment::Line(start0, end0), PathSegment::Line(start1, end1)) => vectors_equal(start0, start1, point_epsilon) && vectors_equal(end0, end1, point_epsilon),
 		(PathSegment::Cubic(p00, p01, p02, p03), PathSegment::Cubic(p10, p11, p12, p13)) => {
-			vectors_equal(p00, p10, point_epsilon) && vectors_equal(p01, p11, point_epsilon) && vectors_equal(p02, p12, point_epsilon) && vectors_equal(p03, p13, point_epsilon)
+			let start_and_end_equal = vectors_equal(p00, p10, point_epsilon) && vectors_equal(p03, 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 angles_equal = (direction1 - p00).angle_to(direction2 - p00).abs() < point_epsilon * 4.;
+			if angles_equal {
+				eprintln!("deduplicating {:?} {:?} because the angles are equal", seg0, seg1);
+			}
+
+			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)
@@ -123,6 +133,8 @@ pub fn path_segment_intersection(seg0: &PathSegment, seg1: &PathSegment, endpoin
 		// dbg!("checking pairs");
 
 		if pairs.len() > 1000 {
+			// TODO: check for intersections of the start/end points. If the two lines overlap, return split points for the start/end points. Use a binary search  to check where the points are on the line.
+			return dbg!(calculate_overlap_intersections(seg0, seg1, eps));
 			return vec![];
 		}
 
@@ -179,6 +191,90 @@ pub fn path_segment_intersection(seg0: &PathSegment, seg1: &PathSegment, endpoin
 	params
 }
 
+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 mut intersections = Vec::new();
+
+	// Check start0 against seg1
+	if let Some(t1) = find_point_on_segment(seg1, start0, eps) {
+		intersections.push([0.0, t1]);
+	}
+
+	// Check end0 against seg1
+	if let Some(t1) = find_point_on_segment(seg1, end0, eps) {
+		intersections.push([1.0, t1]);
+	}
+
+	// Check start1 against seg0
+	if let Some(t0) = find_point_on_segment(seg0, start1, eps) {
+		intersections.push([t0, 0.0]);
+	}
+
+	// Check end1 against seg0
+	if let Some(t0) = find_point_on_segment(seg0, end1, eps) {
+		intersections.push([t0, 1.0]);
+	}
+
+	// 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));
+
+	// 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) {
+			return vec![[0.0, 0.0], [1.0, 1.0]];
+		}
+	} else if intersections.len() > 2 {
+		// Keep only the first and last intersection points
+		intersections = vec![intersections[0], intersections[intersections.len() - 1]];
+	}
+
+	intersections
+}
+
+fn find_point_on_segment(seg: &PathSegment, point: Vector, 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);
+
+		if vectors_equal(current_point, 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 dist_start = (point - start_point).length_squared();
+		let dist_end = (point - end_point).length_squared();
+		let dist_current = (point - current_point).length_squared();
+
+		if dist_current < dist_start && dist_current < dist_end {
+			return Some(t);
+		}
+
+		if dist_start < dist_end {
+			t = (start + t) / 2.0;
+		} else {
+			t = (t + end) / 2.0;
+		}
+
+		if (end - start) < eps.param {
+			break;
+		}
+	}
+
+	None
+}
+
 #[cfg(test)]
 mod test {
 	use super::*;

libraries/path-bool/src/lib.rs

@@ -153,7 +153,7 @@ mod test {
 			"M458.370270,572.165771C428.525848,486.720093 368.618805,467.485992 273,476 C107.564178,490.730591 161.737915,383.575775 0,340 C0,340 0,689 0,689 C56,700 106.513901,779.342590 188,694.666687 C306.607422,571.416260 372.033966,552.205139 458.370270,572.165771 Z",
 		);
 
-		let result = path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, PathBooleanOperation::Difference).unwrap();
+		let result = path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, PathBooleanOperation::Union).unwrap();
 
 		// Add assertions here based on expected results
 		assert_eq!(result.len(), 1, "Expected 1 resulting path for Union operation");
@@ -170,6 +170,36 @@ mod test {
 
 		let result = path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, PathBooleanOperation::Difference).unwrap();
 
+		// Add assertions here based on expected results
+		assert_eq!(result.len(), 1, "Expected 1 resulting path for Union operation");
+		dbg!(path_to_path_data(&result[0], 0.001));
+		// Add more specific assertions about the resulting path if needed
+		assert!(!result[0].is_empty());
+	}
+	#[test]
+	fn painted_dreams_4() {
+		let a = path_from_path_data("M458.370270,572.165771C372.033966,552.205139 306.607422,571.416260 188.000000,694.666687 C106.513901,779.342590 56.000000,700.000000 0.000000,689.000000 C0.000000,689.000000 0.000000,768.000000 0.000000,768.000000 C0.000000,768.000000 481.333344,768.000000 481.333344,768.000000 C481.474091,680.589417 474.095154,617.186768 458.370270,572.165771 Z ");
+		let b = path_from_path_data(
+			"M364.000000,768.000000C272.000000,686.000000 294.333333,468.666667 173.333333,506.666667 C110.156241,526.507407 0.000000,608.000000 0.000000,608.000000 L -0.000000,768.000000 L 364.000000,768.000000 Z",
+		);
+
+		let result = path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, PathBooleanOperation::Difference).unwrap();
+
+		// Add assertions here based on expected results
+		assert_eq!(result.len(), 1, "Expected 1 resulting path for Union operation");
+		dbg!(path_to_path_data(&result[0], 0.001));
+		// Add more specific assertions about the resulting path if needed
+		assert!(!result[0].is_empty());
+	}
+	#[test]
+	fn painted_dreams_5() {
+		let a = path_from_path_data("M889.000000,0.000000C889.000000,0.000000 889.000000,21.000000 898.000000,46.000000 C909.595887,78.210796 872.365858,104.085306 869.000000,147.000000 C865.000000,198.000000 915.000000,237.000000 933.000000,273.000000 C951.000000,309.000000 951.703704,335.407407 923.000000,349.000000 C898.996281,360.366922 881.000000,367.000000 902.000000,394.000000 C923.000000,421.000000 928.592593,431.407407 898.000000,468.000000 C912.888889,472.888889 929.333333,513.333333 896.000000,523.000000 C896.000000,523.000000 876.000000,533.333333 886.000000,572.000000 C896.458810,612.440732 873.333333,657.777778 802.666667,656.444444 C738.670245,655.236965 689.000000,643.000000 655.000000,636.000000 C621.000000,629.000000 604.000000,623.000000 585.000000,666.000000 C566.000000,709.000000 564.000000,768.000000 564.000000,768.000000 C564.000000,768.000000 0.000000,768.000000 0.000000,768.000000 C0.000000,768.000000 0.000000,0.000000 0.000000,0.000000 C0.000000,0.000000 889.000000,0.000000 889.000000,0.000000 Z");
+		let b = path_from_path_data(
+			"M891.555556,569.382716C891.555556,569.382716 883.555556,577.777778 879.111111,595.851852 C874.666667,613.925926 857.185185,631.407407 830.814815,633.777778 C804.444444,636.148148 765.629630,637.925926 708.148148,616.296296 C650.666667,594.666667 560.666667,568.000000 468.000000,487.333333 C375.333333,406.666667 283.333333,354.666667 283.333333,354.666667 C332.000000,330.666667 373.407788,298.323579 468.479950,219.785706 C495.739209,197.267187 505.084065,165.580817 514.452332,146.721008 C525.711584,124.054345 577.519713,94.951389 589.958848,64.658436 C601.152263,37.399177 601.175694,0.000010 601.175694,0.000000 C601.175694,0.000000 0.000000,0.000000 0.000000,0.000000 C0.000000,0.000000 0.000000,768.000000 0.000000,768.000000 C0.000000,768.000000 891.555556,768.000000 891.555556,768.000000 C891.555556,768.000000 891.555556,569.382716 891.555556,569.382716 Z",
+		);
+
+		let result = path_boolean(&a, FillRule::NonZero, &b, FillRule::NonZero, PathBooleanOperation::Intersection).unwrap();
+
 		// Add assertions here based on expected results
 		assert_eq!(result.len(), 1, "Expected 1 resulting path for Union operation");
 		dbg!(path_to_path_data(&result[0], 0.001));

libraries/path-bool/src/line_segment.rs

@@ -12,21 +12,18 @@ const COLLINEAR_EPS: f64 = f64::EPSILON * 64.0;
 pub fn line_segment_intersection([p1, p2]: LineSegment, [p3, p4]: LineSegment, eps: f64) -> Option<(f64, f64)> {
 	// https://en.wikipedia.org/wiki/Intersection_(geometry)#Two_line_segments
 
-	let a1 = p2.x - p1.x;
-	let b1 = p3.x - p4.x;
-	let c1 = p3.x - p1.x;
-	let a2 = p2.y - p1.y;
-	let b2 = p3.y - p4.y;
-	let c2 = p3.y - p1.y;
+	let a = p2 - p1;
+	let b = p3 - p4;
+	let c = p3 - p1;
 
-	let denom = a1 * b2 - a2 * b1;
+	let denom = a.x * b.y - a.y * b.x;
 
 	if denom.abs() < COLLINEAR_EPS {
 		return None;
 	}
 
-	let s = (c1 * b2 - c2 * b1) / denom;
-	let t = (a1 * c2 - a2 * c1) / denom;
+	let s = (c.x * b.y - c.y * b.x) / denom;
+	let t = (a.x * c.y - a.y * c.x) / denom;
 
 	if (-eps..=1.0 + eps).contains(&s) && (-eps..=1.0 + eps).contains(&t) {
 		Some((s, t))

libraries/path-bool/src/path_boolean.rs

@@ -247,15 +247,15 @@ fn dual_graph_to_dot(components: &[DualGraphComponent], edges: &SlotMap<DualEdge
 
 fn segment_to_edge(parent: u8) -> impl Fn(&PathSegment) -> Option<MajorGraphEdgeStage1> {
 	move |seg| {
-		if bounding_box_max_extent(&path_segment_bounding_box(seg)) < f64::EPSILON {
+		if bounding_box_max_extent(&path_segment_bounding_box(seg)) < EPS.point {
 			return None;
 		}
 
 		match seg {
 			// Convert Line Segments expressed as cubic beziers to proper line segments
 			PathSegment::Cubic(start, _, _, end) => {
 				let direction = sample_path_segment_at(seg, 0.1);
-				if (end - start).angle_to(direction - start).abs() < EPS.param {
+				if (end - start).angle_to(direction - start).abs() < EPS.point * 4. {
 					Some((PathSegment::Line(*start, *end), parent))
 				} else {
 					Some((*seg, parent))
@@ -752,10 +752,6 @@ fn compute_point_winding(polygon: &[Vector], tested_point: Vector) -> i32 {
 
 fn compute_winding(face: &DualGraphVertex, edges: &SlotMap<DualEdgeKey, DualGraphHalfEdge>) -> Option<i32> {
 	let polygon = face_to_polygon(face, edges);
-	#[cfg(feature = "logging")]
-	for point in &polygon {
-		eprintln!("[{}, {}]", point.x, point.y);
-	}
 
 	for i in 0..polygon.len() {
 		let a = polygon[i];
@@ -824,7 +820,7 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 
 		loop {
 			#[cfg(feature = "logging")]
-			eprintln!("Processing edge: {}", (start_edge_key.0.as_ffi() & 0xFF) - 1);
+			eprintln!("Processing edge: {}", (edge_key.0.as_ffi() & 0xFF));
 			let twin = edge.twin.expect("Edge doesn't have a twin");
 			let twin_dual_key = minor_to_dual_edge.get(&twin).copied();
 
@@ -846,7 +842,7 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 
 			edge_key = get_next_edge(edge_key, minor_graph);
 			#[cfg(feature = "logging")]
-			eprintln!("Next edge: {}", (start_edge_key.0.as_ffi() & 0xFF) - 1);
+			eprintln!("Next edge: {}", (edge_key.0.as_ffi() & 0xFF));
 			edge = &minor_graph.edges[edge_key];
 
 			if edge.incident_vertices[0] == start_edge.incident_vertices[0] {
@@ -940,10 +936,16 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 			.iter()
 			.map(|face_key| compute_winding(&dual_vertices[*face_key], &dual_edges).map(|w| (face_key, w)))
 			.collect();
-		let Some(mut windings) = windings else {
+		let Some(windings) = windings else {
 			return Err(BooleanError::NoEarInPolygon);
 		};
 
+		let areas: Vec<_> = component_vertices
+			.iter()
+			.map(|face_key| (face_key, compute_signed_area(&dual_vertices[*face_key], &dual_edges)))
+			.collect();
+		dbg!(&areas);
+
 		#[cfg(feature = "logging")]
 		if cfg!(feature = "logging") {
 			eprintln!(
@@ -966,11 +968,13 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 			count = 1;
 			reverse_winding = true;
 		}
-		if count != 1 {
-			return Err(BooleanError::MultipleOuterFaces);
-		}
-		let outer_face_key = *windings.iter().find(|(&_, winding)| (winding < &0) ^ reverse_winding).expect("No outer face of a component found.").0;
-		// TODO: merge with previous iter
+		let outer_face_key = if count != 1 {
+			// return Err(BooleanError::MultipleOuterFaces);
+			*areas.iter().max_by_key(|(_, area)| ((area.abs() * 1000.) as u64)).unwrap().0
+		} else {
+			*windings.iter().find(|(&_, winding)| (winding < &0) ^ reverse_winding).expect("No outer face of a component found.").0
+		};
+		dbg!(outer_face_key);
 
 		components.push(DualGraphComponent {
 			vertices: component_vertices,
@@ -989,6 +993,8 @@ fn compute_dual(minor_graph: &MinorGraph) -> Result<DualGraph, BooleanError> {
 fn get_next_edge(edge_key: MinorEdgeKey, graph: &MinorGraph) -> MinorEdgeKey {
 	let edge = &graph.edges[edge_key];
 	let vertex = &graph.vertices[edge.incident_vertices[1]];
+	#[cfg(feature = "logging")]
+	eprintln!("{edge_key:?}, twin: {:?}, {:?}", edge.twin, vertex.outgoing_edges);
 	let index = vertex.outgoing_edges.iter().position(|&e| Some(edge_key) == graph.edges[e].twin).unwrap();
 	vertex.outgoing_edges[(index + 1) % vertex.outgoing_edges.len()]
 }
@@ -1319,6 +1325,12 @@ pub fn path_boolean(a: &Path, a_fill_rule: FillRule, b: &Path, b_fill_rule: Fill
 
 	let (split_edges, total_bounding_box) = split_at_intersections(&unsplit_edges);
 
+	#[cfg(feature = "logging")]
+	for (edge, _, _) in split_edges.iter() {
+		// eprintln!("{}", edge.format_path());
+		eprintln!("{}", path_to_path_data(&vec![*edge], 0.001));
+	}
+
 	let total_bounding_box = match total_bounding_box {
 		Some(bb) => bb,
 		None => return Ok(Vec::new()), // input geometry is empty