Refine To Length (#741)

* sketched out implementation

* started PartitionQuad

* added edge directions

* compiles

* first test passing

* minor progress

* simplify

* refactor

* fixed interior verts

* getting manifold results

* improved triangulation

* finished algorithm

* fixed fans

* a few fixes

* fixed 3-2-2

* handle reversed triangles

* use Vec

* fixed another bug

* refine working

* replaced old subdivide

* fix allocation error

* fixed sphere

* fix cache

* fixed undefined behavior

* fix rounding error

* updated test

* cleanup

* add lock

* added properties support

* tightened test

* fixed edge colors

* fixed corners

* only duplicate props when necessary

* fix boolean props

* fixed manifoldness error

* fixed some narrow triangles

* fix compile

* added bindings

* fix formatting

* addressing feedback

* revert edge divisions change

Author: elalish

.vscode/settings.json

@@ -108,7 +108,12 @@
     "latch": "cpp",
     "semaphore": "cpp",
     "span": "cpp",
-    "__sso_allocator": "cpp"
+    "__sso_allocator": "cpp",
+    "source_location": "cpp",
+    "format": "cpp",
+    "numbers": "cpp",
+    "ranges": "cpp",
+    "stop_token": "cpp"
   },
   "C_Cpp.clang_format_fallbackStyle": "google",
   "editor.formatOnSave": true,
@@ -117,7 +122,6 @@
     "-DMANIFOLD_CBIND=ON",
     "-DMANIFOLD_EXPORT=ON",
     "-DMANIFOLD_DEBUG=ON",
-    "-DMANIFOLD_USE_CUDA=OFF",
     "-DMANIFOLD_PAR=TBB",
     "-DCODE_COVERAGE=OFF",
     "-DCMAKE_CXX_FLAGS=''" //'-fsanitize=address,undefined'"

bindings/c/include/manifoldc.h

