gh-50 Fix point-to-point touch detection and optimize fill indexing

- Use unsafe unchecked indexing in StoreFillsHandler for performance
- Add point coincidence detection for single-vertex touches between shapes
- Refactor TouchesHandler to return (boundary_contact, interior_overlap) tuple
  with early-exit on interior overlap
- Make evaluate() generic over output type to support tuple returns
- Add tests for point-to-point and segment endpoint touch scenarios

Author: bretttully

iOverlay/src/build/builder.rs

@@ -29,7 +29,9 @@ impl FillHandler for StoreFillsHandler<'_> {
 
     #[inline(always)]
     fn handle(&mut self, index: usize, fill: SegmentFill) -> ControlFlow<()> {
-        self.fills[index] = fill;
+        // fills is pre-allocated to segments.len() and index is guaranteed
+        // to be in range by the sweep algorithm
+        unsafe { *self.fills.get_unchecked_mut(index) = fill };
         ControlFlow::Continue(())
     }
 

iOverlay/src/core/predicate.rs

@@ -65,39 +65,39 @@ impl FillHandler for InteriorsIntersectHandler {
 
 /// Handler that checks if subject and clip shapes touch (boundaries intersect but interiors don't).
 ///
-/// Returns `true` if the shapes share boundary points but their interiors don't overlap.
-/// Early-exits `false` on first interior overlap.
+/// Returns `(boundary_contact, interior_overlap)`. Early-exits with `(_, true)` on first
+/// interior overlap since that definitively means the shapes don't just touch.
 pub(crate) struct TouchesHandler {
-    has_intersection: bool,
+    has_boundary_contact: bool,
 }
 
 impl TouchesHandler {
     pub(crate) fn new() -> Self {
         Self {
-            has_intersection: false,
+            has_boundary_contact: false,
         }
     }
 }
 
 impl FillHandler for TouchesHandler {
-    type Output = bool;
+    type Output = (bool, bool); // (boundary_contact, interior_overlap)
 
     #[inline(always)]
-    fn handle(&mut self, _index: usize, fill: SegmentFill) -> ControlFlow<bool> {
-        // Check interior overlap - if found, they don't just touch
+    fn handle(&mut self, _index: usize, fill: SegmentFill) -> ControlFlow<(bool, bool)> {
+        // Check interior overlap - early exit since this means they don't just touch
         if (fill & BOTH_TOP) == BOTH_TOP || (fill & BOTH_BOTTOM) == BOTH_BOTTOM {
-            return ControlFlow::Break(false);
+            return ControlFlow::Break((self.has_boundary_contact, true));
         }
-        // Check boundary contact (both shapes contribute but on opposite sides)
+        // Check boundary contact (both shapes contribute)
         if (fill & SUBJ_BOTH) != 0 && (fill & CLIP_BOTH) != 0 {
-            self.has_intersection = true;
+            self.has_boundary_contact = true;
         }
         ControlFlow::Continue(())
     }
 
     #[inline(always)]
-    fn finalize(self) -> bool {
-        self.has_intersection
+    fn finalize(self) -> (bool, bool) {
+        (self.has_boundary_contact, false)
     }
 }
 
@@ -225,15 +225,15 @@ mod tests {
         let fill = SUBJ_TOP | CLIP_BOTTOM;
         let result = handler.handle(0, fill);
         assert!(matches!(result, ControlFlow::Continue(())));
-        assert!(handler.finalize());
+        assert_eq!(handler.finalize(), (true, false)); // boundary contact, no interior overlap
     }
 
     #[test]
     fn test_touches_handler_interior_overlap() {
         let mut handler = TouchesHandler::new();
         let fill = SUBJ_TOP | CLIP_TOP;
         let result = handler.handle(0, fill);
-        assert!(matches!(result, ControlFlow::Break(false)));
+        assert!(matches!(result, ControlFlow::Break((_, true)))); // early exit on interior overlap
     }
 
     #[test]
@@ -242,7 +242,7 @@ mod tests {
         let fill = SUBJ_TOP;
         let result = handler.handle(0, fill);
         assert!(matches!(result, ControlFlow::Continue(())));
-        assert!(!handler.finalize());
+        assert_eq!(handler.finalize(), (false, false)); // no boundary contact, no interior overlap
     }
 
     #[test]

iOverlay/src/core/relate.rs

@@ -11,6 +11,45 @@ use alloc::vec::Vec;
 use i_float::int::point::IntPoint;
 use i_shape::int::shape::{IntContour, IntShape};
 
+/// Checks if any vertex from a subject segment coincides with any vertex from a clip segment.
+///
+/// Collects all endpoints, sorts by (x, y), then scans for adjacent points from different shapes.
+fn has_point_coincidence(segments: &[Segment<ShapeCountBoolean>]) -> bool {
+    // Collect all endpoints with a flag indicating if they're from subj (true) or clip (false)
+    let mut points: Vec<(i32, i32, bool, bool)> = Vec::with_capacity(segments.len() * 2);
+
+    for seg in segments {
+        let is_subj = seg.count.subj != 0;
+        let is_clip = seg.count.clip != 0;
+        points.push((seg.x_segment.a.x, seg.x_segment.a.y, is_subj, is_clip));
+        points.push((seg.x_segment.b.x, seg.x_segment.b.y, is_subj, is_clip));
+    }
+
+    // Sort by (x, y)
+    points.sort_unstable_by(|a, b| (a.0, a.1).cmp(&(b.0, b.1)));
+
+    // Scan for adjacent points at the same location from different shapes
+    let mut i = 0;
+    while i < points.len() {
+        let (x, y, _, _) = points[i];
+        let mut has_subj = false;
+        let mut has_clip = false;
+
+        // Collect all points at this location
+        while i < points.len() && points[i].0 == x && points[i].1 == y {
+            has_subj |= points[i].2;
+            has_clip |= points[i].3;
+            i += 1;
+        }
+
+        if has_subj && has_clip {
+            return true;
+        }
+    }
+
+    false
+}
+
 /// Overlay structure optimized for spatial predicate evaluation.
 ///
 /// `PredicateOverlay` provides efficient spatial relationship testing between
@@ -54,22 +93,25 @@ impl PredicateOverlay {
         }
     }
 
-    fn evaluate<H: FillHandler<Output = bool>>(&mut self, handler: H) -> bool {
+    fn evaluate<T: Default, H: FillHandler<Output = T>>(&mut self, handler: H) -> T {
         if self.segments.is_empty() {
-            return false;
+            return T::default();
         }
         self.split_solver.split_segments(&mut self.segments, &self.solver);
         if self.segments.is_empty() {
-            return false;
+            return T::default();
         }
         self.sweep_runner
             .run_with_fill_rule(self.fill_rule, &self.solver, &self.segments, handler)
     }
 
     /// Returns `true` if the subject and clip shapes intersect (share any point).
+    ///
+    /// This includes both interior overlap and boundary contact (including single-point touches).
     #[inline]
     pub fn intersects(&mut self) -> bool {
-        self.evaluate(IntersectsHandler)
+        // Check sweep first (handles most cases), then fall back to point coincidence
+        self.evaluate(IntersectsHandler) || has_point_coincidence(&self.segments)
     }
 
     /// Returns `true` if the interiors of subject and clip shapes overlap.
@@ -84,10 +126,17 @@ impl PredicateOverlay {
     /// Returns `true` if subject and clip shapes touch (boundaries intersect but interiors don't).
     ///
     /// This returns `true` when shapes share boundary points (edges or vertices)
-    /// but their interiors don't overlap.
+    /// but their interiors don't overlap. This includes single-point vertex touches.
     #[inline]
     pub fn touches(&mut self) -> bool {
-        self.evaluate(TouchesHandler::new())
+        let (boundary_contact, interior_overlap) = self.evaluate(TouchesHandler::new());
+        if interior_overlap {
+            return false;
+        }
+        if boundary_contact {
+            return true;
+        }
+        has_point_coincidence(&self.segments)
     }
 
     /// Returns `true` if subject is completely within clip.
@@ -238,4 +287,64 @@ mod tests {
         overlay.add_contour(&square(5, 5, 10), ShapeType::Clip);
         assert!(overlay.intersects());
     }
+
+    #[test]
+    fn test_point_touch_intersects() {
+        // Two squares touching at a single corner point (10, 10)
+        let mut overlay = PredicateOverlay::new(16);
+        overlay.add_contour(&square(0, 0, 10), ShapeType::Subject);
+        overlay.add_contour(&square(10, 10, 10), ShapeType::Clip);
+        assert!(overlay.intersects(), "point-to-point should intersect");
+    }
+
+    #[test]
+    fn test_point_touch_touches() {
+        // Two squares touching at a single corner point (10, 10)
+        let mut overlay = PredicateOverlay::new(16);
+        overlay.add_contour(&square(0, 0, 10), ShapeType::Subject);
+        overlay.add_contour(&square(10, 10, 10), ShapeType::Clip);
+        assert!(overlay.touches(), "point-to-point should touch");
+    }
+
+    #[test]
+    fn test_point_touch_no_interior_intersect() {
+        // Two squares touching at a single corner point (10, 10)
+        let mut overlay = PredicateOverlay::new(16);
+        overlay.add_contour(&square(0, 0, 10), ShapeType::Subject);
+        overlay.add_contour(&square(10, 10, 10), ShapeType::Clip);
+        assert!(!overlay.interiors_intersect(), "point touch has no interior intersection");
+    }
+
+    #[test]
+    fn test_segment_end_to_start_touch() {
+        // Triangle where subject's segment endpoint touches clip's segment startpoint
+        // Subject: triangle at (0,0), (10,0), (5,10)
+        // Clip: triangle at (10,0), (20,0), (15,10)
+        // They touch at exactly one point: (10,0)
+        let subj = vec![
+            IntPoint::new(0, 0),
+            IntPoint::new(10, 0),
+            IntPoint::new(5, 10),
+        ];
+        let clip = vec![
+            IntPoint::new(10, 0),
+            IntPoint::new(20, 0),
+            IntPoint::new(15, 10),
+        ];
+
+        let mut overlay = PredicateOverlay::new(16);
+        overlay.add_contour(&subj, ShapeType::Subject);
+        overlay.add_contour(&clip, ShapeType::Clip);
+        assert!(overlay.intersects(), "segment b touching segment a should intersect");
+
+        overlay.clear();
+        overlay.add_contour(&subj, ShapeType::Subject);
+        overlay.add_contour(&clip, ShapeType::Clip);
+        assert!(overlay.touches(), "segment b touching segment a should touch");
+
+        overlay.clear();
+        overlay.add_contour(&subj, ShapeType::Subject);
+        overlay.add_contour(&clip, ShapeType::Clip);
+        assert!(!overlay.interiors_intersect(), "segment b touching segment a should not have interior intersection");
+    }
 }