feat(curve): M.5 concentric-ring continuous Frechet + ML.2 half-disc MIC

M.5: DiscreteFrechetDistance closed form for concentric CircularString
rings (F=|R-r|). ML.2: CurveExact.halfDiscMic / mic() r=R/2 on axis.
Tests + program sequence docs. Skip M.4 / R.3.

Co-authored-by: Jeroen Bloemscheer <grootstebozewolf@users.noreply.github.com>

Author: cursoragent

doc/CHAINSAW_LASER_PROGRAM.md

@@ -1,67 +1,60 @@
 # Chainsaw → Laser · arc-native program
 
-Tip pin: `feature/sfa-curve-rgr` / session @ `c293fe97` (Sync → M.3 → R.2 → ML.4 landed).  
+Tip pin: session @ `1cd9f498` · product Sync→M.3→R.2→ML.4 @ `c293fe97`.  
+**Active sequence:** **M.5 → ML.2 → HP.4 → N-SS expand (Option B) → stop**
+
 Contract: parity or named densify-shim · `t_laser ≤ 1.15 × t_chainsaw` · no silent ConcaveHull · OverlayNGCurve never *Curved*.
 
 Scoreboard (user board): **green 16 · chainsaw-only 3 · measured 11 hold**. See [LASER_RATCHET.md](LASER_RATCHET.md).
 
-## Holds (do not start)
-
-- **ML.2** convex hole-free CurvePolygon MIC
-- **HP.4** HotPixel walk
-- **N-SS expand** / P2.5.5 as a start signal
-- **M.5** continuous Fréchet before DHD owns Curve*
-- Full **D-HF TAG** green (keep `fail()` in `CurveAwarenessSpecTest`)
+## Holds (still bind)
 
-## Sequence locked (this branch)
+- Full **D-HF TAG** green (`fail()` kept)
+- **M.4** stadium HD · **R.3** stadium relate · **ML.3** MIC miss catalog · **HP.5** core HotPixel
+- 74-file N-SS Option B *lie* · curvature-order face walk
 
-**Sync → M.3 → R.2 → ML.4 → stop**
+## Sequence (this branch)
 
 | Step | Rung | Do |
 |------|------|----|
-| Sync | docs | **Landed** — this file + ratchet / seams / epic pointers |
-| M.3 | D-HF-IWD | **Landed** — `isFullyWithinDistance` via `exactOrientedPoints` |
-| R.2 | DE-9IM | **Landed** — half-disc / open CircularString vs Point / Line / same-circle disc |
-| ML.4 | LEC | **Landed** — `ObstacleDistance` hole-free filled shell assembly |
+| M.5 | Continuous Fréchet | One more continuous closed-form cell; general coupling leftover |
+| ML.2 | Convex MIC | HALF_DISC closed form (centre on axis, r=R/2); nonconvex null |
+| HP.4 | Faces after snap | Wire `CurveHotPixelSnap`; stamp if `SHARED_SNAPPED_RAY` |
+| N-SS | Option B expand | One more `OverlayNGCircle` exact cell; not 74-file |
+| stop | — | Retip; await PO |
 
-**Stop.** No further rungs on this sequence. Holds above still bind.
+## Prior sequence (landed)
+
+Sync → M.3 IWD → R.2 half-disc → ML.4 shell @ `c293fe97` / docs `1cd9f498`.
 
 ## Kit map (abbreviated)
 
 ### Metric (M.X)
 
 | Rung | Status |
 |------|--------|
-| M.0 | Done — distance helpers + two-pair D-HF / Fréchet subset |
-| M.1 | Landed — DHD owns Curve* (arc→segment; discs) |
-| M.2 | Landed — bulge sensitivity |
-| **M.3** | **Landed** — D-HF-IWD `isFullyWithinDistance` |
-| M.4+ | Hold / later (stadium HD, Fréchet, DistanceOp TAG) |
+| M.0–M.3 | Landed |
+| M.4 | Hold |
+| **M.5** | **This sequence** — continuous Fréchet |
+| M.6+ | Later |
 
