spec: F-MC + F-MS spike -- reader half free, writer override closes both

Probe of current Phase-1 behaviour against six F-MC / F-MS red tests
(MultiCompositeMemberSpec):

  - test_FMC_READ_membersRetainSubtypes        passes today
  - test_FMC_COPY_copyPreservesMemberSubtypes  passes today
  - test_FMS_READ_membersRetainSubtypes        passes today
  - test_FMS_COPY_copyPreservesMemberSubtypes  passes today
  - test_FMC_WKT_writerEmitsMemberTagsForRoundTrip   RED
  - test_FMS_WKT_writerEmitsCurvePolygonTagForRoundTrip   RED

Finding: the reader half of F-MC and F-MS is **already done** on the
extension-points base. CurvedWKTReader.readCurveMember dispatches
through readGeometryTaggedText on a tagged member, so a CIRCULARSTRING
or COMPOUNDCURVE inside MULTICURVE comes back as its proper subtype;
likewise CurvePolygon inside MULTISURFACE. MultiLineString and
MultiPolygon store LineString[] / Polygon[] internally, so copy()
through the standard copyInternal already preserves member subtypes
without F-CP-style storage redesign.

The writer half loses member identity: appendMultiLineStringText and
appendMultiPolygonText emit per-member coordinates as bare
parenthesised bodies, dropping the type tag. So a MULTICURVE
containing a CIRCULARSTRING round-trips as MULTICURVE with all
plain-LineString members.

Fix (this commit): CurvedWKTWriter overrides the
appendOtherGeometryTaggedText extension hook from PR locationtech#1194 to
intercept MultiCurve and MultiSurface. The override emits the
OGC-conventional shape:

  - plain LineString member  -> body-only `(x y, x y, …)`
  - CircularString member    -> tagged `CIRCULARSTRING (…)`
  - CompoundCurve member     -> tagged `COMPOUNDCURVE (…)`
  - plain Polygon member     -> body-only `((x y, …))`
  - CurvePolygon member      -> tagged `CURVEPOLYGON (…)`

Implementation is ~75 LOC additive on CurvedWKTWriter. Per-member
emission uses `new CurvedWKTWriter().write(member)` for the tagged
form and a leading-keyword-strip helper for the body-only form. No
jts-core API change required -- everything routes through the
extension hook already in place.

Posture verified:
  - default `mvn -pl modules/curved test`           55 / 55 green
  - on-demand `-Dtest=MultiCompositeMemberSpec`     6 / 6 green
  - full reactor with checkstyle                    BUILD SUCCESS

Spec class joins the curveawareness/ exclusion convention so it runs
on demand only (same pattern as CurvePolygonStructuralSpec).

