CalculateNormals and Smooth (#771)

elalish · web-flow · commit c9ec16969d27 · 2024-03-19T10:29:02.000-07:00
* started implementation

* update to Vec

* refactor

* snap normals to faces

* added flat face sharpening

* added Smooth member

* Smooth working

* refactor SetNormals

* calculateNormals runs

* CalculateNormals works

* update test

* add bindings

* fix python bindings

* fix format

* Smooth -&gt; SmoothOut

* a few fixes

* weird format bug

* addressing feedback

* update docs
diff --git a/.github/workflows/check_format.yml b/.github/workflows/check_format.yml
@@ -12,7 +12,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: DoozyX/clang-format-lint-action@v0.14
+    - uses: DoozyX/clang-format-lint-action@v0.17
       with:
         source: '.'
         exclude: '*/third_party'
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -120,6 +120,7 @@
   "cmake.configureArgs": [
     "-DBUILD_SHARED_LIBS=ON",
     "-DMANIFOLD_CBIND=ON",
+    "-DMANIFOLD_PYBIND=ON",
     "-DMANIFOLD_EXPORT=ON",
     "-DMANIFOLD_DEBUG=ON",
     "-DMANIFOLD_PAR=TBB",
diff --git a/bindings/c/include/manifoldc.h b/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_out(void *mem, ManifoldManifold *m,
+                                      float minSharpAngle, float minSmoothness);
 ManifoldManifold *manifold_refine(void *mem, ManifoldManifold *m, int refine);
 ManifoldManifold *manifold_refine_to_length(void *mem, ManifoldManifold *m,
                                             float length);
@@ -188,6 +190,9 @@ ManifoldManifold *manifold_set_properties(
     void (*fun)(float *new_prop, ManifoldVec3 position, const float *old_prop));
 ManifoldManifold *manifold_calculate_curvature(void *mem, ManifoldManifold *m,
                                                int gaussian_idx, int mean_idx);
+ManifoldManifold *manifold_calculate_normals(void *mem, ManifoldManifold *m,
+                                             int normal_idx,
+                                             int min_sharp_angle);
 
 // CrossSection Shapes/Constructors
 
diff --git a/bindings/c/manifoldc.cpp b/bindings/c/manifoldc.cpp
@@ -300,6 +300,13 @@ ManifoldMeshGL *manifold_level_set_seq_context(
   return level_set_context(mem, sdf, bounds, edge_length, level, true, ctx);
 }
 
+ManifoldManifold *manifold_smooth_out(void *mem, ManifoldManifold *m,
+                                      float minSharpAngle,
+                                      float minSmoothness) {
+  auto smoothed = from_c(m)->SmoothOut(minSharpAngle, minSmoothness);
+  return to_c(new (mem) Manifold(smoothed));
+}
+
 ManifoldManifold *manifold_refine(void *mem, ManifoldManifold *m, int refine) {
   auto refined = from_c(m)->Refine(refine);
   return to_c(new (mem) Manifold(refined));
@@ -543,6 +550,13 @@ ManifoldManifold *manifold_calculate_curvature(void *mem, ManifoldManifold *m,
   return to_c(new (mem) Manifold(man));
 }
 
+ManifoldManifold *manifold_calculate_normals(void *mem, ManifoldManifold *m,
+                                             int normal_idx,
+                                             int min_sharp_angle) {
+  auto man = from_c(m)->CalculateNormals(normal_idx, min_sharp_angle);
+  return to_c(new (mem) Manifold(man));
+}
+
 // Static Quality Globals
 
 void manifold_set_min_circular_angle(float degrees) {
diff --git a/bindings/python/examples/all_apis.py b/bindings/python/examples/all_apis.py
@@ -69,6 +69,7 @@ def all_manifold():
     m = Manifold.batch_hull([m, m.translate((0, 0, 1))])
     b = m.bounding_box()
     m = m.calculate_curvature(4, 5)
+    m = m.calculate_normals(0)
     m = Manifold.compose([m, m.translate((5, 0, 0))])
     m = Manifold.cube((1, 1, 1))
     m = Manifold.cylinder(1, 1)
@@ -92,6 +93,7 @@ def all_manifold():
     c = m.project()
     m = m.refine(2)
     m = m.refine_to_length(0.1)
+    m = m.smooth_out()
     i = Manifold.reserve_ids(1)
     m = m.scale((1, 2, 3))
     m = m.set_properties(3, lambda pos, prop: pos)
diff --git a/bindings/python/manifold3d.cpp b/bindings/python/manifold3d.cpp
@@ -315,6 +315,12 @@ NB_MODULE(manifold3d, m) {
       .def("calculate_curvature", &Manifold::CalculateCurvature,
            nb::arg("gaussian_idx"), nb::arg("mean_idx"),
            manifold__calculate_curvature__gaussian_idx__mean_idx)
+      .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_out", &Manifold::SmoothOut, nb::arg("min_sharp_angle") = 60,
+           nb::arg("min_smoothness") = 0,
+           manifold__smooth_out__min_sharp_angle__min_smoothness)
       .def("refine", &Manifold::Refine, nb::arg("n"), manifold__refine__n)
       .def("refine_to_length", &Manifold::RefineToLength, nb::arg("length"),
            manifold__refine_to_length__length)
diff --git a/bindings/wasm/bindings.cpp b/bindings/wasm/bindings.cpp
@@ -144,6 +144,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("_GetMeshJS", &js::GetMeshJS)
       .function("refine", &Manifold::Refine)
       .function("refineToLength", &Manifold::RefineToLength)
+      .function("smoothOut", &Manifold::SmoothOut)
       .function("_Warp", &man_js::Warp)
       .function("_SetProperties", &man_js::SetProperties)
       .function("transform", &man_js::Transform)
@@ -165,6 +166,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("genus", &Manifold::Genus)
       .function("getProperties", &Manifold::GetProperties)
       .function("calculateCurvature", &Manifold::CalculateCurvature)
+      .function("calculateNormals", &Manifold::CalculateNormals)
       .function("originalID", &Manifold::OriginalID)
       .function("asOriginal", &Manifold::AsOriginal);
 
diff --git a/bindings/wasm/examples/worker.test.js b/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(41284, 1, 'Volume');
-    expect(result.surfaceArea).to.be.closeTo(7810, 1, 'Surface Area');
+    expect(result.volume).to.be.closeTo(41100, 100, 'Volume');
+    expect(result.surfaceArea).to.be.closeTo(7790, 10, 'Surface Area');
   });
 
   test('Torus Knot', async () => {
diff --git a/bindings/wasm/examples/worker.ts b/bindings/wasm/examples/worker.ts
@@ -59,10 +59,29 @@ const manifoldStaticFunctions = [
 ];
 // manifold member functions (that return a new manifold)
 const manifoldMemberFunctions = [
-  'add',       'subtract',       'intersect',     'decompose',  'warp',
-  'transform', 'translate',      'rotate',        'scale',      'mirror',
-  'refine',    'refineToLength', 'setProperties', 'asOriginal', 'trimByPlane',
-  'split',     'splitByPlane',   'slice',         'project',    'hull'
+  'add',
+  'subtract',
+  'intersect',
+  'decompose',
+  'warp',
+  'transform',
+  'translate',
+  'rotate',
+  'scale',
+  'mirror',
+  'calculateCurvature',
+  'calculateNormals',
+  'smoothOut',
+  'refine',
+  'refineToLength',
+  'setProperties',
+  'asOriginal',
+  'trimByPlane',
+  'split',
+  'splitByPlane',
+  'slice',
+  'project',
+  'hull'
 ];
 // CrossSection static methods (that return a new cross-section)
 const crossSectionStaticFunctions = [
diff --git a/bindings/wasm/manifold-encapsulated-types.d.ts b/bindings/wasm/manifold-encapsulated-types.d.ts
@@ -559,6 +559,24 @@ export class Manifold {
    */
   warp(warpFunc: (vert: Vec3) => void): 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.
+   *
+   * @param minSharpAngle degrees, default 60. Any edges with angles greater
+   * than this value will remain sharp. The rest will be smoothed to G1
+   * continuity, with the caveat that flat faces of three or more triangles will
+   * always remain flat. With a value of zero, the model is faceted, but in this
+   * case there is no point in smoothing.
+   *
+   * @param minSmoothness range: 0 - 1, default 0. The smoothness applied to
+   * sharp angles. The default gives a hard edge, while values > 0 will give a
+   * small fillet on these sharp edges. A value of 1 is equivalent to a
+   * minSharpAngle of 180 - all edges will be smooth.
+   */
+  smoothOut(minSharpAngle?: number, minSmoothness?: number): Manifold;
+
   /**
    * Increase the density of the mesh by splitting every edge into n pieces. For
    * instance, with n = 2, each triangle will be split into 4 triangles. These
@@ -618,6 +636,24 @@ export class Manifold {
    */
   calculateCurvature(gaussianIdx: number, meanIdx: number): Manifold;
 
+  /**
+   * Fills in vertex properties for normal vectors, calculated from the mesh
+   * geometry. Flat faces composed of three or more triangles will remain flat.
+   *
+   * @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.
+   *
+   * @param minSharpAngle Any edges with angles greater than this value will
+   * remain sharp, getting different normal vector properties on each side of
+   * the edge. By default, no edges are sharp and all normals are shared. With a
+   * value of zero, the model is faceted and all normals match their triangle
+   * normals, but in this case it would be better not to calculate normals at
+   * all.
+   */
+  calculateNormals(normalIdx: number, minSharpAngle: number): Manifold;
+
   // Boolean Operations
 
   /**
diff --git a/src/manifold/include/manifold.h b/src/manifold/include/manifold.h
@@ -128,8 +128,8 @@ struct MeshGL {
  * potentially Mesh if only basic geometry is required.
  *
  * In addition to storing geometric data, a Manifold can also store an arbitrary
- * number of vertex properties. These could be anything, e.g. UV coordinates,
- * colors, bone weights, etc, but this library is completely agnostic. All
+ * number of vertex properties. These could be anything, e.g. normals, UV
+ * coordinates, colors, etc, but this library is completely agnostic. All
  * properties are merely float values indexed by channel number. It is up to the
  * user to associate channel numbers with meaning.
  *
@@ -244,6 +244,8 @@ class Manifold {
   Manifold SetProperties(
       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 SmoothOut(float minSharpAngle = 60, float minSmoothness = 0) const;
   Manifold Refine(int) const;
   Manifold RefineToLength(float) const;
   // Manifold RefineToPrecision(float);
diff --git a/src/manifold/src/constructors.cpp b/src/manifold/src/constructors.cpp
@@ -88,7 +88,7 @@ Manifold Manifold::Smooth(const MeshGL& meshGL,
   std::vector<float> propertyTolerance(meshGL.numProp - 3, -1);
   std::shared_ptr<Impl> impl =
       std::make_shared<Impl>(meshGL, propertyTolerance);
-  impl->CreateTangents(sharpenedEdges);
+  impl->CreateTangents(impl->UpdateSharpenedEdges(sharpenedEdges));
   return Manifold(impl);
 }
 
@@ -128,7 +128,7 @@ Manifold Manifold::Smooth(const Mesh& mesh,
 
   Impl::MeshRelationD relation = {(int)ReserveIDs(1)};
   std::shared_ptr<Impl> impl = std::make_shared<Impl>(mesh, relation);
-  impl->CreateTangents(sharpenedEdges);
+  impl->CreateTangents(impl->UpdateSharpenedEdges(sharpenedEdges));
   return Manifold(impl);
 }
 
diff --git a/src/manifold/src/impl.h b/src/manifold/src/impl.h
@@ -137,7 +137,14 @@ struct Manifold::Impl {
   void SplitPinchedVerts();
 
   // smoothing.cu
-  void CreateTangents(const std::vector<Smoothness>&);
+  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(std::vector<Smoothness>);
   Vec<Barycentric> Subdivide(std::function<int(glm::vec3)>);
   void Refine(std::function<int(glm::vec3)>);
 };
diff --git a/src/manifold/src/manifold.cpp b/src/manifold/src/manifold.cpp
@@ -655,6 +655,51 @@ Manifold Manifold::CalculateCurvature(int gaussianIdx, int meanIdx) const {
   return Manifold(std::make_shared<CsgLeafNode>(pImpl));
 }
 
+/**
+ * Fills in vertex properties for normal vectors, calculated from the mesh
+ * geometry. Flat faces composed of three or more triangles will remain flat.
+ *
+ * @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.
+ *
+ * @param minSharpAngle Any edges with angles greater than this value will
+ * remain sharp, getting different normal vector properties on each side of the
+ * edge. By default, no edges are sharp and all normals are shared. With a value
+ * of zero, the model is faceted and all normals match their triangle normals,
+ * but in this case it would be better not to calculate normals at all.
+ */
+Manifold Manifold::CalculateNormals(int normalIdx, float minSharpAngle) const {
+  auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
+  pImpl->SetNormals(normalIdx, minSharpAngle);
+  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.
+ *
+ * @param minSharpAngle degrees, default 60. Any edges with angles greater than
+ * this value will remain sharp. The rest will be smoothed to G1 continuity,
+ * with the caveat that flat faces of three or more triangles will always remain
+ * flat. With a value of zero, the model is faceted, but in this case there is
+ * no point in smoothing.
+ *
+ * @param minSmoothness range: 0 - 1, default 0. The smoothness applied to sharp
+ * angles. The default gives a hard edge, while values > 0 will give a small
+ * fillet on these sharp edges. A value of 1 is equivalent to a minSharpAngle of
+ * 180 - all edges will be smooth.
+ */
+Manifold Manifold::SmoothOut(float minSharpAngle, float minSmoothness) const {
+  auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
+  if (!IsEmpty()) {
+    pImpl->CreateTangents(pImpl->SharpenEdges(minSharpAngle, minSmoothness));
+  }
+  return Manifold(std::make_shared<CsgLeafNode>(pImpl));
+}
+
 /**
  * Increase the density of the mesh by splitting every edge into n pieces. For
  * instance, with n = 2, each triangle will be split into 4 triangles. These
diff --git a/src/manifold/src/shared.h b/src/manifold/src/shared.h
@@ -157,6 +157,10 @@ struct TriRef {
   /// The triangle index of the original triangle this was part of:
   /// Mesh.triVerts[tri].
   int tri;
+
+  bool SameFace(const TriRef& other) const {
+    return meshID == other.meshID && tri == other.tri;
+  }
 };
 
 /**
diff --git a/src/manifold/src/smoothing.cpp b/src/manifold/src/smoothing.cpp
diff --git a/test/manifold_test.cpp b/test/manifold_test.cpp
diff --git a/test/samples_test.cpp b/test/samples_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ Manifold Manifold::Smooth(const MeshGL& meshGL,`
`88`	`88`	`std::vector<float> propertyTolerance(meshGL.numProp - 3, -1);`
`89`	`89`	`std::shared_ptr<Impl> impl =`
`90`	`90`	`std::make_shared<Impl>(meshGL, propertyTolerance);`
`91`		`- impl->CreateTangents(sharpenedEdges);`
	`91`	`+ impl->CreateTangents(impl->UpdateSharpenedEdges(sharpenedEdges));`
`92`	`92`	`return Manifold(impl);`
`93`	`93`	`}`
`94`	`94`
`@@ -128,7 +128,7 @@ Manifold Manifold::Smooth(const Mesh& mesh,`
`128`	`128`
`129`	`129`	`Impl::MeshRelationD relation = {(int)ReserveIDs(1)};`
`130`	`130`	`std::shared_ptr<Impl> impl = std::make_shared<Impl>(mesh, relation);`
`131`		`- impl->CreateTangents(sharpenedEdges);`
	`131`	`+ impl->CreateTangents(impl->UpdateSharpenedEdges(sharpenedEdges));`
`132`	`132`	`return Manifold(impl);`
`133`	`133`	`}`
`134`	`134`