Fix local classification bug (#26)

Author: unageek

include/kigumi/Classify_faces_locally.h

@@ -118,63 +118,60 @@ class Classify_faces_locally {
       }
     }
 
-    if (is_undefined_configuration) {
-      return {};
-    }
-
-    // Check consistency and tag rest of the faces.
-
-    // An example case of an inconsistent configuration:
-    //
-    //                 Right, Int.
-    //                    //|
-    //                    //|
-    //                    //|
-    //             /////////|/////////
-    //   Left, ??? ---------+--------- Left, Ext.
-    //          :
-    //   Should be tagged as interior according to global classification.
-
-    auto consistent = true;
-    for (auto dry_run : {true, false}) {
-      auto tag = m.data(faces_.at(k).fi).tag;
-      auto orientation = faces_.at(k).orientation;
-      // Go around and return to the starting point to check consistency.
-      for (std::size_t i = k + 1; i <= k + faces_.size(); ++i) {
-        const auto& f = faces_.at(i % faces_.size());
-        auto& f_data = m.data(f.fi);
-
-        if (f.orientation == orientation) {
-          tag = tag == Face_tag::EXTERIOR ? Face_tag::INTERIOR : Face_tag::EXTERIOR;
+    if (!is_undefined_configuration) {
+      // Check consistency and tag rest of the faces.
+
+      // An example case of an inconsistent configuration:
+      //
+      //                 Right, Int.
+      //                    //|
+      //                    //|
+      //                    //|
+      //             /////////|/////////
+      //   Left, ??? ---------+--------- Left, Ext.
+      //          :
+      //   Should be tagged as interior according to global classification.
+
+      auto consistent = true;
+      for (auto dry_run : {true, false}) {
+        auto tag = m.data(faces_.at(k).fi).tag;
+        auto orientation = faces_.at(k).orientation;
+        // Go around and return to the starting point to check consistency.
+        for (std::size_t i = k + 1; i <= k + faces_.size(); ++i) {
+          const auto& f = faces_.at(i % faces_.size());
+          auto& f_data = m.data(f.fi);
+
+          if (f.orientation == orientation) {
+            tag = tag == Face_tag::EXTERIOR ? Face_tag::INTERIOR : Face_tag::EXTERIOR;
+          }
+          orientation = f.orientation;
+
+          if (f_data.tag == Face_tag::UNKNOWN) {
+            if (!dry_run) {
+              f_data.tag = tag;
+            }
+          } else if ((f_data.tag == Face_tag::EXTERIOR || f_data.tag == Face_tag::INTERIOR) &&
+                     f_data.tag != tag) {
+            consistent = false;
+            break;
+          }
         }
-        orientation = f.orientation;
 
-        if (f_data.tag == Face_tag::UNKNOWN) {
-          if (!dry_run) {
-            f_data.tag = tag;
-          }
-        } else if ((f_data.tag == Face_tag::EXTERIOR || f_data.tag == Face_tag::INTERIOR) &&
-                   f_data.tag != tag) {
-          consistent = false;
+        if (!consistent) {
+          // Leave unknown faces to the global classifier.
           break;
         }
       }
-
-      if (!consistent) {
-        // Leave unknown faces to the global classifier.
-        break;
-      }
     }
 
-    // Propagate face tags.
+    // Propagate the tags.
 
     Warnings warnings{};
 
     for (const auto& f : faces_) {
-      auto fi = f.fi;
-      auto f_tag = m.data(fi).tag;
-      if (f_tag == Face_tag::EXTERIOR || f_tag == Face_tag::INTERIOR) {
-        warnings |= propagate_face_tags_(m, border_edges, fi);
+      const auto& f_data = m.data(f.fi);
+      if (f_data.tag != Face_tag::UNKNOWN) {
+        warnings |= propagate_face_tags_(m, border_edges, f.fi);
       }
     }
 

include/kigumi/Corefine.h

@@ -204,8 +204,8 @@ class Corefine {
     }
   }
 
-  std::vector<Edge> get_intersecting_edges() const {
-    std::vector<Edge> edges;
+  Edge_set get_intersecting_edges() const {
+    Edge_set edges;
 
     for (const auto& info : infos_) {
       auto n = info.intersections.size();
@@ -217,7 +217,7 @@ class Corefine {
         auto j = i < n - 1 ? i + 1 : 0;
         auto a = info.intersections.at(i);
         auto b = info.intersections.at(j);
-        edges.push_back(make_edge(Vertex_index{a}, Vertex_index{b}));
+        edges.insert(make_edge(Vertex_index{a}, Vertex_index{b}));
       }
     }
 

include/kigumi/Mix.h

@@ -53,8 +53,8 @@ class Mix {
 
     std::cout << "Local classification..." << std::endl;
 
-    auto intersecting_edges = corefine.get_intersecting_edges();
-    Edge_set border_edges(intersecting_edges.begin(), intersecting_edges.end());
+    auto border_edges = corefine.get_intersecting_edges();
+    std::vector<Edge> intersecting_edges(border_edges.begin(), border_edges.end());
     Warnings warnings{};
 
     parallel_do(

include/kigumi/Propagate_face_tags.h

@@ -7,7 +7,6 @@
 #include <kigumi/Warnings.h>
 
 #include <queue>
-#include <stdexcept>
 
 namespace kigumi {
 
@@ -21,10 +20,6 @@ class Propagate_face_tags {
     auto from_left = data.from_left;
     auto tag = data.tag;
 
-    if (tag != Face_tag::INTERIOR && tag != Face_tag::EXTERIOR) {
-      throw std::runtime_error("the seed face must be tagged as either interior or exterior");
-    }
-
     Warnings warnings{};
 
     queue_.push(seed);