Use OGC options and verify input winding order in shared point test

- Switch to Overlay::with_contours_custom with IntOverlayOptions::ogc()
- Add test_input_winding_order asserting all rectangles are CCW
  (negative area_two)
- Simplify overlay helper to accept fill_rule and return results directly

https://claude.ai/code/session_01UWsUQwhyBYT5ABqevBFmkR

Author: claude

iOverlay/tests/shared_point_tests.rs

@@ -2,8 +2,9 @@
 mod tests {
     use i_float::int::point::IntPoint;
     use i_overlay::core::fill_rule::FillRule;
-    use i_overlay::core::overlay::{Overlay, ShapeType};
+    use i_overlay::core::overlay::{IntOverlayOptions, Overlay};
     use i_overlay::core::overlay_rule::OverlayRule;
+    use i_shape::int::area::Area;
 
     // Four boxes that form a shape with a hole, where the exterior
     // contour and hole contour should share a point at (2,2):
@@ -25,16 +26,17 @@ mod tests {
     // The hole is at (1,1)-(2,2). The point (2,2) lies on both the
     // exterior contour and the hole contour.
     //
-    // Expected exterior contour (6 points):
+    // Expected exterior contour (6 points, CCW):
     //   (0,0) → (3,0) → (3,2) → (2,2) → (2,3) → (0,3)
     //
-    // Expected hole contour (4 points):
+    // Expected hole contour (4 points, CW):
     //   (1,1) → (2,1) → (2,2) → (1,2)
     //
     // BUG: The library currently produces a single merged contour that
     // visits (2,2) twice in a figure-8 instead of two separate contours:
     //   (0,0)→(3,0)→(3,2)→(2,2)→(2,1)→(1,1)→(1,2)→(2,2)→(2,3)→(0,3)
 
+    /// Create a CCW rectangle contour from (x1,y1) to (x2,y2).
     fn rect(x1: i32, y1: i32, x2: i32, y2: i32) -> Vec<IntPoint> {
         vec![
             IntPoint::new(x1, y1),
@@ -44,29 +46,44 @@ mod tests {
         ]
     }
 
-    fn overlay() -> Overlay {
-        let mut overlay = Overlay::new(16);
-
-        overlay.add_contour(&rect(0, 0, 3, 1), ShapeType::Subject);
-        overlay.add_contour(&rect(0, 1, 1, 2), ShapeType::Subject);
-        overlay.add_contour(&rect(2, 1, 3, 2), ShapeType::Subject);
-        overlay.add_contour(&rect(0, 2, 2, 3), ShapeType::Subject);
+    fn subject_contours() -> Vec<Vec<IntPoint>> {
+        vec![
+            rect(0, 0, 3, 1),
+            rect(0, 1, 1, 2),
+            rect(2, 1, 3, 2),
+            rect(0, 2, 2, 3),
+        ]
+    }
 
-        overlay
+    fn overlay(fill_rule: FillRule) -> Vec<Vec<Vec<IntPoint>>> {
+        let contours = subject_contours();
+        let mut overlay = Overlay::with_contours_custom(
+            &contours,
+            &[],
+            IntOverlayOptions::ogc(),
+            Default::default(),
+        );
+        overlay.overlay(OverlayRule::Subject, fill_rule)
     }
 
     fn contour_contains(contour: &[IntPoint], point: IntPoint) -> bool {
         contour.iter().any(|p| *p == point)
     }
 
     #[test]
-    fn test_shared_point_even_odd() {
-        let mut buffer = Default::default();
+    fn test_input_winding_order() {
+        // All input rectangles must be CCW (negative area_two).
+        for contour in &subject_contours() {
+            assert!(
+                contour.area_two() < 0,
+                "input contour must be counter-clockwise, got area_two={}", contour.area_two()
+            );
+        }
+    }
 
-        let result = overlay()
-            .build_graph_view(FillRule::EvenOdd)
-            .unwrap()
-            .extract_shapes(OverlayRule::Subject, &mut buffer);
+    #[test]
+    fn test_shared_point_even_odd() {
+        let result = overlay(FillRule::EvenOdd);
 
         assert_eq!(result.len(), 1, "expected 1 shape");
         assert_eq!(result[0].len(), 2, "expected 2 contours (exterior + hole)");
@@ -84,12 +101,7 @@ mod tests {
 
     #[test]
     fn test_shared_point_non_zero() {
-        let mut buffer = Default::default();
-
-        let result = overlay()
-            .build_graph_view(FillRule::NonZero)
-            .unwrap()
-            .extract_shapes(OverlayRule::Subject, &mut buffer);
+        let result = overlay(FillRule::NonZero);
 
         assert_eq!(result.len(), 1, "expected 1 shape");
         assert_eq!(result[0].len(), 2, "expected 2 contours (exterior + hole)");
@@ -107,12 +119,7 @@ mod tests {
 
     #[test]
     fn test_shared_point_positive() {
-        let mut buffer = Default::default();
-
-        let result = overlay()
-            .build_graph_view(FillRule::Positive)
-            .unwrap()
-            .extract_shapes(OverlayRule::Subject, &mut buffer);
+        let result = overlay(FillRule::Positive);
 
         assert_eq!(result.len(), 1, "expected 1 shape");
         assert_eq!(result[0].len(), 2, "expected 2 contours (exterior + hole)");
@@ -130,15 +137,10 @@ mod tests {
 
     #[test]
     fn test_shared_point_negative() {
-        let mut buffer = Default::default();
-
-        let result = overlay()
-            .build_graph_view(FillRule::Negative)
-            .unwrap()
-            .extract_shapes(OverlayRule::Subject, &mut buffer);
+        let result = overlay(FillRule::Negative);
 
-        // All contours are CCW (positive winding), so Negative fill rule
-        // produces no filled regions.
+        // All input contours are CCW (positive winding), so Negative
+        // fill rule produces no filled regions.
         assert_eq!(result.len(), 0, "expected 0 shapes for Negative fill rule");
     }
 }