@@ -140,6 +140,8 @@ ManifoldManifold *manifold_mirror(void *mem, ManifoldManifold *m, float nx,
 ManifoldManifold *manifold_warp(void *mem, ManifoldManifold *m,
                                 ManifoldVec3 (*fun)(float, float, float));
 ManifoldManifold *manifold_refine(void *mem, ManifoldManifold *m, int refine);
+ManifoldManifold *manifold_refine_to_length(void *mem, ManifoldManifold *m,
+                                            float length);
 
 // Manifold Shapes / Constructors
 

bindings/c/manifoldc.cpp

@@ -305,6 +305,12 @@ ManifoldManifold *manifold_refine(void *mem, ManifoldManifold *m, int refine) {
   return to_c(new (mem) Manifold(refined));
 }
 
+ManifoldManifold *manifold_refine_to_length(void *mem, ManifoldManifold *m,
+                                            float length) {
+  auto refined = from_c(m)->RefineToLength(length);
+  return to_c(new (mem) Manifold(refined));
+}
+
 ManifoldManifold *manifold_empty(void *mem) {
   return to_c(new (mem) Manifold());
 }

bindings/python/examples/all_apis.py

@@ -91,6 +91,7 @@ def all_manifold():
     p = m.precision()
     c = m.project()
     m = m.refine(2)
+    m = m.refine_to_length(0.1)
     i = Manifold.reserve_ids(1)
     m = m.scale((1, 2, 3))
     m = m.set_properties(3, lambda pos, prop: pos)

bindings/python/manifold3d.cpp

@@ -316,6 +316,8 @@ NB_MODULE(manifold3d, m) {
            nb::arg("gaussian_idx"), nb::arg("mean_idx"),
            manifold__calculate_curvature__gaussian_idx__mean_idx)
       .def("refine", &Manifold::Refine, nb::arg("n"), manifold__refine__n)
+      .def("refine_to_length", &Manifold::RefineToLength, nb::arg("length"),
+           manifold__refine_to_length__length)
       .def("to_mesh", &Manifold::GetMeshGL,
            nb::arg("normal_idx") = glm::ivec3(0),
            manifold__get_mesh_gl__normal_idx)

bindings/wasm/bindings.cpp

@@ -143,6 +143,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("hull", select_overload<Manifold() const>(&Manifold::Hull))
       .function("_GetMeshJS", &js::GetMeshJS)
       .function("refine", &Manifold::Refine)
+      .function("refineToLength", &Manifold::RefineToLength)
       .function("_Warp", &man_js::Warp)
       .function("_SetProperties", &man_js::SetProperties)
       .function("transform", &man_js::Transform)

bindings/wasm/examples/worker.ts

@@ -59,9 +59,10 @@ const manifoldStaticFunctions = [
 ];
 // manifold member functions (that return a new manifold)
 const manifoldMemberFunctions = [
-  'add', 'subtract', 'intersect', 'decompose', 'warp', 'transform', 'translate',
-  'rotate', 'scale', 'mirror', 'refine', 'setProperties', 'asOriginal',
-  'trimByPlane', 'split', 'splitByPlane', 'slice', 'project', 'hull'
+  'add',       'subtract',       'intersect',     'decompose',  'warp',
+  'transform', 'translate',      'rotate',        'scale',      'mirror',
+  'refine',    'refineToLength', 'setProperties', 'asOriginal', 'trimByPlane',
+  'split',     'splitByPlane',   'slice',         'project',    'hull'
 ];
 // CrossSection static methods (that return a new cross-section)
 const crossSectionStaticFunctions = [

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

@@ -571,6 +571,18 @@ export class Manifold {
    */
   refine(n: number): Manifold;
 
+  /**
+   * Increase the density of the mesh by splitting each edge into pieces of
+   * roughly the input length. Interior verts are added to keep the rest of the
+   * triangulation edges also of roughly the same length. If halfedgeTangents
+   * are present (e.g. from the Smooth() constructor), the new vertices will be
+   * moved to the interpolated surface according to their barycentric
+   * coordinates.
+   *
+   * @param length The length that edges will be broken down to.
+   */
+  refineToLength(length: number): Manifold;
+
   /**
    * Create a new copy of this manifold with updated vertex properties by
    * supplying a function that takes the existing position and properties as

src/manifold/include/manifold.h

@@ -220,7 +220,7 @@ class Manifold {
       int, std::function<void(float*, glm::vec3, const float*)>) const;
   Manifold CalculateCurvature(int gaussianIdx, int meanIdx) const;
   Manifold Refine(int) const;
-  // Manifold RefineToLength(float);
+  Manifold RefineToLength(float) const;
   // Manifold RefineToPrecision(float);
   ///@}
 

src/manifold/src/constructors.cpp

@@ -207,7 +207,7 @@ Manifold Manifold::Sphere(float radius, int circularSegments) {
   int n = circularSegments > 0 ? (circularSegments + 3) / 4
                                : Quality::GetCircularSegments(radius) / 4;
   auto pImpl_ = std::make_shared<Impl>(Impl::Shape::Octahedron);
-  pImpl_->Subdivide(n);
+  pImpl_->Subdivide([n](glm::vec3 edge) { return n - 1; });
   for_each_n(autoPolicy(pImpl_->NumVert()), pImpl_->vertPos_.begin(),
              pImpl_->NumVert(), ToSphere({radius}));
   pImpl_->Finish();

src/manifold/src/impl.h

@@ -138,7 +138,7 @@ struct Manifold::Impl {
 
   // smoothing.cu
   void CreateTangents(const std::vector<Smoothness>&);
-  Vec<Barycentric> Subdivide(int n);
-  void Refine(int n);
+  Vec<Barycentric> Subdivide(std::function<int(glm::vec3)>);
+  void Refine(std::function<int(glm::vec3)>);
 };
 }  // namespace manifold

src/manifold/src/manifold.cpp

@@ -667,7 +667,26 @@ Manifold Manifold::CalculateCurvature(int gaussianIdx, int meanIdx) const {
  */
 Manifold Manifold::Refine(int n) const {
   auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
-  pImpl->Refine(n);
+  if (n > 1) {
+    pImpl->Refine([n](glm::vec3 edge) { return n - 1; });
+  }
+  return Manifold(std::make_shared<CsgLeafNode>(pImpl));
+}
+
+/**
+ * Increase the density of the mesh by splitting each edge into pieces of
+ * roughly the input length. Interior verts are added to keep the rest of the
+ * triangulation edges also of roughly the same length. If halfedgeTangents are
+ * present (e.g. from the Smooth() constructor), the new vertices will be moved
+ * to the interpolated surface according to their barycentric coordinates.
+ *
+ * @param length The length that edges will be broken down to.
+ */
+Manifold Manifold::RefineToLength(float length) const {
+  length = glm::abs(length);
+  auto pImpl = std::make_shared<Impl>(*GetCsgLeafNode().GetImpl());
+  pImpl->Refine(
+      [length](glm::vec3 edge) { return glm::length(edge) / length; });
   return Manifold(std::make_shared<CsgLeafNode>(pImpl));
 }