Phase-1 status after this commit:
  F-CP   still pending (Option A recommended, see PR locationtech#1194 comment thread)
  F-MC   READER done on base; WRITER closed by this spike
  F-MS   READER done on base; WRITER closed by this spike
  F-RD   testbuilder rendering, separate Phase 4-B / lab work

Once F-CP lands under Option A, Phase 1 is complete and Phases 2/3/4/5/7
unlock per the §10 dependency graph.

Assisted-by: Claude (Opus-4.7)
Signed-off-by: Jeroen Bloemscheer <jeroen@jeroentechsolutions.uk>

Author: grootstebozewolf

modules/curved/pom.xml

@@ -39,6 +39,18 @@
                   </archive>
                 </configuration>
             </plugin>
+            <plugin>
+                <!-- Spec / red-test suites under spec/curveawareness/ are
+                     intentionally red and document deferred behaviour
+                     (see issue #1195 §11). They run on demand with
+                     `mvn -pl modules/curved test -Dtest=<SpecClassName>`. -->
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>**/spec/curveawareness/*.java</exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 

modules/curved/src/main/java/org/locationtech/jts/io/curved/CurvedWKTWriter.java

@@ -11,23 +11,44 @@
  */
 package org.locationtech.jts.io.curved;
 
+import java.io.IOException;
+import java.io.Writer;
+import java.util.EnumSet;
+import java.util.Locale;
+
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.curved.MultiCurve;
+import org.locationtech.jts.geom.curved.MultiSurface;
+import org.locationtech.jts.io.Ordinate;
+import org.locationtech.jts.io.OrdinateFormat;
 import org.locationtech.jts.io.WKTWriter;
 
 /**
  * A {@link WKTWriter} subclass for the OGC SFA / ISO 19125-2 extended
  * geometry types.
- * <p>
- * In the current phase-1 implementation this class is a no-op marker:
- * the curve geometry classes ({@code CircularString}, {@code Triangle},
- * {@code CurvePolygon}, etc.) extend their nearest core counterparts
- * and the core {@code WKTWriter} already emits each subclass's keyword
- * via {@code Geometry.getGeometryType().toUpperCase(Locale.ROOT)}.
- * <p>
- * The class is provided here so that callers can pair {@code
- * CurvedWKTReader} with {@code CurvedWKTWriter} symmetrically, and so
- * that future enhancements (member-structured emission for
- * {@code CompoundCurve}, etc.) can land here without changing caller
- * code.
+ *
+ * <p>Phase-1 keyword emission is inherited from the core writer
+ * (which now reads the keyword from
+ * {@code Geometry.getGeometryType().toUpperCase(Locale.ROOT)}, courtesy
+ * of PR #1194). What this subclass adds, via the
+ * {@link #appendOtherGeometryTaggedText} extension hook, is
+ * <em>member-tag preservation</em> for the multi-composite types:
+ *
+ * <ul>
+ *   <li><b>MULTICURVE</b> — emits {@code CIRCULARSTRING (…)} or
+ *       {@code COMPOUNDCURVE (…)} for non-plain members, body-only
+ *       parentheses for plain {@code LineString} members.</li>
+ *   <li><b>MULTISURFACE</b> — emits {@code CURVEPOLYGON (…)} for
+ *       {@code CurvePolygon} members, body-only parentheses for plain
+ *       {@code Polygon} members.</li>
+ * </ul>
+ *
+ * <p>This closes F-MC-WKT and F-MS-WKT (locationtech/jts#1195). The
+ * reader-side preservation of member subtypes already works on the
+ * current Phase-1 base via {@code CurvedWKTReader.readCurveMember /
+ * readSurfaceMember}; only the writer side needed to learn.
  */
 public class CurvedWKTWriter extends WKTWriter {
 
@@ -38,4 +59,75 @@ public CurvedWKTWriter() {
   public CurvedWKTWriter(int outputDimension) {
     super(outputDimension);
   }
+
+  @Override
+  protected boolean appendOtherGeometryTaggedText(
+      Geometry geometry, EnumSet<Ordinate> outputOrdinates, boolean useFormatting,
+      int level, Writer writer, OrdinateFormat formatter) throws IOException {
+    if (geometry instanceof MultiCurve) {
+      writeMultiCurveText((MultiCurve) geometry, outputOrdinates, writer);
+      return true;
+    }
+    if (geometry instanceof MultiSurface) {
+      writeMultiSurfaceText((MultiSurface) geometry, outputOrdinates, writer);
+      return true;
+    }
+    return false;
+  }
+
+  private void writeMultiCurveText(MultiCurve mc, EnumSet<Ordinate> outputOrdinates, Writer writer)
+      throws IOException {
+    writer.write(mc.getGeometryType().toUpperCase(Locale.ROOT));
+    appendOrdinateText(outputOrdinates, writer);
+    if (mc.isEmpty()) {
+      writer.write(" EMPTY");
+      return;
+    }
+    writer.write(" (");
+    for (int i = 0; i < mc.getNumGeometries(); i++) {
+      if (i > 0) writer.write(", ");
+      Geometry m = mc.getGeometryN(i);
+      // Plain LineString members emit body-only (OGC SFA conventional).
+      // Curve-typed members emit the tagged form so the reader recovers
+      // their subtype on round-trip.
+      if (m.getClass() == LineString.class) {
+        writer.write(emitBodyOnly(m));
+      } else {
+        writer.write(new CurvedWKTWriter().write(m));
+      }
+    }
+    writer.write(")");
+  }
+
+  private void writeMultiSurfaceText(MultiSurface ms, EnumSet<Ordinate> outputOrdinates, Writer writer)
+      throws IOException {
+    writer.write(ms.getGeometryType().toUpperCase(Locale.ROOT));
+    appendOrdinateText(outputOrdinates, writer);
+    if (ms.isEmpty()) {
+      writer.write(" EMPTY");
+      return;
+    }
+    writer.write(" (");
+    for (int i = 0; i < ms.getNumGeometries(); i++) {
+      if (i > 0) writer.write(", ");
+      Geometry m = ms.getGeometryN(i);
+      if (m.getClass() == Polygon.class) {
+        writer.write(emitBodyOnly(m));
+      } else {
+        writer.write(new CurvedWKTWriter().write(m));
+      }
+    }
+    writer.write(")");
+  }
+
+  /**
+   * Body-only emission for plain LineString / Polygon members.
+   * Strips the leading keyword (e.g. "LINESTRING ", "POLYGON ") so that
+   * the result reads as a bare parenthesised body within a multi-composite.
+   */
+  private static String emitBodyOnly(Geometry plainMember) {
+    String full = new CurvedWKTWriter().write(plainMember);
+    int firstParen = full.indexOf('(');
+    return firstParen < 0 ? full : full.substring(firstParen);
+  }
 }

modules/curved/src/test/java/org/locationtech/jts/spec/curveawareness/MultiCompositeMemberSpec.java

@@ -0,0 +1,182 @@
+/*
+ * 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.spec.curveawareness;
+
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.curved.CircularString;
+import org.locationtech.jts.geom.curved.CompoundCurve;
+import org.locationtech.jts.geom.curved.CurvePolygon;
+import org.locationtech.jts.geom.curved.MultiCurve;
+import org.locationtech.jts.geom.curved.MultiSurface;
+import org.locationtech.jts.io.curved.CurvedWKTReader;
+import org.locationtech.jts.io.curved.CurvedWKTWriter;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import junit.textui.TestRunner;
+import test.jts.GeometryTestCase;
+
+/**
+ * Focused red-test suite for sub-issues <strong>F-MC</strong> (structural
+ * MultiCurve) and <strong>F-MS</strong> (structural MultiSurface) of the
+ * SFA Curve Awareness epic (locationtech/jts#1195).
+ *
+ * <p>Unlike F-CP, these two have <b>no DOVE-style risk</b>:
+ * {@code MultiLineString.getGeometryN(int)} already returns
+ * {@code Geometry}, and {@code MultiPolygon.getGeometryN(int)} returns
+ * {@code Geometry} too — so a member typed as a {@code CircularString}
+ * or {@code CurvePolygon} satisfies the existing contract without
+ * widening any return type.
+ *
+ * <p>The questions for F-MC / F-MS are simpler:
+ * <ol>
+ *   <li><b>FMC-READ</b>: does the WKT reader preserve heterogeneous
+ *       members (CircularString / CompoundCurve / plain LineString)
+ *       inside MULTICURVE?</li>
+ *   <li><b>FMC-COPY</b>: does {@code MultiCurve.copy()} preserve each
+ *       member's subtype, not just the parent {@code LineString}?</li>
+ *   <li><b>FMC-WKT</b>: does the writer emit member type tags so
+ *       round-trip is lossless?</li>
+ *   <li><b>FMS-READ</b>: same question for MULTISURFACE
+ *       (Polygon / CurvePolygon members).</li>
+ *   <li><b>FMS-COPY</b>: same copy preservation question for
+ *       MultiSurface.</li>
+ *   <li><b>FMS-WKT</b>: writer round-trip for MULTISURFACE.</li>
+ * </ol>
+ *
+ * <p>Each {@code fail("FMC-…: …")} / {@code "FMS-…: …"} message names
+ * the sub-issue tag so the message stream is a live progress meter.
+ * Tests already known to pass via the {@code readCurveMember} /
+ * {@code readSurfaceMember} dispatch in PR #1194 will go green
+ * immediately; the rest mark the remaining gap.
+ *
+ * <p>Run on demand: {@code mvn -pl modules/curved test
+ * -Dtest=MultiCompositeMemberSpec}.
+ */
+public class MultiCompositeMemberSpec extends GeometryTestCase {
+
+  public static void main(String[] args) { TestRunner.run(suite()); }
+  public static Test suite() { return new TestSuite(MultiCompositeMemberSpec.class); }
+  public MultiCompositeMemberSpec(String name) { super(name); }
+
+  // -- F-MC --------------------------------------------------------------
+
+  private static final String WKT_MC_HETEROGENEOUS =
+      "MULTICURVE("
+      + "(5 5, 3 5, 3 3, 0 3), "
+      + "CIRCULARSTRING(0 0, 1 1, 2 0), "
+      + "COMPOUNDCURVE(CIRCULARSTRING(0 0, 1 1, 2 0), (2 0, 5 0))"
+      + ")";
+
+  /** FMC-READ: MultiCurve member subtypes survive the reader. */
+  public void test_FMC_READ_membersRetainSubtypes() throws Exception {
+    Geometry g = new CurvedWKTReader().read(WKT_MC_HETEROGENEOUS);
+    assertTrue("Reader returns MultiCurve", g instanceof MultiCurve);
+    MultiCurve mc = (MultiCurve) g;
+    assertEquals("FMC-READ: three members", 3, mc.getNumGeometries());
+
+    Geometry m0 = mc.getGeometryN(0);
+    Geometry m1 = mc.getGeometryN(1);
+    Geometry m2 = mc.getGeometryN(2);
+    assertEquals("FMC-READ: member 0 is plain LineString, got " + m0.getGeometryType(),
+        "LineString", m0.getGeometryType());
+    assertTrue("FMC-READ: member 1 is CircularString, got " + m1.getClass().getSimpleName(),
+        m1 instanceof CircularString);
+    assertTrue("FMC-READ: member 2 is CompoundCurve, got " + m2.getClass().getSimpleName(),
+        m2 instanceof CompoundCurve);
+  }
+
+  /** FMC-COPY: MultiCurve.copy() preserves each member's subtype. */
+  public void test_FMC_COPY_copyPreservesMemberSubtypes() throws Exception {
+    MultiCurve mc = (MultiCurve) new CurvedWKTReader().read(WKT_MC_HETEROGENEOUS);
+    MultiCurve copy = (MultiCurve) mc.copy();
+    for (int i = 0; i < mc.getNumGeometries(); i++) {
+      assertEquals("FMC-COPY: member " + i + " class survives copy",
+          mc.getGeometryN(i).getClass(),
+          copy.getGeometryN(i).getClass());
+    }
+    assertNotSame("FMC-COPY: deep copy of first member",
+        mc.getGeometryN(0), copy.getGeometryN(0));
+  }
+
+  /** FMC-WKT: writer emits member type tags so re-reading recovers the same shape. */
+  public void test_FMC_WKT_writerEmitsMemberTagsForRoundTrip() throws Exception {
+    MultiCurve mc = (MultiCurve) new CurvedWKTReader().read(WKT_MC_HETEROGENEOUS);
+    String emitted = new CurvedWKTWriter().write(mc);
+    assertTrue("FMC-WKT: emitted WKT mentions CIRCULARSTRING tag inside body, got: "
+        + emitted, emitted.toUpperCase().contains("CIRCULARSTRING"));
+    assertTrue("FMC-WKT: emitted WKT mentions COMPOUNDCURVE tag inside body, got: "
+        + emitted, emitted.toUpperCase().contains("COMPOUNDCURVE"));
+
+    MultiCurve roundTripped = (MultiCurve) new CurvedWKTReader().read(emitted);
+    assertEquals("FMC-WKT: same member count", mc.getNumGeometries(),
+        roundTripped.getNumGeometries());
+    for (int i = 0; i < mc.getNumGeometries(); i++) {
+      assertEquals("FMC-WKT: member " + i + " class survives round-trip",
+          mc.getGeometryN(i).getClass(),
+          roundTripped.getGeometryN(i).getClass());
+    }
+  }
+
+  // -- F-MS --------------------------------------------------------------
+
+  private static final String WKT_MS_HETEROGENEOUS =
+      "MULTISURFACE("
+      + "((0 0, 10 0, 10 10, 0 10, 0 0)), "
+      + "CURVEPOLYGON(CIRCULARSTRING(0 0, 4 0, 4 4, 0 4, 0 0))"
+      + ")";
+
+  /** FMS-READ: MultiSurface preserves Polygon vs CurvePolygon members. */
+  public void test_FMS_READ_membersRetainSubtypes() throws Exception {
+    Geometry g = new CurvedWKTReader().read(WKT_MS_HETEROGENEOUS);
+    assertTrue("Reader returns MultiSurface", g instanceof MultiSurface);
+    MultiSurface ms = (MultiSurface) g;
+    assertEquals("FMS-READ: two members", 2, ms.getNumGeometries());
+
+    Geometry m0 = ms.getGeometryN(0);
+    Geometry m1 = ms.getGeometryN(1);
+    assertEquals("FMS-READ: member 0 is plain Polygon, got " + m0.getGeometryType(),
+        "Polygon", m0.getGeometryType());
+    assertTrue("FMS-READ: member 1 is CurvePolygon, got " + m1.getClass().getSimpleName(),
+        m1 instanceof CurvePolygon);
+  }
+
+  /** FMS-COPY: MultiSurface.copy() preserves Polygon vs CurvePolygon. */
+  public void test_FMS_COPY_copyPreservesMemberSubtypes() throws Exception {
+    MultiSurface ms = (MultiSurface) new CurvedWKTReader().read(WKT_MS_HETEROGENEOUS);
+    MultiSurface copy = (MultiSurface) ms.copy();
+    for (int i = 0; i < ms.getNumGeometries(); i++) {
+      assertEquals("FMS-COPY: member " + i + " class survives copy",
+          ms.getGeometryN(i).getClass(),
+          copy.getGeometryN(i).getClass());
+    }
+  }
+
+  /** FMS-WKT: round-trip preserves the CURVEPOLYGON member tag. */
+  public void test_FMS_WKT_writerEmitsCurvePolygonTagForRoundTrip() throws Exception {
+    MultiSurface ms = (MultiSurface) new CurvedWKTReader().read(WKT_MS_HETEROGENEOUS);
+    String emitted = new CurvedWKTWriter().write(ms);
+    assertTrue("FMS-WKT: emitted WKT mentions CURVEPOLYGON tag inside body, got: "
+        + emitted, emitted.toUpperCase().contains("CURVEPOLYGON"));
+
+    MultiSurface roundTripped = (MultiSurface) new CurvedWKTReader().read(emitted);
+    assertEquals("FMS-WKT: same member count", ms.getNumGeometries(),
+        roundTripped.getNumGeometries());
+    for (int i = 0; i < ms.getNumGeometries(); i++) {
+      assertEquals("FMS-WKT: member " + i + " class survives round-trip",
+          ms.getGeometryN(i).getClass(),
+          roundTripped.getGeometryN(i).getClass());
+    }
+  }
+}