conquer3d 0.7.4__tar.gz → 0.7.6__tar.gz

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

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

{conquer3d-0.7.4 → conquer3d-0.7.6}/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.6}/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.6}/conquer3d/csrc/data_structure/mesh_bvh.cu

@@ -233,16 +233,8 @@ __global__ void filter_ray_triangle_intersections_kernel(
         float3 v2 = vertices[tri.z];
         float3 centroid = (v0 + v1 + v2) / 3.0f;
 
-        float3 ray_dir = centroid - p;
-        float dir_len = maths::norm(ray_dir);
-        if (dir_len > 1e-6f)
-        {
-            ray_dir = ray_dir / dir_len;
-        }
-        else
-        {
-            ray_dir = make_float3(1.0f, 0.0f, 0.0f);
-        }
+        float3 ray_dir = maths::normalize_safe(
+            centroid - p, make_float3(1.0f, 0.0f, 0.0f), 1e-6f);
 
         Ray ray2(p, ray_dir, 0.0f);
 
@@ -452,7 +444,7 @@ __global__ void filter_ray_triangle_intersections_kernel(
             float3 u0 = v1 - v0;
             float len2_0 = maths::dot2(u0);
             if (len2_0 > 1e-10f) {
-                float t0 = fminf(fmaxf(maths::dot(best_pt - v0, u0) / len2_0, 0.0f), 1.0f);
+                float t0 = maths::saturate(maths::dot(best_pt - v0, u0) / len2_0);
                 if (maths::dot2(v0 + t0 * u0 - best_pt) <= eps_sq) {
                     N = pseudonormal_edges[3 * best_tri_id + 0];
                     found = true;
@@ -463,7 +455,7 @@ __global__ void filter_ray_triangle_intersections_kernel(
             float3 u1 = v2 - v1;
             float len2_1 = maths::dot2(u1);
             if (len2_1 > 1e-10f) {
-                float t1 = fminf(fmaxf(maths::dot(best_pt - v1, u1) / len2_1, 0.0f), 1.0f);
+                float t1 = maths::saturate(maths::dot(best_pt - v1, u1) / len2_1);
                 if (maths::dot2(v1 + t1 * u1 - best_pt) <= eps_sq) {
                     N = pseudonormal_edges[3 * best_tri_id + 1];
                     found = true;
@@ -474,7 +466,7 @@ __global__ void filter_ray_triangle_intersections_kernel(
             float3 u2 = v0 - v2;
             float len2_2 = maths::dot2(u2);
             if (len2_2 > 1e-10f) {
-                float t2 = fminf(fmaxf(maths::dot(best_pt - v2, u2) / len2_2, 0.0f), 1.0f);
+                float t2 = maths::saturate(maths::dot(best_pt - v2, u2) / len2_2);
                 if (maths::dot2(v2 + t2 * u2 - best_pt) <= eps_sq) {
                     N = pseudonormal_edges[3 * best_tri_id + 2];
                     found = true;

{conquer3d-0.7.4 → conquer3d-0.7.6}/conquer3d/csrc/data_structure/triangle_mesh.cu

@@ -524,9 +524,9 @@ __global__ void compute_vertex_normals_kernel(
                 float3 e1 = maths::normalize(v2 - v1);
                 float3 e2 = maths::normalize(v0 - v2);
 
-                float a0 = acosf(fminf(fmaxf(-maths::dot(e0, e2), -1.0f), 1.0f));
-                float a1 = acosf(fminf(fmaxf(-maths::dot(e1, e0), -1.0f), 1.0f));
-                float a2 = acosf(fminf(fmaxf(-maths::dot(e2, e1), -1.0f), 1.0f));
+                float a0 = acosf(maths::clamp(-maths::dot(e0, e2), -1.0f, 1.0f));
+                float a1 = acosf(maths::clamp(-maths::dot(e1, e0), -1.0f, 1.0f));
+                float a2 = acosf(maths::clamp(-maths::dot(e2, e1), -1.0f, 1.0f));
 
                 if (isfinite(a0)) {
                     atomicAdd(&vertex_normals[tri.x].x, a0 * n.x);

{conquer3d-0.7.4 → conquer3d-0.7.6}/conquer3d/csrc/maths/f3x1.h

@@ -260,6 +260,40 @@ namespace maths
             fminf(fmaxf(v.z, min_val.z), max_val.z)
         );
     }
+
+    /**
+     * @brief Linear interpolation between two vectors.
+     * @details Overloads the scalar lerp() in ops.h. Interpolating along an edge is the
+     * single most repeated operation in the extraction kernels -- a crossing point, an
+     * interpolated normal, a blended colour -- and naming it keeps those sites readable.
+     * @param[in] a Vector returned at $t = 0$.
+     * @param[in] b Vector returned at $t = 1$.
+     * @param[in] t Interpolation parameter; not clamped.
+     * @return $\mathbf{a} + t\,(\mathbf{b} - \mathbf{a})$.
+     */
+    static inline __host__ __device__ float3 lerp(float3 a, float3 b, float t) {
+        return a + (b - a) * t;
+    }
+
+    /**
+     * @brief Normalises a vector, falling back when it is too short to normalise.
+     * @details normalize() divides unconditionally and yields NaN or an infinity for a
+     * degenerate input. Kernels therefore guard the division by hand, and did so with three
+     * different epsilons across the tree. This states the policy once: below @p eps the
+     * direction is meaningless, so @p fallback is returned instead.
+     * @param[in] v Vector to normalise.
+     * @param[in] fallback Direction returned when @p v is shorter than @p eps.
+     * @param[in] eps Length below which @p v is treated as degenerate.
+     * @return The unit vector along @p v, or @p fallback.
+     */
+    static inline __host__ __device__ float3 normalize_safe(
+        float3 v,
+        float3 fallback = make_float3(0.0f, 0.0f, 1.0f),
+        float eps = 1e-8f)
+    {
+        float len = norm(v);
+        return (len > eps) ? (v * (1.0f / len)) : fallback;
+    }
 }
 
 /**

conquer3d-0.7.6/conquer3d/csrc/maths/ops.h

@@ -0,0 +1,89 @@
+#ifndef OPS_H
+#define OPS_H
+
+#include <stdint.h>
+#include <cmath>
+#include <vector_types.h>
+#include <vector_functions.h>
+/**
+ * @file ops.h
+ * @brief Host fallbacks for CUDA math intrinsics, and scalar interpolation helpers.
+ *
+ * @details `rsqrt` and `rsqrtf` are device intrinsics that do not exist when a translation
+ * unit is compiled by the host compiler alone. These definitions appear only outside
+ * `__CUDACC__`, so headers shared between host and device code compile either way without
+ * `#ifdef` guards at every call site.
+ *
+ * The scalar helpers below are the counterparts of the `float3` routines in f3x1.h and
+ * overload on the same names, so `maths::clamp` and `maths::lerp` read identically whether
+ * the operand is a scalar or a vector. They live here rather than in f3x1.h because this
+ * header is included first and must not depend on the vector operators.
+ */
+
+#include <math_constants.h>
+
+#ifndef __CUDACC__
+/**
+ * @brief Reciprocal square root, double precision (host fallback).
+ * @param[in] a Value whose reciprocal square root is taken; must be positive.
+ * @return The value $1 / \sqrt{a}$.
+ * @note Defined only when not compiling with nvcc, which supplies the intrinsic.
+ */
+static inline __host__ __device__ double rsqrt(double a) {
+    return 1. / sqrt(a);
+}
+
+/**
+ * @brief Reciprocal square root, single precision (host fallback).
+ * @param[in] a Value whose reciprocal square root is taken; must be positive.
+ * @return The value $1 / \sqrt{a}$.
+ * @note Defined only when not compiling with nvcc. The device intrinsic is an
+ * approximation, so host and device results may differ in the last bits.
+ */
+static inline __host__ __device__ float rsqrtf(float a) {
+    return 1. / sqrtf(a);
+}
+#endif
+
+namespace maths
+{
+    /**
+     * @brief Confines a scalar to a range.
+     * @details Scalar overload of the `float3` clamp in f3x1.h. Spelling the two branches
+     * as one call keeps the intent legible where the bound is itself an expression.
+     * @param[in] v Value to clamp.
+     * @param[in] min_val Lower bound.
+     * @param[in] max_val Upper bound.
+     * @return @p v confined to $[\text{min\_val}, \text{max\_val}]$.
+     * @note Ordered `fmaxf(lo, fminf(hi, v))` to match the form these call sites already
+     * used. The order is irrelevant for finite input but decides which bound a NaN
+     * collapses to, so keeping it preserves the previous behaviour exactly.
+     */
+    static inline __host__ __device__ float clamp(float v, float min_val, float max_val) {
+        return fmaxf(min_val, fminf(max_val, v));
+    }
+
+    /**
+     * @brief Confines a scalar to the unit interval.
+     * @details The overwhelmingly common case of clamp(), used wherever an interpolation
+     * parameter or a normalised cell coordinate must not escape $[0, 1]$ through rounding.
+     * @param[in] v Value to clamp.
+     * @return @p v confined to $[0, 1]$.
+     */
+    static inline __host__ __device__ float saturate(float v) {
+        return fmaxf(0.0f, fminf(1.0f, v));
+    }
+
+    /**
+     * @brief Linear interpolation between two scalars.
+     * @param[in] a Value returned at $t = 0$.
+     * @param[in] b Value returned at $t = 1$.
+     * @param[in] t Interpolation parameter; not clamped.
+     * @return $a + t\,(b - a)$.
+     */
+    static inline __host__ __device__ float lerp(float a, float b, float t) {
+        return a + (b - a) * t;
+    }
+}
+
+#endif // OPS_H

{conquer3d-0.7.4 → conquer3d-0.7.6}/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,30 +231,13 @@ __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;
 }
 
-/**
- * @brief Evaluates the residual Quadratic Error Function (QEF) value at point x.
- */
-__host__ __device__ __forceinline__ float evaluate_qef_error(
-    const float3 *pts,
-    const float3 *normals,
-    int count,
-    const float3 &x
-) {
-    float error = 0.0f;
-    for (int i = 0; i < count; ++i) {
-        float d = maths::dot(normals[i], x - pts[i]);
-        error += d * d;
-    }
-    return error;
-}
-
 } // namespace maths
 
 #endif // QEF_H

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

@@ -56,11 +56,7 @@ __device__ __forceinline__ float3 compute_trilinear_normal(
                       v   * ((1.0f - u) * (s[7] - s[3]) + u * (s[6] - s[2]));
 
     float3 grad = make_float3(du / dx, dv / dy, dw / dz);
-    float len = maths::norm(grad);
-    if (len > 1e-8f) {
-        return grad * (1.0f / len);
-    }
-    return make_float3(0.0f, 0.0f, 1.0f);
+    return maths::normalize_safe(grad);
 }
 
 // Compute minimum angle of a 3D triangle in radians
@@ -91,9 +87,9 @@ __device__ __forceinline__ float triangle_min_angle(
     float cos1 = -maths::dot(e0, e1) / (l0 * l1);
     float cos2 = -maths::dot(e1, e2) / (l1 * l2);
 
-    cos0 = fmaxf(-1.0f, fminf(1.0f, cos0));
-    cos1 = fmaxf(-1.0f, fminf(1.0f, cos1));
-    cos2 = fmaxf(-1.0f, fminf(1.0f, cos2));
+    cos0 = maths::clamp(cos0, -1.0f, 1.0f);
+    cos1 = maths::clamp(cos1, -1.0f, 1.0f);
+    cos2 = maths::clamp(cos2, -1.0f, 1.0f);
 
     return fminf(acosf(cos0), fminf(acosf(cos1), acosf(cos2)));
 }
@@ -138,6 +134,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,
@@ -182,22 +180,36 @@ __global__ void compute_dual_vertices_kernel(
         // Bipolar test
         if ((s0 < iso && s1 >= iso) || (s0 >= iso && s1 < iso)) {
             float t = (iso - s0) / (s1 - s0);
-            t = fmaxf(0.0f, fminf(1.0f, t));
+            t = maths::saturate(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 = maths::lerp(p[v0], p[v1], 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;
-                float len = maths::norm(n_interp);
-                n = (len > 1e-8f) ? (n_interp * (1.0f / len)) : make_float3(0, 0, 1);
+                n = maths::normalize_safe(maths::lerp(n0, n1, t));
             } else {
-                float u = dc_corner_uvw[v0][0] + (dc_corner_uvw[v1][0] - dc_corner_uvw[v0][0]) * t;
-                float v = dc_corner_uvw[v0][1] + (dc_corner_uvw[v1][1] - dc_corner_uvw[v0][1]) * t;
-                float w = dc_corner_uvw[v0][2] + (dc_corner_uvw[v1][2] - dc_corner_uvw[v0][2]) * t;
+                float u = maths::lerp(dc_corner_uvw[v0][0], dc_corner_uvw[v1][0], t);
+                float v = maths::lerp(dc_corner_uvw[v0][1], dc_corner_uvw[v1][1], t);
+                float w = maths::lerp(dc_corner_uvw[v0][2], dc_corner_uvw[v1][2], t);
                 n = compute_trilinear_normal(u, v, w, s, dx, dy, dz);
             }
             normals[count] = n;
@@ -489,9 +501,9 @@ __global__ void compact_dual_vertices_and_colors_kernel(
         float dy = fmaxf(c_max.y - c_min.y, 1e-6f);
         float dz = fmaxf(c_max.z - c_min.z, 1e-6f);
 
-        float u = fmaxf(0.0f, fminf(1.0f, (v.x - c_min.x) / dx));
-        float val_v = fmaxf(0.0f, fminf(1.0f, (v.y - c_min.y) / dy));
-        float w = fmaxf(0.0f, fminf(1.0f, (v.z - c_min.z) / dz));
+        float u = maths::saturate((v.x - c_min.x) / dx);
+        float val_v = maths::saturate((v.y - c_min.y) / dy);
+        float w = maths::saturate((v.z - c_min.z) / dz);
 
         #pragma unroll
         for (int ch = 0; ch < num_channels; ++ch) {
@@ -665,7 +677,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 +719,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 +930,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.6}/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.6}/conquer3d/csrc/ops/dmc.cu

@@ -111,9 +111,9 @@ __device__ __forceinline__ float triangle_min_angle(
     float cos1 = -maths::dot(e0, e1) / (l0 * l1);
     float cos2 = -maths::dot(e1, e2) / (l1 * l2);
 
-    cos0 = fmaxf(-1.0f, fminf(1.0f, cos0));
-    cos1 = fmaxf(-1.0f, fminf(1.0f, cos1));
-    cos2 = fmaxf(-1.0f, fminf(1.0f, cos2));
+    cos0 = maths::clamp(cos0, -1.0f, 1.0f);
+    cos1 = maths::clamp(cos1, -1.0f, 1.0f);
+    cos2 = maths::clamp(cos2, -1.0f, 1.0f);
 
     float a0 = acosf(cos0);
     float a1 = acosf(cos1);
@@ -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,18 +438,32 @@ __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];
             float s1 = s[v1];
             float t = (iso - s0) / (s1 - s0);
-            t = fmaxf(0.0f, fminf(1.0f, t));
+            t = maths::saturate(t);
 
-            float u_e = dmc_corner_uvw[v0][0] + (dmc_corner_uvw[v1][0] - dmc_corner_uvw[v0][0]) * t;
-            float v_e = dmc_corner_uvw[v0][1] + (dmc_corner_uvw[v1][1] - dmc_corner_uvw[v0][1]) * t;
-            float w_e = dmc_corner_uvw[v0][2] + (dmc_corner_uvw[v1][2] - dmc_corner_uvw[v0][2]) * t;
+            float u_e = maths::lerp(dmc_corner_uvw[v0][0], dmc_corner_uvw[v1][0], t);
+            float v_e = maths::lerp(dmc_corner_uvw[v0][1], dmc_corner_uvw[v1][1], t);
+            float w_e = maths::lerp(dmc_corner_uvw[v0][2], dmc_corner_uvw[v1][2], t);
 
             u_sum += u_e;
             v_sum += v_e;
@@ -473,9 +489,19 @@ __global__ void dmc_extract_dual_vertices_and_edges_kernel(
             // Fast path: use precomputed inside-voxel vertex directly
             out_vertices[dual_vert_idx] = precomputed_vertices[m];
             float3 pt = precomputed_vertices[m];
-            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));
+            u = maths::saturate((pt.x - c_min.x) / dx);
+            v = maths::saturate((pt.y - c_min.y) / dy);
+            w = maths::saturate((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 = maths::saturate((pt.x - c_min.x) / dx);
+            v = maths::saturate((pt.y - c_min.y) / dy);
+            w = maths::saturate((pt.z - c_min.z) / dz);
         } else {
             // Newton-Raphson Level-Set Projection
             for (int iter = 0; iter < project_iters; ++iter) {
@@ -484,9 +510,9 @@ __global__ void dmc_extract_dual_vertices_and_edges_kernel(
                 float len_sq = grad.x * grad.x + grad.y * grad.y + grad.z * grad.z;
                 if (len_sq > 1e-8f) {
                     float step = 0.5f * (iso - f_val) / len_sq;
-                    u = fmaxf(0.0f, fminf(1.0f, u + step * grad.x));
-                    v = fmaxf(0.0f, fminf(1.0f, v + step * grad.y));
-                    w = fmaxf(0.0f, fminf(1.0f, w + step * grad.z));
+                    u = maths::saturate(u + step * grad.x);
+                    v = maths::saturate(v + step * grad.y);
+                    w = maths::saturate(w + step * grad.z);
                 }
             }
 
@@ -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.6}/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
 );
 
 /**