conquer3d 0.7.4__tar.gz → 0.7.5__tar.gz

{conquer3d-0.7.4/conquer3d.egg-info → conquer3d-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.7.4
+Version: 0.7.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/binds/ops/dc.cpp

@@ -21,7 +21,9 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_cont
     std::optional<torch::Tensor> colors,
     std::optional<torch::Tensor> voxel_vertices,
     float iso,
-    bool quad_split
+    bool quad_split,
+    std::optional<torch::Tensor> edge_points,
+    std::optional<torch::Tensor> edge_normals
 ) {
     CHECK_INPUT(grid_vertices);
     CHECK_INPUT(voxels);
@@ -36,6 +38,20 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_cont
     if (voxel_vertices.has_value() && voxel_vertices.value().defined()) {
         CHECK_INPUT(voxel_vertices.value());
     }
+    if (edge_points.has_value() && edge_points.value().defined()) {
+        CHECK_INPUT(edge_points.value());
+        TORCH_CHECK(edge_points.value().dim() == 3 && edge_points.value().size(1) == 12 && edge_points.value().size(2) == 3,
+                    "edge_points must have shape (M, 12, 3)");
+        TORCH_CHECK(edge_points.value().size(0) == voxels.size(0),
+                    "edge_points must have one row per voxel");
+    }
+    if (edge_normals.has_value() && edge_normals.value().defined()) {
+        CHECK_INPUT(edge_normals.value());
+        TORCH_CHECK(edge_normals.value().dim() == 3 && edge_normals.value().size(1) == 12 && edge_normals.value().size(2) == 3,
+                    "edge_normals must have shape (M, 12, 3)");
+        TORCH_CHECK(edge_normals.value().size(0) == voxels.size(0),
+                    "edge_normals must have one row per voxel");
+    }
 
     return conquer3d::ops::dual_contouring(
         grid_vertices,
@@ -45,7 +61,9 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_cont
         colors,
         voxel_vertices,
         iso,
-        quad_split
+        quad_split,
+        edge_points,
+        edge_normals
     );
 }
 
@@ -106,6 +124,7 @@ void bind_ops_dc(py::module &m) {
           py::arg("grid_normals") = py::none(), py::arg("colors") = py::none(),
           py::arg("voxel_vertices") = py::none(),
           py::arg("iso") = 0.0f, py::arg("quad_split") = true,
+          py::arg("edge_points") = py::none(), py::arg("edge_normals") = py::none(),
           R"pbdoc(
           Extracts a sharp-feature preserving surface mesh using Dual Contouring with GPU QEF solver (Ju et al. 2002) or precomputed voxel vertices.
 

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/binds/ops/dmc.cpp

@@ -21,7 +21,9 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_marc
     std::optional<torch::Tensor> voxel_vertices,
     float iso,
     bool quad_split,
-    int project_iters
+    int project_iters,
+    std::optional<torch::Tensor> edge_points,
+    std::optional<torch::Tensor> edge_normals
 ) {
     CHECK_INPUT(grid_vertices);
     CHECK_INPUT(voxels);
@@ -33,6 +35,15 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_marc
     if (voxel_vertices.has_value() && voxel_vertices.value().defined()) {
         CHECK_INPUT(voxel_vertices.value());
     }
+    for (auto *t : {&edge_points, &edge_normals}) {
+        if (t->has_value() && t->value().defined()) {
+            CHECK_INPUT(t->value());
+            TORCH_CHECK(t->value().dim() == 3 && t->value().size(1) == 12 && t->value().size(2) == 3,
+                        "edge_points/edge_normals must have shape (M, 12, 3)");
+            TORCH_CHECK(t->value().size(0) == voxels.size(0),
+                        "edge_points/edge_normals must have one row per voxel");
+        }
+    }
 
     return conquer3d::ops::dual_marching_cubes(
         grid_vertices,
@@ -42,7 +53,9 @@ std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> dual_marc
         voxel_vertices,
         iso,
         quad_split,
-        project_iters
+        project_iters,
+        edge_points,
+        edge_normals
     );
 }
 
