Smooth By Normals (#776)

* SmoothByNormals compiles

* added ForVert

* tests pass

* added bindings

* stupid formatting...

* fix typo

* small fix

* aligned weights

Author: elalish

bindings/c/include/manifoldc.h

@@ -139,6 +139,8 @@ ManifoldManifold *manifold_mirror(void *mem, ManifoldManifold *m, float nx,
                                   float ny, float nz);
 ManifoldManifold *manifold_warp(void *mem, ManifoldManifold *m,
                                 ManifoldVec3 (*fun)(float, float, float));
+ManifoldManifold *manifold_smooth_by_normals(void *mem, ManifoldManifold *m,
+                                             int normalIdx);
 ManifoldManifold *manifold_smooth_out(void *mem, ManifoldManifold *m,
                                       float minSharpAngle, float minSmoothness);
 ManifoldManifold *manifold_refine(void *mem, ManifoldManifold *m, int refine);

bindings/c/manifoldc.cpp

@@ -300,6 +300,12 @@ ManifoldMeshGL *manifold_level_set_seq_context(
   return level_set_context(mem, sdf, bounds, edge_length, level, true, ctx);
 }
 
+ManifoldManifold *manifold_smooth_by_normals(void *mem, ManifoldManifold *m,
+                                             int normalIdx) {
+  auto smoothed = from_c(m)->SmoothByNormals(normalIdx);
+  return to_c(new (mem) Manifold(smoothed));
+}
+
 ManifoldManifold *manifold_smooth_out(void *mem, ManifoldManifold *m,
                                       float minSharpAngle,
                                       float minSmoothness) {

bindings/python/examples/all_apis.py

@@ -70,6 +70,7 @@ def all_manifold():
     b = m.bounding_box()
     m = m.calculate_curvature(4, 5)
     m = m.calculate_normals(0)
+    m = m.smooth_by_normals(0)
     m = Manifold.compose([m, m.translate((5, 0, 0))])
     m = Manifold.cube((1, 1, 1))
     m = Manifold.cylinder(1, 1)

bindings/python/manifold3d.cpp

@@ -318,6 +318,8 @@ NB_MODULE(manifold3d, m) {
       .def("calculate_normals", &Manifold::CalculateNormals,
            nb::arg("normal_idx"), nb::arg("min_sharp_angle") = 60,
            manifold__calculate_normals__normal_idx__min_sharp_angle)
+      .def("smooth_by_normals", &Manifold::SmoothByNormals,
+           nb::arg("normal_idx"), manifold__smooth_by_normals__normal_idx)
       .def("smooth_out", &Manifold::SmoothOut, nb::arg("min_sharp_angle") = 60,
            nb::arg("min_smoothness") = 0,
            manifold__smooth_out__min_sharp_angle__min_smoothness)

bindings/wasm/bindings.cpp

@@ -144,6 +144,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("_GetMeshJS", &js::GetMeshJS)
       .function("refine", &Manifold::Refine)
       .function("refineToLength", &Manifold::RefineToLength)
+      .function("smoothByNormals", &Manifold::SmoothByNormals)
       .function("smoothOut", &Manifold::SmoothOut)
       .function("_Warp", &man_js::Warp)
       .function("_SetProperties", &man_js::SetProperties)

bindings/wasm/examples/public/examples.js

@@ -221,7 +221,7 @@ export const examples = {
       const radius = 30;
       const offset = 20;
       const wiggles = 12;
-      const sharpness = 0.8;
+      const sharpness = 0.6;
       const n = 50;
 
       const positions = [];

bindings/wasm/examples/worker.test.js

@@ -116,8 +116,8 @@ suite('Examples', () => {
   test('Scallop', async () => {
     const result = await runExample('Scallop');
     expect(result.genus).to.equal(0, 'Genus');
-    expect(result.volume).to.be.closeTo(41100, 100, 'Volume');
-    expect(result.surfaceArea).to.be.closeTo(7790, 10, 'Surface Area');
+    expect(result.volume).to.be.closeTo(41500, 100, 'Volume');
+    expect(result.surfaceArea).to.be.closeTo(7880, 10, 'Surface Area');
   });
 
   test('Torus Knot', async () => {

bindings/wasm/examples/worker.ts

@@ -71,6 +71,7 @@ const manifoldMemberFunctions = [
   'mirror',
   'calculateCurvature',
   'calculateNormals',
+  'smoothByNormals',
   'smoothOut',
   'refine',
   'refineToLength',

bindings/wasm/manifold-encapsulated-types.d.ts

@@ -562,7 +562,20 @@ export class Manifold {
   /**
    * Smooths out the Manifold by filling in the halfedgeTangent vectors. The
    * geometry will remain unchanged until Refine or RefineToLength is called to
-   * interpolate the surface.
+   * interpolate the surface. This version uses the supplied vertex normal
+   * properties to define the tangent vectors.
+   *
+   * @param normalIdx The first property channel of the normals. NumProp must be
+   * at least normalIdx + 3. Any vertex where multiple normals exist and don't
+   * agree will result in a sharp edge.
+   */
+  smoothByNormals(normalIdx: number): Manifold;
+
+  /**
+   * Smooths out the Manifold by filling in the halfedgeTangent vectors. The
+   * geometry will remain unchanged until Refine or RefineToLength is called to
+   * interpolate the surface. This version uses the geometry of the triangles
+   * and pseudo-normals to define the tangent vectors.
    *
    * @param minSharpAngle degrees, default 60. Any edges with angles greater
    * than this value will remain sharp. The rest will be smoothed to G1

samples/src/scallop.cpp

@@ -25,7 +25,7 @@ Manifold Scallop() {
   constexpr float radius = 3;
   constexpr float offset = 2;
   constexpr int wiggles = 12;
-  constexpr float sharpness = 0.8;
+  constexpr float sharpness = 0.6;
 
   Mesh scallop;
   std::vector<Smoothness> sharpenedEdges;

src/manifold/include/manifold.h

@@ -245,6 +245,7 @@ class Manifold {
       int, std::function<void(float*, glm::vec3, const float*)>) const;
   Manifold CalculateCurvature(int gaussianIdx, int meanIdx) const;
   Manifold CalculateNormals(int normalIdx, float minSharpAngle = 60) const;
+  Manifold SmoothByNormals(int normalIdx) const;
   Manifold SmoothOut(float minSharpAngle = 60, float minSmoothness = 0) const;
   Manifold Refine(int) const;
   Manifold RefineToLength(float) const;

src/manifold/src/impl.h

@@ -66,6 +66,29 @@ struct Manifold::Impl {
        const std::vector<float>& propertyTolerance = {},
        bool hasFaceIDs = false);
 
+  inline void ForVert(int halfedge, std::function<void(int halfedge)> func) {
+    int current = halfedge;
+    do {
+      func(current);
+      current = NextHalfedge(halfedge_[current].pairedHalfedge);
+    } while (current != halfedge);
+  }
+
+  template <typename T>
+  void ForVert(int halfedge, std::function<T(int halfedge)> transform,
+               std::function<void(int halfedge, const T& here, const T& next)>
+                   binaryOp) {
+    T here = transform(halfedge);
+    int current = halfedge;
+    do {
+      const int nextHalfedge = NextHalfedge(halfedge_[current].pairedHalfedge);
+      const T next = transform(nextHalfedge);
+      binaryOp(current, here, next);
+      here = next;
+      current = nextHalfedge;
+    } while (current != halfedge);
+  }
+
   void CreateFaces(const std::vector<float>& propertyTolerance = {});
   void RemoveUnreferencedVerts(Vec<glm::ivec3>& triVerts);
   void InitializeOriginal();
@@ -137,13 +160,15 @@ struct Manifold::Impl {
   void SplitPinchedVerts();
 
   // smoothing.cu
+  glm::vec3 GetNormal(int halfedge, int normalIdx) const;
   std::vector<Smoothness> UpdateSharpenedEdges(
       const std::vector<Smoothness>&) const;
   Vec<bool> FlatFaces() const;
   Vec<int> VertFlatFace(const Vec<bool>&) const;
   std::vector<Smoothness> SharpenEdges(float minSharpAngle,
                                        float minSmoothness) const;
   void SetNormals(int normalIdx, float minSharpAngle);
+  void CreateTangents(int normalIdx);
   void CreateTangents(std::vector<Smoothness>);
   Vec<Barycentric> Subdivide(std::function<int(glm::vec3)>);
   void Refine(std::function<int(glm::vec3)>);

src/manifold/src/manifold.cpp

@@ -661,8 +661,8 @@ Manifold Manifold::CalculateCurvature(int gaussianIdx, int meanIdx) const {
  *
  * @param normalIdx The property channel in which to store the X
  * values of the normals. The X, Y, and Z channels will be sequential. The
- * property set will be automatically expanded to include up through normalIdx
- * + 2.
+ * property set will be automatically expanded such that NumProp will be at
+ * least normalIdx + 3.
  *
  * @param minSharpAngle Any edges with angles greater than this value will
  * remain sharp, getting different normal vector properties on each side of the
@@ -679,7 +679,26 @@ Manifold Manifold::CalculateNormals(int normalIdx, float minSharpAngle) const {
 /**
  * Smooths out the Manifold by filling in the halfedgeTangent vectors. The
  * geometry will remain unchanged until Refine or RefineToLength is called to
- * interpolate the surface.
+ * interpolate the surface. This version uses the supplied vertex normal
+ * properties to define the tangent vectors.
+ *
+ * @param normalIdx The first property channel of the normals. NumProp must be
+ * at least normalIdx + 3. Any vertex where multiple normals exist and don't
+ * agree will result in a sharp edge.
+ */
+Manifold Manifold::SmoothByNormals(int normalIdx) const {
+  auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
+  if (!IsEmpty()) {
+    pImpl->CreateTangents(normalIdx);
+  }
+  return Manifold(std::make_shared<CsgLeafNode>(pImpl));
+}
+
+/**
+ * Smooths out the Manifold by filling in the halfedgeTangent vectors. The
+ * geometry will remain unchanged until Refine or RefineToLength is called to
+ * interpolate the surface. This version uses the geometry of the triangles and
+ * pseudo-normals to define the tangent vectors.
  *
  * @param minSharpAngle degrees, default 60. Any edges with angles greater than
  * this value will remain sharp. The rest will be smoothed to G1 continuity,