-### Relate (R.X)
+### MIC / LEC (ML.X)
 
 | Rung | Status |
 |------|--------|
-| R.0 | Done — disc DE-9IM lock |
-| R.1 | Landed — TOUCH `FF2F01212` public relate |
-| **R.2** | **Landed** — half-disc / CircularString |
-| R.3+ | Stadium / CompoundCurve shell — not this stop |
+| ML.0–ML.1 | Landed |
+| **ML.2** | **This sequence** — convex hole-free MIC |
+| ML.3 | Named misses — keep grid |
+| ML.4 | Landed |
 
-### MIC / LEC (ML.X)
+### HotPixel / N-SS
 
 | Rung | Status |
 |------|--------|
-| ML.0 | Done — disc identity + LEC disc-over-disk |
-| ML.1 | Landed — stadium MIC |
-| ML.2 | **Hold** |
-| ML.3 | Named misses (holed / pinch / annulus) — keep grid |
-| **ML.4** | **Landed** — ObstacleDistance hole-free shell assembly |
-| ML.5+ | Apollonius / IsRadiusWithin — after ML.4 |
-
-## Named leftovers (not this stop)
-
-Bar-1 style leftovers may still include: H-DISC (open arcs) · CC-NEST-ANNULUS · R1.6-honesty · TOUCH-int · edge-constrained weighted · HP seams. R-PR-HALF sewn by R.2.  
-Do not expand DiscreteHausdorff named pairs. Do not densify-then-flag-exact.
+| HP.0–HP.3 | Landed |
+| **HP.4** | **This sequence** — faces after snap / honest stamp |
+| HP.5 | Off |
+| N-SS | Started OverlayNGCircle; **expand** this sequence |
 
 ## Related
 

modules/core/src/main/java/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistance.java

