Improve girder cap loop traversal and coverage tests

Author: cakeGit

src/main/java/com/kipti/bnb/content/girder_strut/cap/GirderCapAccumulator.java

@@ -17,6 +17,7 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -153,7 +154,13 @@ List<CapLoop> buildLoops(Vector3f planePoint, Vector3f planeNormal) {
             );
         }
 
-        return Collections.unmodifiableList(loops);
+        List<CapLoop> deduped = dedupeLoops(loops);
+        if (deduped.size() != loops.size()) {
+            CreateBitsnBobs.LOGGER.debug(
+                "[GirderCap] removed {} duplicate loops", loops.size() - deduped.size()
+            );
+        }
+        return Collections.unmodifiableList(deduped);
     }
 
     private void emitLoop(
@@ -224,9 +231,6 @@ private static List<CapVertex> traceLoop(CapEdge start, Map<VertexKey, List<CapE
                 return List.of();
             }
             current.setUsed(true);
-            if (current.twin() != null) {
-                current.twin().setUsed(true);
-            }
             loop.add(current.start().copy());
 
             CapEdge next = findNextEdge(current, outgoing, start);
@@ -256,18 +260,15 @@ private static CapEdge findNextEdge(CapEdge current, Map<VertexKey, List<CapEdge
             return null;
         }
 
-        int twinIndex = current.twin() == null ? -1 : star.indexOf(current.twin());
-        if (twinIndex >= 0) {
-            int size = star.size();
-            for (int offset = 1; offset <= size; offset++) {
-                int index = (twinIndex - offset + size) % size;
-                CapEdge candidate = star.get(index);
-                if (!candidate.used() || candidate == start) {
-                    return candidate;
-                }
-            }
+        float baseAngle = current.twin() != null ? current.twin().normalizedAngle() : CapEdge.normalizeAngle(current.angle() + (float) Math.PI);
+
+        CapEdge best = selectNextEdge(star, baseAngle, start);
+        if (best != null) {
+            return best;
         }
 
+        // If every unused edge lies exactly on the base direction we may have a degenerate wedge.
+        // Fall back to any available edge to avoid abandoning the loop outright.
         for (CapEdge candidate : star) {
             if (!candidate.used() || candidate == start) {
                 return candidate;
@@ -277,6 +278,39 @@ private static CapEdge findNextEdge(CapEdge current, Map<VertexKey, List<CapEdge
         return null;
     }
 
+    private static List<CapLoop> dedupeLoops(List<CapLoop> loops) {
+        Map<LoopSignature, CapLoop> unique = new LinkedHashMap<>();
+        for (CapLoop loop : loops) {
+            LoopSignature signature = LoopSignature.from(loop);
+            unique.putIfAbsent(signature, loop);
+        }
+        return new ArrayList<>(unique.values());
+    }
+
+    private static CapEdge selectNextEdge(List<CapEdge> star, float baseAngle, CapEdge start) {
+        CapEdge best = null;
+        float bestDelta = Float.POSITIVE_INFINITY;
+        for (CapEdge candidate : star) {
+            if (candidate.used() && candidate != start) {
+                continue;
+            }
+            float delta = angleDelta(baseAngle, candidate.normalizedAngle());
+            if (delta < bestDelta - GirderGeometry.EPSILON) {
+                bestDelta = delta;
+                best = candidate;
+            }
+        }
+        return best;
+    }
+
+    private static float angleDelta(float from, float to) {
+        float delta = to - from;
+        while (delta <= 0f) {
+            delta += (float) (Math.PI * 2.0);
+        }
+        return delta;
+    }
+
     private record CapSegment(CapVertex start, CapVertex end, int tintIndex, boolean shade) {
     }
 
@@ -286,6 +320,45 @@ record CapLoop(LoopKey key, List<CapVertex> vertices) {
     private record LoopKey(int tintIndex, boolean shade) {
     }
 
+    private record LoopSignature(LoopKey key, String geometry) {
+
+        static LoopSignature from(CapLoop loop) {
+            return new LoopSignature(loop.key(), canonicalGeometry(loop));
+        }
+
+        private static String canonicalGeometry(CapLoop loop) {
+            List<VertexKey> keys = new ArrayList<>(loop.vertices().size());
+            for (CapVertex vertex : loop.vertices()) {
+                keys.add(VertexKey.from(vertex.position()));
+            }
+            String forward = canonicalOrientation(keys);
+            List<VertexKey> reversed = new ArrayList<>(keys);
+            java.util.Collections.reverse(reversed);
+            String backward = canonicalOrientation(reversed);
+            return forward.compareTo(backward) <= 0 ? forward : backward;
+        }
+
+        private static String canonicalOrientation(List<VertexKey> keys) {
+            if (keys.isEmpty()) {
+                return "";
+            }
+            int size = keys.size();
+            String best = null;
+            for (int offset = 0; offset < size; offset++) {
+                StringBuilder builder = new StringBuilder();
+                for (int i = 0; i < size; i++) {
+                    VertexKey key = keys.get((offset + i) % size);
+                    builder.append(key.x()).append(',').append(key.y()).append(',').append(key.z()).append(';');
+                }
+                String candidate = builder.toString();
+                if (best == null || candidate.compareTo(best) < 0) {
+                    best = candidate;
+                }
+            }
+            return best;
+        }
+    }
+
     static final class CapVertex {
 
         private final Vector3f position;
@@ -367,6 +440,7 @@ private static final class CapEdge {
         private final VertexKey startKey;
         private final VertexKey endKey;
         private final float angle;
+        private final float normalizedAngle;
         private CapEdge twin;
         private boolean used;
 
@@ -376,6 +450,7 @@ private static final class CapEdge {
             this.startKey = startKey;
             this.endKey = endKey;
             this.angle = angle;
+            this.normalizedAngle = normalizeAngle(angle);
         }
 
         CapVertex start() {
@@ -398,6 +473,10 @@ float angle() {
             return angle;
         }
 
+        float normalizedAngle() {
+            return normalizedAngle;
+        }
+
         boolean used() {
             return used;
         }
@@ -413,6 +492,14 @@ CapEdge twin() {
         void setTwin(CapEdge twin) {
             this.twin = twin;
         }
+
+        static float normalizeAngle(float angle) {
+            float normalized = angle % (float) (Math.PI * 2.0);
+            if (normalized < 0f) {
+                normalized += (float) (Math.PI * 2.0);
+            }
+            return normalized;
+        }
     }
 
     private static Vector2f planarCoordinates(Vector3f position, Vector3f planePoint, Vector3f uAxis, Vector3f vAxis) {

src/test/java/com/kipti/bnb/content/girder_strut/cap/GirderCapAccumulatorTest.java

@@ -8,8 +8,10 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
@@ -58,13 +60,14 @@ void duplicateSegmentsProduceIndependentLoops() {
         accumulator.addSegments(null, 1, true, segments);
 
         List<GirderCapAccumulator.CapLoop> loops = accumulator.buildLoops(PLANE_POINT, PLANE_NORMAL);
-        assertEquals(2, loops.size(), "duplicated segments should trace two separate loops");
+        assertEquals(1, loops.size(), "duplicated segments with identical attributes collapse to a single loop");
 
         Set<Vector3f> expected = collectProjectedPositions(baseSegments, PLANE_POINT, PLANE_NORMAL);
-        for (GirderCapAccumulator.CapLoop loop : loops) {
-            assertEquals(4, loop.vertices().size(), "each loop should contain the square corners");
-            assertVerticesMatch(loop.vertices(), expected);
-        }
+        GirderCapAccumulator.CapLoop loop = loops.getFirst();
+        assertEquals(4, loop.vertices().size(), "loop should contain the square corners");
+        assertVerticesMatch(loop.vertices(), expected);
+        assertPositiveArea(loop.vertices());
+        assertAllProjectedVerticesCovered(loops, segments, PLANE_POINT, PLANE_NORMAL);
     }
 
     @Test
@@ -101,7 +104,9 @@ void complexSegmentSetProducesExpectedCoverage() {
         for (GirderCapAccumulator.CapLoop loop : loops) {
             assertFalse(loop.vertices().isEmpty(), "loop should contain vertices");
             assertVerticesMatch(loop.vertices(), expected);
+            assertPositiveArea(loop.vertices());
         }
+        assertAllProjectedVerticesCovered(loops, segments, planePoint, PLANE_NORMAL);
     }
 
     private static void assertVerticesMatch(List<GirderCapAccumulator.CapVertex> vertices, Set<Vector3f> expected) {
@@ -112,6 +117,68 @@ private static void assertVerticesMatch(List<GirderCapAccumulator.CapVertex> ver
         }
     }
 
+    private static void assertAllProjectedVerticesCovered(
+        List<GirderCapAccumulator.CapLoop> loops,
+        List<GirderMeshQuad.Segment> segments,
+        Vector3f planePoint,
+        Vector3f planeNormal
+    ) {
+        Map<String, Integer> usage = new HashMap<>();
+        for (GirderMeshQuad.Segment segment : segments) {
+            increment(usage, project(segment.start().position(), planePoint, planeNormal));
+            increment(usage, project(segment.end().position(), planePoint, planeNormal));
+        }
+
+        List<Vector3f> missing = new ArrayList<>();
+        for (Map.Entry<String, Integer> entry : usage.entrySet()) {
+            if (entry.getValue() < 2) {
+                continue;
+            }
+            Vector3f position = decode(entry.getKey());
+            boolean covered = false;
+            for (GirderCapAccumulator.CapLoop loop : loops) {
+                covered = loop.vertices().stream().anyMatch(vertex -> closeEnough(position, vertex.position()));
+                if (covered) {
+                    break;
+                }
+            }
+            if (!covered) {
+                missing.add(position);
+            }
+        }
+        assertTrue(missing.isEmpty(), "projected vertices were not covered: " + missing);
+    }
+
+    private static void assertPositiveArea(List<GirderCapAccumulator.CapVertex> vertices) {
+        float area = 0f;
+        int size = vertices.size();
+        for (int i = 0; i < size; i++) {
+            Vector3f current = vertices.get(i).position();
+            Vector3f next = vertices.get((i + 1) % size).position();
+            area += (current.x * next.y) - (next.x * current.y);
+        }
+        assertTrue(Math.abs(area) > GirderGeometry.EPSILON, "loop collapsed to zero-area polygon");
+    }
+
+    private static void increment(Map<String, Integer> usage, Vector3f position) {
+        usage.merge(quantize(position), 1, Integer::sum);
+    }
+
+    private static String quantize(Vector3f position) {
+        int x = Math.round(position.x / GirderGeometry.EPSILON);
+        int y = Math.round(position.y / GirderGeometry.EPSILON);
+        int z = Math.round(position.z / GirderGeometry.EPSILON);
+        return x + ":" + y + ":" + z;
+    }
+
+    private static Vector3f decode(String key) {
+        String[] parts = key.split(":");
+        float x = Integer.parseInt(parts[0]) * GirderGeometry.EPSILON;
+        float y = Integer.parseInt(parts[1]) * GirderGeometry.EPSILON;
+        float z = Integer.parseInt(parts[2]) * GirderGeometry.EPSILON;
+        return new Vector3f(x, y, z);
+    }
+
     private static Set<Vector3f> collectProjectedPositions(
         List<GirderMeshQuad.Segment> segments,
         Vector3f planePoint,