elalish · pca006132 · Mar 15, 2025 · Mar 14, 2025 · Mar 14, 2025 · Mar 14, 2025
diff --git a/src/edge_op.cpp b/src/edge_op.cpp
@@ -752,6 +752,7 @@ void Manifold::Impl::SplitPinchedVerts() {
             if (local[i]) continue;
             local[i] = true;
             const int vert = halfedge_[i].startVert;
+            if (vert == -1) continue;
             size_t largest = i;
             ForVert(i, [&local, &largest](int current) {
               local[current] = true;
@@ -791,6 +792,7 @@ void Manifold::Impl::SplitPinchedVerts() {
     for (size_t i = 0; i < nbEdges; ++i) {
       if (halfedgeProcessed[i]) continue;
       int vert = halfedge_[i].startVert;
+      if (vert == -1) continue;
       if (vertProcessed[vert]) {
         vertPos_.push_back(vertPos_[vert]);
         vert = NumVert() - 1;

diff --git a/src/face_op.cpp b/src/face_op.cpp
@@ -115,9 +115,6 @@
     const vec3 normal = faceNormal_[face];
 
     if (numEdge == 3) {  // Single triangle
-      int mapping[3] = {halfedge_[firstEdge].startVert,
-                        halfedge_[firstEdge + 1].startVert,
-                        halfedge_[firstEdge + 2].startVert};
       ivec3 tri(halfedge_[firstEdge].startVert,
                 halfedge_[firstEdge + 1].startVert,
                 halfedge_[firstEdge + 2].startVert);
@@ -132,10 +129,6 @@
 
       addTri(face, tri, normal, halfedgeRef[firstEdge]);
     } else if (numEdge == 4) {  // Pair of triangles
-      int mapping[4] = {halfedge_[firstEdge].startVert,
-                        halfedge_[firstEdge + 1].startVert,
-                        halfedge_[firstEdge + 2].startVert,
-                        halfedge_[firstEdge + 3].startVert};
       const mat2x3 projection = GetAxisAlignedProjection(normal);
       auto triCCW = [&projection, this](const ivec3 tri) {
         return CCW(projection * this->vertPos_[tri[0]],
@@ -269,6 +262,10 @@
                for (const int i : {0, 1, 2}) {
                  const int edge = 3 * tri + i;
                  const int pair = halfedge_[edge].pairedHalfedge;
+                 if (pair < 0) {
+                   edgeFace[edge] = remove;
+                   return;
+                 }
                  const auto& ref = meshRelation_.triRef[tri];
                  if (ref.SameFace(meshRelation_.triRef[pair / 3])) {
                    edgeFace[edge] = remove;

diff --git a/src/impl.cpp b/src/impl.cpp
@@ -174,6 +174,10 @@
   for_each_n(autoPolicy(numTri), countAt(0), numTri,
              [&triPriority, this](int tri) {
                meshRelation_.triRef[tri].faceID = -1;
+               if (halfedge_[3 * tri].startVert < 0) {
+                 triPriority[tri] = {0, tri};
+                 return;
+               }
                const vec3 v = vertPos_[halfedge_[3 * tri].startVert];
                triPriority[tri] = {
                    length2(cross(vertPos_[halfedge_[3 * tri].endVert] - v,
@@ -189,6 +193,7 @@
     if (meshRelation_.triRef[tp.tri].faceID >= 0) continue;
 
     meshRelation_.triRef[tp.tri].faceID = tp.tri;
+    if (halfedge_[3 * tp.tri].startVert < 0) continue;
     const vec3 base = vertPos_[halfedge_[3 * tp.tri].startVert];
     const vec3 normal = faceNormal_[tp.tri];
     interiorHalfedges.resize(3);
@@ -306,25 +311,32 @@
   // Mark opposed triangles for removal - this may strand unreferenced verts
   // which are removed later by RemoveUnreferencedVerts() and Finish().
   const int numEdge = numHalfedge / 2;
-  const auto body = [&](int i, int segmentEnd) {
+
+  constexpr int removedHalfedge = -2;
+  const auto body = [&, removedHalfedge](int i, int consecutiveStart,
+                                         int segmentEnd) {
     const int pair0 = ids[i];
-    Halfedge h0 = halfedge_[pair0];
-    int k = i + numEdge;
+    Halfedge& h0 = halfedge_[pair0];
+    int k = consecutiveStart + numEdge;
     while (1) {
       const int pair1 = ids[k];
-      Halfedge h1 = halfedge_[pair1];
+      Halfedge& h1 = halfedge_[pair1];
       if (h0.startVert != h1.endVert || h0.endVert != h1.startVert) break;
       if (halfedge_[NextHalfedge(pair0)].endVert ==
           halfedge_[NextHalfedge(pair1)].endVert) {
-        h0 = {-1, -1, -1};
-        h1 = {-1, -1, -1};
+        h0.pairedHalfedge = h1.pairedHalfedge = removedHalfedge;
         // Reorder so that remaining edges pair up
         if (k != i + numEdge) std::swap(ids[i + numEdge], ids[k]);
         break;
       }
       ++k;
       if (k >= segmentEnd + numEdge) break;
     }
+    if (i + 1 == segmentEnd) return consecutiveStart;
+    Halfedge& h1 = halfedge_[ids[i + 1]];
+    if (h0.startVert == h1.startVert && h0.endVert == h1.endVert)
+      return consecutiveStart;
+    return i + 1;
   };
 
 #if MANIFOLD_PAR == 1
@@ -348,23 +360,30 @@
   for_each(ExecutionPolicy::Par, ranges.begin(), ranges.end(),
            [&](const std::pair<int, int>& range) {
              const auto [start, end] = range;
-             for (int i = start; i < end; ++i) body(i, end);
+             int consecutiveStart = start;
+             for (int i = start; i < end; ++i)
+               consecutiveStart = body(i, consecutiveStart, end);
            });
 #else
-  for (int i = 0; i < numEdge; ++i) body(i, numEdge);
+  int consecutiveStart = 0;
+  for (int i = 0; i < numEdge; ++i)
+    consecutiveStart = body(i, consecutiveStart, numEdge);
 #endif
 
   // Once sorted, the first half of the range is the forward halfedges, which
   // correspond to their backward pair at the same offset in the second half
   // of the range.
-  for_each_n(policy, countAt(0), numEdge, [this, &ids, numEdge](int i) {
-    const int pair0 = ids[i];
-    const int pair1 = ids[i + numEdge];
-    if (halfedge_[pair0].startVert >= 0) {
-      halfedge_[pair0].pairedHalfedge = pair1;
-      halfedge_[pair1].pairedHalfedge = pair0;
-    }
-  });
+  for_each_n(policy, countAt(0), numEdge,
+             [this, &ids, numEdge, removedHalfedge](int i) {
+               const int pair0 = ids[i];
+               const int pair1 = ids[i + numEdge];
+               if (halfedge_[pair0].pairedHalfedge != removedHalfedge) {
+                 halfedge_[pair0].pairedHalfedge = pair1;
+                 halfedge_[pair1].pairedHalfedge = pair0;
+               } else {
+                 halfedge_[pair0] = halfedge_[pair1] = {-1, -1, -1};
+               }
+             });
 }
 
 /**
@@ -511,6 +530,7 @@
   });
 
   auto atomicMin = [&vertHalfedgeMap](int value, int vert) {
+    if (vert < 0) return;
     int old = std::numeric_limits<int>::max();
     while (!vertHalfedgeMap[vert].compare_exchange_strong(old, value))
       if (old < value) break;
@@ -520,6 +540,10 @@
     calculateTriNormal = true;
     for_each_n(policy, countAt(0), NumTri(), [&](const int face) {
       vec3& triNormal = faceNormal_[face];
+      if (halfedge_[3 * face].startVert < 0) {
+        triNormal = vec3(0, 0, 1);
+        return;
+      }
 
       ivec3 triVerts;
       for (int i : {0, 1, 2}) {

diff --git a/test/manifold_test.cpp b/test/manifold_test.cpp
@@ -117,6 +117,55 @@ TEST(Manifold, InvalidInput6) {
   EXPECT_EQ(tet.Status(), Manifold::Error::VertexOutOfBounds);
 }
 
+TEST(Manifold, OppositeFace) {
+  MeshGL gl;
+  gl.vertProperties = {
+      0, 0, 0,  //
+      1, 0, 0,  //
+      0, 1, 0,  //
+      1, 1, 0,  //
+      0, 0, 1,  //
+      1, 0, 1,  //
+      0, 1, 1,  //
+      1, 1, 1,  //
+      //
+      2, 0, 0,  //
+      2, 1, 0,  //
+      2, 0, 1,  //
+      2, 1, 1,  //
+  };
+  gl.triVerts = {
+      0, 1,  4,   //
+      0, 2,  3,   //
+      0, 3,  1,   //
+      0, 4,  2,   //
+      1, 3,  5,   //
+      1, 3,  9,   //
+      1, 5,  3,   //
+      1, 5,  4,   //
+      1, 8,  5,   //
+      1, 9,  8,   //
+      2, 4,  6,   //
+      2, 6,  7,   //
+      2, 7,  3,   //
+      3, 5,  7,   //
+      3, 7,  5,   //
+      3, 7,  11,  //
+      3, 11, 9,   //
+      4, 5,  6,   //
+      5, 7,  6,   //
+      5, 8,  10,  //
+      5, 10, 7,   //
+      7, 10, 11,  //
+      8, 9,  10,  //
+      9, 11, 10,  //
+  };
+  Manifold man(gl);
+  EXPECT_EQ(man.Status(), Manifold::Error::NoError);
+  EXPECT_EQ(man.NumVert(), 8);
+  EXPECT_FLOAT_EQ(man.Volume(), 2);
+}
+
 /**
  * ExpectMeshes performs a decomposition, so this test ensures that compose and
  * decompose are inverse operations.
@@ -990,4 +1039,4 @@ TEST(Manifold, MergeRefine) {
   manifold = manifold.RefineToLength(1.0);
   EXPECT_NEAR(manifold.Volume(), 31.21, 0.01);
 }
-#endif
+#endif
diff --git a/test/sdf_test.cpp b/test/sdf_test.cpp
@@ -42,7 +42,7 @@ TEST(SDF, SphereShell) {
       },
       {vec3(-1.1), vec3(1.1)}, 0.01, 0, 0.0001);
 
-  EXPECT_NEAR(sphere.Genus(), 11500, 1000);
+  EXPECT_NEAR(sphere.Genus(), 14235, 1000);
 
 #ifdef MANIFOLD_EXPORT
   if (options.exportModels)