@@ -79,8 +79,9 @@ public static double distance(Geometry g0, Geometry g1) {
 
   /**
    * True when {@link #distance(Geometry, Geometry)} uses a certified
-   * continuous closed form (two circular discs, or an endpoint-aligned
-   * minor circular arc over its chord) instead of the control-point matrix.
+   * continuous closed form (two circular discs, an endpoint-aligned
+   * minor circular arc over its chord, or two concentric full-circle
+   * rings) instead of the control-point matrix.
    *
    * @param g0 the 1st geometry
    * @param g1 the 2nd geometry
@@ -99,6 +100,9 @@ public static boolean hasCertifiedClosedForm(Geometry g0, Geometry g1) {
       return DiscreteHausdorffDistance.circularDisc(g0) != null
           && DiscreteHausdorffDistance.circularDisc(g1) != null;
     }
+    if ("CircularString".equals(t0) && "CircularString".equals(t1)) {
+      return fillConcentricCircularRings(g0, g1, null);
+    }
     return false;
   }
 
@@ -169,9 +173,10 @@ public Coordinate[] getCoordinates() {
   }
 
   /**
-   * Continuous Fréchet equals Hausdorff on the two certified pairs.
+   * Continuous Fréchet equals Hausdorff on the certified pairs.
    * Two discs reuse {@link DiscreteHausdorffDistance#circleToCircle}.
    * The aligned minor arc uses the sagitta of that same Hausdorff.
+   * Two concentric full-circle rings use {@code |R−r|}.
    */
   private boolean applyCertifiedClosedForm() {
     if (g0 == null || g1 == null) {
@@ -200,9 +205,51 @@ private boolean applyCertifiedClosedForm() {
           db[0], db[1], db[2], da[0], da[1], da[2], ptDist);
       return true;
     }
+    if ("CircularString".equals(t0) && "CircularString".equals(t1)) {
+      ptDist = new PointPairDistance();
+      if (fillConcentricCircularRings(g0, g1, ptDist)) {
+        return true;
+      }
+      ptDist = null;
+      return false;
+    }
     return false;
   }
 
+  /**
+   * M.5: two concentric full-circle {@code CircularString} rings.
+   * Continuous Fréchet equals Hausdorff equals {@code |R−r|}. Off-centre
+   * rings miss (not this cell). Control polylines of the same points
+   * stay on the discrete matrix.
+   *
+   * @param dest filled with a farthest pair when non-null
+   * @return {@code true} when the pair is certified
+   */
+  private static boolean fillConcentricCircularRings(Geometry a, Geometry b,
+      PointPairDistance dest) {
+    double[] ra = DiscreteHausdorffDistance.circularRing(a);
+    double[] rb = DiscreteHausdorffDistance.circularRing(b);
+    if (ra == null || rb == null) {
+      return false;
+    }
+    if (Math.hypot(ra[0] - rb[0], ra[1] - rb[1]) > 1.0e-9) {
+      return false;
+    }
+    if (dest == null) {
+      return true;
+    }
+    double cx = ra[0];
+    double cy = ra[1];
+    // Farthest pair: outer point and its radial projection on the inner.
+    double rOut = Math.max(ra[2], rb[2]);
+    double rIn = Math.min(ra[2], rb[2]);
+    Coordinate outer = new Coordinate(cx + rOut, cy);
+    Coordinate inner = new Coordinate(cx + rIn, cy);
+    dest.initialize();
+    dest.setMaximum(outer, inner);
+    return true;
+  }
+
   private static boolean isArcSegmentTypePair(String t0, String t1) {
     return ("CircularString".equals(t0) && "LineString".equals(t1))
         || ("LineString".equals(t0) && "CircularString".equals(t1));

modules/curve/src/main/java/org/locationtech/jts/geom/curve/CurveExact.java

@@ -1298,7 +1298,31 @@ private static boolean isCurveCollection(Geometry g) {
   static CircularArcDensifier.Circle mic(Geometry g) {
     CircularArcDensifier.Circle disc = circularDisc(g);
     if (disc != null) return disc;
-    return stadiumMic(g);
+    CircularArcDensifier.Circle stadium = stadiumMic(g);
+    if (stadium != null) return stadium;
+    return halfDiscMic(g);
+  }
+
+  /**
+   * ML.2: MIC of a certified half-disc. Centre sits on the symmetry
+   * ray through the arc mid-control; radius is {@code R/2}. Matches
+   * densify-{@code MaximumInscribedCircle} on HALF_DISC (R=5 → (0, 2.5)).
+   * Non-half-disc convex shells and nonconvex shapes miss.
+   */
+  static CircularArcDensifier.Circle halfDiscMic(Geometry g) {
+    HalfDisc half = HalfDisc.of(g);
+    if (half == null) return null;
+    double r = half.circle.r;
+    if (r <= 0.0) return null;
+    double ux = half.mid.x - half.circle.cx;
+    double uy = half.mid.y - half.circle.cy;
+    double len = Math.hypot(ux, uy);
+    if (len <= 1.0e-12) return null;
+    ux /= len;
+    uy /= len;
+    double micR = 0.5 * r;
+    return new CircularArcDensifier.Circle(
+        half.circle.cx + micR * ux, half.circle.cy + micR * uy, micR);
   }
 
   /**

modules/curve/src/test/java/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistanceCurveTest.java

@@ -113,4 +113,28 @@ public void testReversedSegmentIsNotClosedForm() throws Exception {
     assertEquals(10.0, frechet, TOL);
     assertTrue(Math.abs(frechet - APEX) > 0.1);
   }
+
+  /**
+   * M.5: concentric full-circle rings — continuous F = |R−r|.
+   */
+  public void testConcentricRingsContinuousFrechetIsRadiusGap() throws Exception {
+    Geometry outer = readCurve(
+        "CIRCULARSTRING (-5 0, 0 5, 5 0, 0 -5, -5 0)");
+    Geometry inner = readCurve(
+        "CIRCULARSTRING (-3 0, 0 3, 3 0, 0 -3, -3 0)");
+    assertTrue(DiscreteFrechetDistance.hasCertifiedClosedForm(outer, inner));
+    assertEquals(2.0, DiscreteFrechetDistance.distance(outer, inner), TOL);
+    assertEquals(2.0, DiscreteFrechetDistance.distance(inner, outer), TOL);
+    // Discrete Hausdorff on control diamonds is not the continuous answer.
+    assertTrue(Math.abs(DiscreteHausdorffDistance.distance(outer, inner) - 2.0)
+        > 0.1);
+  }
+
+  public void testOffCentreRingsAreNotConcentricCell() throws Exception {
+    Geometry a = readCurve(
+        "CIRCULARSTRING (-5 0, 0 5, 5 0, 0 -5, -5 0)");
+    Geometry b = readCurve(
+        "CIRCULARSTRING (-3 2, 0 5, 3 2, 0 -1, -3 2)");
+    assertTrue(!DiscreteFrechetDistance.hasCertifiedClosedForm(a, b));
+  }
 }

modules/curve/src/test/java/org/locationtech/jts/algorithm/distance/DiscreteFrechetDistancePerfGateTest.java

@@ -126,4 +126,15 @@ public void testPlainLineIsChordPath() throws Exception {
         () -> DiscreteFrechetDistance.distance(line, seg),
         () -> DiscreteFrechetDistance.distance(line, seg));
   }
+
+  /** M.5: concentric rings continuous closed form. */
+  public void testConcentricRingsNotSlowerThanControlPoints() throws Exception {
+    Geometry outer = readCurve(
+        "CIRCULARSTRING (-5 0, 0 5, 5 0, 0 -5, -5 0)");
+    Geometry inner = readCurve(
+        "CIRCULARSTRING (-3 0, 0 3, 3 0, 0 -3, -3 0)");
+    assertLaserNotSlower("Frechet concentric rings",
+        () -> DiscreteFrechetDistance.distance(outer, inner),
+        () -> controlPointDistance(outer, inner));
+  }
 }