@@ -99,6 +112,7 @@ void bind_ops_dmc(py::module &m) {
           py::arg("grid_vertices"), py::arg("voxels"), py::arg("sdf"),
           py::arg("colors") = py::none(), py::arg("voxel_vertices") = py::none(),
           py::arg("iso") = 0.0f, py::arg("quad_split") = true, py::arg("project_iters") = 5,
+          py::arg("edge_points") = py::none(), py::arg("edge_normals") = py::none(),
           R"pbdoc(
           Extracts a watertight 2-manifold surface mesh using Differentiable Dual Marching Cubes (Schaefer & Warren 2004) or precomputed voxel vertices.
 

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/maths/qef.h

@@ -144,6 +144,7 @@ __host__ __device__ __forceinline__ void symmetric_eigen_3x3(
  * @param cell_min Minimum AABB coordinate of the voxel cell.
  * @param cell_max Maximum AABB coordinate of the voxel cell.
  * @param svd_tolerance Relative eigenvalue threshold for pseudoinverse (default: 0.01).
+ * @param cell_expand Scale applied to the cell half-extents before clamping (default: 2.0).
  * @return Optimal inner vertex position x*.
  */
 __host__ __device__ __forceinline__ float3 solve_qef(
@@ -152,12 +153,18 @@ __host__ __device__ __forceinline__ float3 solve_qef(
     int count,
     const float3 &cell_min,
     const float3 &cell_max,
-    float svd_tolerance = 0.01f
+    float svd_tolerance = 0.01f,
+    float cell_expand = 2.0f
 ) {
     if (count <= 0) {
         return (cell_min + cell_max) * 0.5f;
     }
 
+    const float3 cell_centre = (cell_min + cell_max) * 0.5f;
+    const float3 cell_half = (cell_max - cell_min) * (0.5f * cell_expand);
+    const float3 clamp_min = cell_centre - cell_half;
+    const float3 clamp_max = cell_centre + cell_half;
+
     // 1. Compute Mass Point (Centroid)
     float3 mass_point = make_float3(0.0f, 0.0f, 0.0f);
     for (int i = 0; i < count; ++i) {
@@ -166,7 +173,7 @@ __host__ __device__ __forceinline__ float3 solve_qef(
     mass_point = mass_point * (1.0f / (float)count);
 
     if (count == 1) {
-        return maths::clamp(pts[0], cell_min, cell_max);
+        return maths::clamp(pts[0], clamp_min, clamp_max);
     }
 
     // 2. Build Shifted Normal Equation System: (A^T A) y = b_tilde
@@ -224,9 +231,9 @@ __host__ __device__ __forceinline__ float3 solve_qef(
         y = y + v2 * proj;
     }
 
-    // 5. Unshift and Clamp to Voxel AABB
+    // 5. Unshift and Clamp to the (optionally widened) Voxel AABB
     float3 x = mass_point + y;
-    x = maths::clamp(x, cell_min, cell_max);
+    x = maths::clamp(x, clamp_min, clamp_max);
 
     return x;
 }

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/ops/dc.cu

@@ -138,6 +138,8 @@ __global__ void compute_dual_vertices_kernel(
     const int *__restrict__ voxels,
     const float *__restrict__ sdf,
     const float3 *__restrict__ grid_normals,
+    const float3 *__restrict__ edge_points,
+    const float3 *__restrict__ edge_normals,
     float iso,
     int num_voxels,
     float3 *__restrict__ dual_vertices,
@@ -184,11 +186,27 @@ __global__ void compute_dual_vertices_kernel(
             float t = (iso - s0) / (s1 - s0);
             t = fmaxf(0.0f, fminf(1.0f, t));
 
-            float3 pt = p[v0] + (p[v1] - p[v0]) * t;
+            float3 pt;
+            float3 n;
+            bool have_hermite = (edge_points != nullptr && edge_normals != nullptr);
+            if (have_hermite) {
+                pt = edge_points[m * 12 + e];
+                float3 hn = edge_normals[m * 12 + e];
+                float hlen = maths::norm(hn);
+                if (hlen > 1e-8f) {
+                    n = hn * (1.0f / hlen);
+                } else {
+                    have_hermite = false;
+                }
+            }
+            if (!have_hermite) {
+                pt = p[v0] + (p[v1] - p[v0]) * t;
+            }
             pts[count] = pt;
 
-            float3 n;
-            if (grid_normals != nullptr) {
+            if (have_hermite) {
+                // normal already set from the supplied Hermite data
+            } else if (grid_normals != nullptr) {
                 float3 n0 = grid_normals[c_idx[v0]];
                 float3 n1 = grid_normals[c_idx[v1]];
                 float3 n_interp = n0 + (n1 - n0) * t;
@@ -665,7 +683,9 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_contouring(
     const c10::optional<at::Tensor> &colors,
     const c10::optional<at::Tensor> &voxel_vertices,
     float iso,
-    bool quad_split
+    bool quad_split,
+    const c10::optional<at::Tensor> &edge_points,
+    const c10::optional<at::Tensor> &edge_normals
 ) {
     at::cuda::CUDAGuard device_guard(grid_vertices.device());
     auto allocator = at::cuda::ThrustAllocator();
@@ -705,12 +725,18 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_contouring(
         dual_vertices = at::empty({num_voxels, 3}, grid_vertices.options());
         source_dual_vertices_ptr = reinterpret_cast<const float3*>(dual_vertices.data_ptr<float>());
         const float3 *normals_ptr = grid_normals.has_value() ? reinterpret_cast<const float3*>(grid_normals.value().data_ptr<float>()) : nullptr;
+        const float3 *ep_ptr = (edge_points.has_value() && edge_points.value().defined() && edge_points.value().numel() > 0)
+            ? reinterpret_cast<const float3*>(edge_points.value().data_ptr<float>()) : nullptr;
+        const float3 *en_ptr = (edge_normals.has_value() && edge_normals.value().defined() && edge_normals.value().numel() > 0)
+            ? reinterpret_cast<const float3*>(edge_normals.value().data_ptr<float>()) : nullptr;
 
         compute_dual_vertices_kernel<<<blocks, threads, 0, at::cuda::getCurrentCUDAStream()>>>(
             reinterpret_cast<const float3*>(grid_vertices.data_ptr<float>()),
             voxels.data_ptr<int>(),
             sdf.data_ptr<float>(),
             normals_ptr,
+            ep_ptr,
+            en_ptr,
             iso,
             num_voxels,
             reinterpret_cast<float3*>(dual_vertices.data_ptr<float>()),
@@ -910,6 +936,8 @@ std::tuple<at::Tensor, c10::optional<at::Tensor>> dual_contouring_backward(
         voxels.data_ptr<int>(),
         sdf.data_ptr<float>(),
         normals_ptr,
+        nullptr,
+        nullptr,
         iso,
         num_voxels,
         reinterpret_cast<float3*>(dual_vertices.data_ptr<float>()),

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/ops/dc.h

@@ -30,7 +30,9 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_contouring(
     const c10::optional<at::Tensor> &colors = c10::nullopt,
     const c10::optional<at::Tensor> &voxel_vertices = c10::nullopt,
     float iso = 0.0f,
-    bool quad_split = true
+    bool quad_split = true,
+    const c10::optional<at::Tensor> &edge_points = c10::nullopt,
+    const c10::optional<at::Tensor> &edge_normals = c10::nullopt
 );
 
 /**

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/ops/dmc.cu

@@ -368,6 +368,8 @@ __global__ void dmc_extract_dual_vertices_and_edges_kernel(
     const float *__restrict__ sdf,
     const float *__restrict__ colors,
     const float3 *__restrict__ precomputed_vertices,
+    const float3 *__restrict__ edge_points,
+    const float3 *__restrict__ edge_normals,
     int num_channels,
     const int *__restrict__ vert_offsets,
     const int *__restrict__ edge_offsets,
@@ -436,8 +438,22 @@ __global__ void dmc_extract_dual_vertices_and_edges_kernel(
         int dual_vert_idx = v_base + c;
         float u_sum = 0.0f, v_sum = 0.0f, w_sum = 0.0f;
 
+        const bool use_hermite = (edge_points != nullptr && edge_normals != nullptr);
+        float3 h_pts[12];
+        float3 h_nrm[12];
+        int h_count = 0;
+
         for (int i = 0; i < sz; ++i) {
             int e = c_edges[c][i];
+            if (use_hermite && h_count < 12) {
+                float3 hn = edge_normals[m * 12 + e];
+                float hlen = maths::norm(hn);
+                if (hlen > 1e-8f) {
+                    h_pts[h_count] = edge_points[m * 12 + e];
+                    h_nrm[h_count] = hn * (1.0f / hlen);
+                    h_count++;
+                }
+            }
             int v0 = dmc_edge_corners[e][0];
             int v1 = dmc_edge_corners[e][1];
             float s0 = s[v0];
@@ -476,6 +492,16 @@ __global__ void dmc_extract_dual_vertices_and_edges_kernel(
             u = fmaxf(0.0f, fminf(1.0f, (pt.x - c_min.x) / dx));
             v = fmaxf(0.0f, fminf(1.0f, (pt.y - c_min.y) / dy));
             w = fmaxf(0.0f, fminf(1.0f, (pt.z - c_min.z) / dz));
+        } else if (use_hermite && h_count > 0) {
+            // Solve the quadratic error function over THIS contour's Hermite data.
+            // Restricting the solve to one contour is what keeps a cell that carries
+            // several contours emitting several distinct vertices, so the manifold
+            // guarantee survives while each vertex still lands on its own feature.
+            float3 pt = maths::solve_qef(h_pts, h_nrm, h_count, c_min, c_max, 0.01f);
+            out_vertices[dual_vert_idx] = pt;
+            u = fmaxf(0.0f, fminf(1.0f, (pt.x - c_min.x) / dx));
+            v = fmaxf(0.0f, fminf(1.0f, (pt.y - c_min.y) / dy));
+            w = fmaxf(0.0f, fminf(1.0f, (pt.z - c_min.z) / dz));
         } else {
             // Newton-Raphson Level-Set Projection
             for (int iter = 0; iter < project_iters; ++iter) {
@@ -802,7 +828,9 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_marching_cube
     const c10::optional<at::Tensor> &voxel_vertices,
     float iso,
     bool quad_split,
-    int project_iters
+    int project_iters,
+    const c10::optional<at::Tensor> &edge_points,
+    const c10::optional<at::Tensor> &edge_normals
 ) {
     TORCH_CHECK(grid_vertices.is_cuda(), "grid_vertices must be a CUDA tensor");
     TORCH_CHECK(voxels.is_cuda(), "voxels must be a CUDA tensor");
@@ -889,12 +917,19 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_marching_cube
         ? reinterpret_cast<const float3*>(voxel_vertices->data_ptr<float>())
         : nullptr;
 
+    const float3 *dmc_ep_ptr = (edge_points.has_value() && edge_points->defined() && edge_points->numel() > 0)
+        ? reinterpret_cast<const float3*>(edge_points->data_ptr<float>()) : nullptr;
+    const float3 *dmc_en_ptr = (edge_normals.has_value() && edge_normals->defined() && edge_normals->numel() > 0)
+        ? reinterpret_cast<const float3*>(edge_normals->data_ptr<float>()) : nullptr;
+
     dmc_extract_dual_vertices_and_edges_kernel<<<grid, block, 0, stream>>>(
         reinterpret_cast<const float3*>(grid_vertices.data_ptr<float>()),
         voxels.data_ptr<int>(),
         sdf.data_ptr<float>(),
         colors_ptr,
         precomputed_ptr,
+        dmc_ep_ptr,
+        dmc_en_ptr,
         num_channels,
         vert_offsets.data_ptr<int>(),
         edge_offsets.data_ptr<int>(),

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/csrc/ops/dmc.h

@@ -29,7 +29,9 @@ std::tuple<at::Tensor, at::Tensor, c10::optional<at::Tensor>> dual_marching_cube
     const c10::optional<at::Tensor> &voxel_vertices = c10::nullopt,
     float iso = 0.0f,
     bool quad_split = true,
-    int project_iters = 5
+    int project_iters = 5,
+    const c10::optional<at::Tensor> &edge_points = c10::nullopt,
+    const c10::optional<at::Tensor> &edge_normals = c10::nullopt
 );
 
 /**

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/ops/__init__.py

@@ -13,6 +13,7 @@ This package provides:
 from .marching_cubes import marching_cubes
 from .marching_cubes_asymptotic import marching_cubes_asymptotic, mca
 from .dual_contouring import dual_contouring, dc
+from .hermite import compute_hermite_from_mesh, compute_hermite_from_field, DC_EDGE_CORNERS
 from .dual_marching_cubes import dual_marching_cubes, dmc
 from .diff_marching_cubes import diff_marching_cubes
 
@@ -31,6 +32,9 @@ __all__ = [
     "mca",
     "dual_contouring",
     "dc",
+    "compute_hermite_from_mesh",
+    "compute_hermite_from_field",
+    "DC_EDGE_CORNERS",
     "dual_marching_cubes",
     "dmc",
     "diff_marching_cubes",

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/ops/dual_contouring.py

@@ -97,7 +97,9 @@ def dual_contouring(
     colors: Optional[torch.Tensor] = None,
     voxel_vertices: Optional[torch.Tensor] = None,
     iso: float = 0.0,
-    quad_split: bool = True
+    quad_split: bool = True,
+    edge_points: Optional[torch.Tensor] = None,
+    edge_normals: Optional[torch.Tensor] = None
 ) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
     """Extracts sharp surface meshes from volumetric scalar fields using Differentiable Dual Contouring.
 
@@ -123,6 +125,16 @@ def dual_contouring(
         quad_split (bool, optional): If True, splits dual quadrilaterals into 2 triangles using
             the optimal Delaunay angle criterion; if False, returns quads of shape `(Q, 4)`.
             Defaults to True.
+        edge_points (torch.Tensor, optional): Float32 tensor of shape `(M, 12, 3)` giving the
+            exact surface intersection point of each voxel-local edge, in the
+            :data:`conquer3d.ops.hermite.DC_EDGE_CORNERS` order. Supplying this together with
+            `edge_normals` is what lets Dual Contouring reproduce sharp creases exactly: the
+            QEF is then built from true Hermite data instead of from normals interpolated
+            between grid vertices, which blend across a crease and round it off. Entries for
+            edges that are not sign-crossing are ignored. Defaults to None.
+        edge_normals (torch.Tensor, optional): Float32 tensor of shape `(M, 12, 3)` giving the
+            exact surface normal at each `edge_points` entry. Must accompany `edge_points`;
+            either both are used or neither. Defaults to None.
 
     Returns:
         Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
@@ -165,8 +177,22 @@ def dual_contouring(
     #         grid_vertices, voxels, sdf, grid_normals, colors, voxel_vertices, iso, quad_split
     #     )
     # else:
+    if (edge_points is None) != (edge_normals is None):
+        raise ValueError("edge_points and edge_normals must be supplied together")
+    if edge_points is not None:
+        edge_points = edge_points.contiguous().float()
+        edge_normals = edge_normals.contiguous().float()
+        for name, t in (("edge_points", edge_points), ("edge_normals", edge_normals)):
+            if not t.is_cuda:
+                raise RuntimeError(f"{name} must be on CUDA")
+            if t.shape != (voxels.shape[0], 12, 3):
+                raise ValueError(
+                    f"{name} must have shape ({voxels.shape[0]}, 12, 3), got {tuple(t.shape)}"
+                )
+
     verts, faces, out_colors = _C.dual_contouring(
-        grid_vertices, voxels, sdf, grid_normals, colors, voxel_vertices, iso, quad_split
+        grid_vertices, voxels, sdf, grid_normals, colors, voxel_vertices, iso, quad_split,
+        edge_points, edge_normals
     )
 
     if colors is None:

{conquer3d-0.7.4 → conquer3d-0.7.5}/conquer3d/ops/dual_marching_cubes.py

@@ -95,7 +95,9 @@ def dual_marching_cubes(
     voxel_vertices: Optional[torch.Tensor] = None,
     iso: float = 0.0,
     quad_split: bool = True,
-    project_iters: int = 5
+    project_iters: int = 5,
+    edge_points: Optional[torch.Tensor] = None,
+    edge_normals: Optional[torch.Tensor] = None
 ) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor, torch.Tensor, torch.Tensor]]:
     """Extracts a strictly 2-manifold surface mesh from a voxel grid using Differentiable Dual Marching Cubes.
 
@@ -120,6 +122,17 @@ def dual_marching_cubes(
         quad_split (bool, optional): If True, splits dual quadrilaterals into 2 triangles using
             the optimal Delaunay angle criterion; if False, returns quads of shape `(Q, 4)`.
             Defaults to True.
+        edge_points (torch.Tensor, optional): Float32 tensor of shape `(M, 12, 3)` giving the
+            exact surface intersection of each voxel-local edge, in
+            :data:`conquer3d.ops.hermite.DC_EDGE_CORNERS` order. Supplied together with
+            `edge_normals`, this replaces the centroid-and-projection placement with a
+            quadratic error function solved per contour, which is what lets Dual Marching
+            Cubes reproduce sharp creases instead of rounding them. Solving per contour
+            rather than per cell keeps a cell that carries several contours emitting
+            several distinct vertices, preserving the manifold guarantee. Defaults to None.
+        edge_normals (torch.Tensor, optional): Float32 tensor of shape `(M, 12, 3)` giving the
+            exact surface normal at each `edge_points` entry. Must accompany `edge_points`.
+            Defaults to None.
         project_iters (int, optional): Number of Newton-Raphson level-set projection iterations.
             Defaults to 5.
 
@@ -160,8 +173,22 @@ def dual_marching_cubes(
     #         grid_vertices, voxels, sdf, colors, voxel_vertices, iso, quad_split, project_iters
     #     )
     # else:
+    if (edge_points is None) != (edge_normals is None):
+        raise ValueError("edge_points and edge_normals must be supplied together")
+    if edge_points is not None:
+        edge_points = edge_points.contiguous().float()
+        edge_normals = edge_normals.contiguous().float()
+        for name, t in (("edge_points", edge_points), ("edge_normals", edge_normals)):
+            if not t.is_cuda:
+                raise RuntimeError(f"{name} must be on CUDA")
+            if t.shape != (voxels.shape[0], 12, 3):
+                raise ValueError(
+                    f"{name} must have shape ({voxels.shape[0]}, 12, 3), got {tuple(t.shape)}"
+                )
+
     verts, faces, out_colors = _C.dual_marching_cubes(
-        grid_vertices, voxels, sdf, colors, voxel_vertices, iso, quad_split, project_iters
+        grid_vertices, voxels, sdf, colors, voxel_vertices, iso, quad_split, project_iters,
+        edge_points, edge_normals
     )
 
     if colors is None: