Update: add feature preservation in remeshing.

tatsy · tatsy · commit c141ab22f5c9 · 2021-09-07T20:43:44.000+09:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 v.0.1.1
 ---
 
+*   Add feature preservation in remeshing.
 *   Include Eigen to repo as a submodule.
 *   Update Python setup to use Poetry.
 *   Add mesh denoising via bilateral filter [Zheng et al. 2011] and L0 smoothing [He and Schaefer 2013].
diff --git a/examples/example_remesh.cpp b/examples/example_remesh.cpp
@@ -7,16 +7,17 @@ namespace mesh = tinymesh;
 
 int main(int argc, char **argv) {
     if (argc <= 1) {
-        printf("usage: %s [input mesh]\n", argv[0]);
+        printf("usage: %s [input mesh] [keep angle]\n", argv[0]);
         return 1;
     }
 
     // Load
     mesh::Mesh mesh(argv[1]);
 
     // Fill holes & remesh
+    const double keepAngle = argc > 2 ? std::atof(argv[2]) * Pi / 180.0 : 0.0;
     mesh::holeFill(mesh, Pi / 6.0);
-    mesh::remeshTriangular(mesh);
+    mesh::remeshTriangular(mesh, 0.8, 1.333, keepAngle);
 
     // Save
     const fs::path filepath = fs::canonical(fs::path(argv[1]));
diff --git a/examples/python/fill_and_fair.py b/examples/python/fill_and_fair.py
@@ -10,9 +10,9 @@ def main(filename):
     mesh = Mesh(filename)
 
     # Freeze faces
-    for i in range(mesh.num_faces()):
-        f = mesh.face(i)
-        f.set_is_static(True)
+    for i in range(mesh.num_vertices()):
+        v = mesh.vertex(i)
+        v.set_is_static(True)
 
     # Fill holes
     hole_fill(mesh, np.pi / 6.0)
diff --git a/src/pybind11.cpp b/src/pybind11.cpp
@@ -70,14 +70,13 @@ PYBIND11_MODULE(tinymesh, m) {
         .def("pos", &Vertex::pos)
         .def("set_pos", &Vertex::setPos)
         .def("is_boundary", &Vertex::isBoundary)
-        .def("is_static", &Vertex::isStatic);
+        .def("is_static", &Vertex::isStatic)
+        .def("set_is_static", &Vertex::setIsStatic);
 
     py::class_<Face, std::shared_ptr<Face>>(m, "Face")
         .def(py::init<>())
         .def("is_boundary", &Face::isBoundary)
-        .def("is_static", &Face::isStatic)
-        .def("set_is_static", &Face::setIsStatic);
-
+        .def("is_static", &Face::isStatic);
 
     /*** Smoothing ***/
 
@@ -129,7 +128,7 @@ PYBIND11_MODULE(tinymesh, m) {
           py::arg("mesh"),
           py::arg("short_length") = 0.8,
           py::arg("long_length") = 1.333,
-          py::arg("angle_thresh") = 0.2,
+          py::arg("angle_keep_less_than") = 0.0,
           py::arg("iterations") = 5);
 
     /*** Simplification ***/
diff --git a/src/tinymesh/core/face.cpp b/src/tinymesh/core/face.cpp
@@ -1,6 +1,7 @@
 #define TINYMESH_API_EXPORT
 #include "face.h"
 
+#include "vertex.h"
 #include "halfedge.h"
 
 namespace tinymesh {
@@ -12,10 +13,27 @@ bool Face::operator==(const Face &other) const {
     bool ret = true;
     ret &= (halfedge_ == other.halfedge_);
     ret &= (index_ == other.index_);
-    ret &= (isBoundary_ == other.isBoundary_);
     return ret;
 }
 
+bool Face::isBoundary() {
+    for (auto vit = this->v_begin(); vit != this->v_end(); ++vit) {
+        if (vit->isBoundary()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool Face::isStatic() {
+    for (auto vit = this->v_begin(); vit != this->v_end(); ++vit) {
+        if (vit->isStatic()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 Face::VertexIterator Face::v_begin() {
     return Face::VertexIterator(halfedge_);
 }
diff --git a/src/tinymesh/core/face.h b/src/tinymesh/core/face.h
@@ -36,21 +36,13 @@ class TINYMESH_API Face {
     int index() const {
         return index_;
     }
-    bool isBoundary() const {
-        return isBoundary_;
-    }
-    bool isStatic() const {
-        return isStatic_;
-    }
-    void setIsStatic(bool flag) {
-        isStatic_ = flag;
-    }
+
+    bool isBoundary();
+    bool isStatic();
 
 private:
     Halfedge *halfedge_ = nullptr;
     int index_ = -1;
-    bool isBoundary_ = false;
-    bool isStatic_ = false;
 
     friend class Mesh;
 };
diff --git a/src/tinymesh/core/halfedge.cpp b/src/tinymesh/core/halfedge.cpp
@@ -23,8 +23,12 @@ double Halfedge::length() const {
     return ::length(src()->pos() - dst()->pos());
 }
 
+bool Halfedge::isStatic() const {
+    return this->src()->isStatic() && this->dst()->isStatic();
+}
+
 bool Halfedge::isBoundary() const {
-    return face_->isBoundary();
+    return this->src()->isBoundary() && this->dst()->isBoundary();
 }
 
 }  // namespace tinymesh
diff --git a/src/tinymesh/core/halfedge.h b/src/tinymesh/core/halfedge.h
@@ -40,6 +40,7 @@ class TINYMESH_API Halfedge {
     Edge *edge() const { return edge_; }
     Face *face() const { return face_; }
     int index() const { return index_; }
+    bool isStatic() const;
     bool isBoundary() const;
 
 private:
diff --git a/src/tinymesh/core/mesh.cpp b/src/tinymesh/core/mesh.cpp
@@ -239,7 +239,6 @@ void Mesh::construct() {
         if (he->rev_ == nullptr) {
             auto face = new Face();
             addFace(face);
-            face->isBoundary_ = true;
 
             std::vector<Halfedge *> boundaryHalfedges;
             Halfedge *it = he.get();
@@ -273,6 +272,7 @@ void Mesh::construct() {
             const auto degree = static_cast<int>(boundaryHalfedges.size());
             for (int j = 0; j < degree; j++) {
                 const int k = (j - 1 + degree) % degree;
+                boundaryHalfedges[j]->src_->isBoundary_ = true;
                 boundaryHalfedges[j]->next_ = boundaryHalfedges[k];
             }
         }
@@ -289,13 +289,10 @@ void Mesh::construct() {
             FatalError("Some vertices are not referenced by any polygon!");
         }
 
-        uint32_t count = 0;
+        uint32_t count = v->isBoundary() ? -1 : 0;
         Halfedge *he = v->halfedge_;
         do {
-            if (!he->face()->isBoundary()) {
-                count += 1;
-            }
-
+            count += 1;
             he = he->rev()->next();
         } while (he != v->halfedge_);
 
@@ -897,7 +894,6 @@ bool Mesh::triangulate(Face *face, double dihedralBound) {
      * Different from them, the triangularion is performed when the dihedral
      * angle in resulting triangularion is less than "dihedralBound".
      */
-
     using E = IndexPair;
     using T = std::tuple<uint32_t, uint32_t, uint32_t>;
 
@@ -1097,6 +1093,7 @@ bool Mesh::triangulate(Face *face, double dihedralBound) {
                 }
             }
 
+            he->src_->isBoundary_ = false;
             he = he->next_;
         } while (he != f->halfedge_);
     }
diff --git a/src/tinymesh/core/vec.h b/src/tinymesh/core/vec.h
@@ -255,11 +255,17 @@ Float dihedral(const Vec<Float, Dims> &v1, const Vec<Float, Dims> &v2, const Vec
     using V = Vec<Float, Dims>;
     const V e12 = v2 - v1;
     const V e13 = v3 - v1;
-    const V n1 = normalize(cross(e12, e13));
+    const V n1 = cross(e12, e13);
+    const Float l1 = length(n1);
     const V e42 = v2 - v1rev;
     const V e43 = v3 - v1rev;
-    const V n4 = normalize(cross(e42, e43));
-    return std::acos(dot(n1, n4));
+    const V n4 = cross(e42, e43);
+    const Float l4 = length(n4);
+    if (l1 == 0.0 || l4 == 0.0) {
+        return 0.0;
+    }
+
+    return std::acos(dot(n1, n4) / (l1 * l4));
 }
 
 // Hash
diff --git a/src/tinymesh/core/vertex.cpp b/src/tinymesh/core/vertex.cpp
@@ -35,9 +35,7 @@ bool Vertex::operator==(const Vertex &other) const {
 int Vertex::degree() {
     int deg = 0;
     for (auto it = ohe_begin(); it != ohe_end(); ++it) {
-        if (!it->face()->isBoundary()) {
-            deg++;
-        }
+        deg++;
     }
     return deg;
 }
@@ -60,24 +58,6 @@ Vec3 Vertex::normal() {
     return normalize(norm);
 }
 
-bool Vertex::isBoundary() {
-    for (auto it = ohe_begin(); it != ohe_end(); ++it) {
-        if (it->isBoundary()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool Vertex::isStatic() {
-    for (auto it = f_begin(); it != f_end(); ++it) {
-        if (it->isStatic()) {
-            return true;
-        }
-    }
-    return false;
-}
-
 Vertex::VertexIterator Vertex::v_begin() {
     return Vertex::VertexIterator(halfedge_);
 }
diff --git a/src/tinymesh/core/vertex.h b/src/tinymesh/core/vertex.h
@@ -49,13 +49,24 @@ class TINYMESH_API Vertex {
 
     int index() const { return index_; }
 
-    bool isBoundary();
-    bool isStatic();
+    bool isBoundary() const {
+        return isBoundary_;
+    }
+
+    bool isStatic() const {
+        return isStatic_;
+    }
+
+    void setIsStatic(bool flag) {
+        isStatic_ = flag;
+    }
 
 private:
     Vec3 pos_;
     Halfedge *halfedge_ = nullptr;
     int index_ = -1;
+    bool isStatic_ = false;
+    bool isBoundary_ = false;
 
     friend class Mesh;
 };
diff --git a/src/tinymesh/parameterize/abfxx.cpp b/src/tinymesh/parameterize/abfxx.cpp
@@ -8,6 +8,7 @@
 #include <set>
 #include <queue>
 #include <map>
+#include <numeric>
 #include <unordered_map>
 
 #include "core/vertex.h"
@@ -88,9 +89,39 @@ void abfxx(Mesh &mesh, int maxiter, double epsilon) {
         }
     }
 
-    // Compute average edge length
+    // Compute distortion of each edge
     const int nFaces = (int)mesh.numFaces();
     const int nVertices = (int)mesh.numVertices();
+    std::vector<double> sumAngles(nVertices);
+    std::vector<double> sumDiheds(nVertices);
+    for (int i = 0; i < nVertices; i++) {
+        Vertex *v = mesh.vertex(i);
+        std::vector<Vec3> neighbors;
+        for (auto vit = v->v_begin(); vit != v->v_end(); ++vit) {
+            neighbors.push_back(vit->pos());
+        }
+
+        const auto nn = static_cast<int>(neighbors.size());
+        const Vec3 p0 = v->pos();
+        sumAngles[i] = 0.0;
+        sumDiheds[i] = 0.0;
+        for (int j = 0; j < nn; j++) {
+            const int k = (j + 1) % nn;
+            const int l = (j - 1 + nn) % nn;
+            const Vec3 p1 = neighbors[l];
+            const Vec3 p2 = neighbors[j];
+            const Vec3 p3 = neighbors[l];
+            const Vec3 e1 = normalize(p1 - p0);
+            const Vec3 e2 = normalize(p2 - p0);
+            sumAngles[i] += std::acos(dot(e1, e2));
+            sumDiheds[i] += dihedral(p1, p0, p2, p3);
+        }
+    }
+
+    // Select seed nodes
+
+
+    // Compute average edge length
     double avgLength = 0.0;
     for (int i = 0; i < (int)mesh.numHalfedges(); i++) {
         avgLength += mesh.halfedge(i)->length();
@@ -101,7 +132,7 @@ void abfxx(Mesh &mesh, int maxiter, double epsilon) {
     // Traverse all the angles
     std::vector<AngleData> angles;
     int count = 0;
-    for (int faceID = 0; faceID < (int)mesh.numFaces(); faceID++) {
+    for (int faceID = 0; faceID < nFaces; faceID++) {
         Face *t = mesh.face(faceID);
         std::vector<Vertex *> vs;
         for (auto vit = t->v_begin(); vit != t->v_end(); ++vit) {
diff --git a/src/tinymesh/remesh/hole_fill.cpp b/src/tinymesh/remesh/hole_fill.cpp
@@ -2,17 +2,33 @@
 #include "remesh.h"
 
 #include "core/mesh.h"
+#include "core/vertex.h"
 #include "core/face.h"
 
 namespace tinymesh {
 
 void holeFill(Mesh& mesh, double dihedralBound) {
+    std::vector<int> holeFaces;
     for (int i = 0; i < (int)mesh.numFaces(); i++) {
         Face *f = mesh.face(i);
-        if (f->isBoundary()) {
-            mesh.triangulate(f, dihedralBound);
+
+        bool isHole = true;
+        for (auto vit = f->v_begin(); vit != f->v_end(); ++vit) {
+            if (!vit->isBoundary()) {
+                isHole = false;
+                break;
+            }
+        }
+
+        if (isHole) {
+            holeFaces.push_back(i);
         }
     }
+
+    for (auto i : holeFaces) {
+        Face *f = mesh.face(i);
+        mesh.triangulate(f, dihedralBound);
+    }
 }
 
 }  // namespace tinymesh
diff --git a/src/tinymesh/remesh/remesh.cpp b/src/tinymesh/remesh/remesh.cpp
diff --git a/src/tinymesh/remesh/remesh.h b/src/tinymesh/remesh/remesh.h

Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,12 @@ double Halfedge::length() const {`
`23`	`23`	`return ::length(src()->pos() - dst()->pos());`
`24`	`24`	`}`
`25`	`25`
	`26`	`+bool Halfedge::isStatic() const {`
	`27`	`+ return this->src()->isStatic() && this->dst()->isStatic();`
	`28`	`+}`
	`29`	`+`
`26`	`30`	`bool Halfedge::isBoundary() const {`
`27`		`- return face_->isBoundary();`
	`31`	`+ return this->src()->isBoundary() && this->dst()->isBoundary();`
`28`	`32`	`}`
`29`	`33`
`30`	`34`	`} // namespace tinymesh`