modules/curve/src/test/java/org/locationtech/jts/geom/curve/CurveExactConvexMicTest.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2026 grootstebozewolf
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * and Eclipse Distribution License v. 1.0 which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v20.html
+ * and the Eclipse Distribution License is available at
+ *
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ */
+package org.locationtech.jts.geom.curve;
+
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.io.curve.CurveWKTReader;
+
+import junit.textui.TestRunner;
+import test.jts.GeometryTestCase;
+
+/**
+ * ML.2: convex hole-free CurvePolygon MIC. HALF_DISC is the witness
+ * (centre on the symmetry ray, r = R/2). Disc (ML.0) and stadium (ML.1)
+ * stay first. Nonconvex / holed miss.
+ */
+public class CurveExactConvexMicTest extends GeometryTestCase {
+
+  private static final String HALF_DISC =
+      "CURVEPOLYGON (COMPOUNDCURVE (CIRCULARSTRING (-5 0, 0 5, 5 0), (5 0, -5 0)))";
+  private static final String HALF_LOWER =
+      "CURVEPOLYGON (COMPOUNDCURVE (CIRCULARSTRING (-5 0, 0 -5, 5 0), (5 0, -5 0)))";
+  private static final String CIRCLE_5 =
+      "CURVEPOLYGON (CIRCULARSTRING (-5 0, 0 5, 5 0, 0 -5, -5 0))";
+  private static final String NONCONVEX_PINCH =
+      "CURVEPOLYGON (COMPOUNDCURVE ("
+          + "CIRCULARSTRING (0 0, -2 2, 0 4), (0 4, 0 3), "
+          + "CIRCULARSTRING (0 3, 2 2, 0 1), (0 1, 0 0)))";
+
+  public static void main(String[] args) {
+    TestRunner.run(CurveExactConvexMicTest.class);
+  }
+
+  public CurveExactConvexMicTest(String name) {
+    super(name);
+  }
+
+  private static Geometry readCurve(String wkt) throws Exception {
+    return new CurveWKTReader(new CurveGeometryFactory()).read(wkt);
+  }
+
+  public void testHalfDiscMicIsHalfRadiusOnAxis() throws Exception {
+    CircularArcDensifier.Circle mic = CurveExact.halfDiscMic(readCurve(HALF_DISC));
+    assertNotNull(mic);
+    assertEquals(0.0, mic.cx, 0.0);
+    assertEquals(2.5, mic.cy, 0.0);
+    assertEquals(2.5, mic.r, 0.0);
+    assertEquals(mic.cx, CurveExact.mic(readCurve(HALF_DISC)).cx, 0.0);
+    assertEquals(mic.cy, CurveExact.mic(readCurve(HALF_DISC)).cy, 0.0);
+    assertEquals(mic.r, CurveExact.mic(readCurve(HALF_DISC)).r, 0.0);
+  }
+
+  public void testLowerHalfDiscMic() throws Exception {
+    CircularArcDensifier.Circle mic = CurveExact.mic(readCurve(HALF_LOWER));
+    assertNotNull(mic);
+    assertEquals(0.0, mic.cx, 0.0);
+    assertEquals(-2.5, mic.cy, 0.0);
+    assertEquals(2.5, mic.r, 0.0);
+  }
+
+  public void testDiscStillMl0First() throws Exception {
+    CircularArcDensifier.Circle mic = CurveExact.mic(readCurve(CIRCLE_5));
+    assertEquals(0.0, mic.cx, 0.0);
+    assertEquals(0.0, mic.cy, 0.0);
+    assertEquals(5.0, mic.r, 0.0);
+    assertNull(CurveExact.halfDiscMic(readCurve(CIRCLE_5)));
+  }
+
+  public void testNonconvexPinchMisses() throws Exception {
+    assertNull(CurveExact.halfDiscMic(readCurve(NONCONVEX_PINCH)));
+    assertNull(CurveExact.mic(readCurve(NONCONVEX_PINCH)));
+  }
+}

modules/curve/src/test/java/org/locationtech/jts/geom/curve/CurveExactStadiumMicTest.java

@@ -20,8 +20,8 @@
 /**
  * ML.1: certified stadium MIC. Radius is the cap radius; centre is
  * the midpoint of the two cap centres. Disc MIC (ML.0) is tried first
- * and stays bit-identical. {@code HALF_DISC} is two members -- a named
- * miss, not a half-disc diamond claimed exact.
+ * and stays bit-identical. {@code HALF_DISC} is ML.2 (r=R/2), not a
+ * stadium.
  */
 public class CurveExactStadiumMicTest extends GeometryTestCase {
 
@@ -101,8 +101,13 @@ public void testHalfDiscIsNotAStadium() throws Exception {
     Geometry half = readCurve(HALF_DISC);
     assertNull("HALF_DISC is one semicircle + diameter",
         CurveExact.stadiumMic(half));
-    assertNull("HALF_DISC is not a disc either -- chordsaw, not a diamond laser",
-        CurveExact.mic(half));
+    // ML.2: half-disc is the convex MIC cell, not a stadium miss.
+    CircularArcDensifier.Circle mic = CurveExact.mic(half);
+    assertNotNull(mic);
+    assertEquals(0.0, mic.cx, 0.0);
+    assertEquals(2.5, mic.cy, 0.0);
+    assertEquals(2.5, mic.r, 0.0);
+    assertEquals(mic.cx, CurveExact.halfDiscMic(half).cx, 0.0);
   }
 
   public void testHoledStadiumStamps() throws Exception {