conquer3d 0.7.3__tar.gz → 0.7.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.7.3
+Version: 0.7.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -60,9 +60,16 @@ Dynamic: license-file
 
 ---
 
+> [!NOTE]
+> The API documentation and the [documentation website](https://khoidoo.github.io/conquer3d/)
+> were written with [Claude](https://claude.ai/code). The library itself — every CUDA kernel,
+> data structure and operator — is the author's own work.
+
+---
+
 ## 🌟 Overview
 
-**Conquer3D** is an ultra-fast, GPU-native computational geometry and differentiable spatial computing library engineered in **PyTorch and CUDA**. Designed from the ground up for 3D computer vision, generative AI, neural surface reconstruction, and differentiable rendering, **Conquer3D** delivers up to **~1.0 Billion faces/second** isosurface extraction, exact CAD sharp crease preservation, and memory-efficient spatial acceleration structures.
+**Conquer3D** is an ultra-fast, GPU-native computational geometry and differentiable spatial computing library engineered in **PyTorch and CUDA**. Designed from the ground up for 3D computer vision, generative AI, neural surface reconstruction, and differentiable rendering, **Conquer3D** delivers up to **~1.3 Billion faces/second** isosurface extraction, exact CAD sharp crease preservation, and memory-efficient spatial acceleration structures.
 
 Every operator consumes and produces PyTorch tensors **in place** — no host round-trip, no format conversion — so meshing a field is an operation *inside* a training step rather than a preprocessing stage around it.
 
@@ -115,14 +122,18 @@ The API reference does not stop at the Python surface. It descends through the p
 
 ## ⚡ Benchmarks
 
-*Empirical extraction performance on **NVIDIA GeForce RTX 4090** on the **Fandisk CAD model** at **$1024^3$ resolution** (6.86M sparse vertices, 5.15M active voxels):*
+*Measured on **NVIDIA GeForce RTX 4090** (torch 2.8.0+cu128, CUDA 12.8) on the **Fandisk CAD model** at **$1024^3$ resolution** (5.15M active cells). Timed with CUDA events around the operator alone, median of 7 runs after 2 warm-ups:*
+
+| Algorithm | Mesh Output | Extracted Vertices | Extracted Faces / Quads | Latency (ms) | Throughput |
+| :--- | :--- | ---: | ---: | ---: | ---: |
+| **DMC (pure quads)** | Pure Quads | 1,716,384 | 1,716,382 | **2.51 ms** | **684M faces/s** |
+| **Dual Marching Cubes** | Triangles | 1,716,384 | 3,432,764 | **2.62 ms** | **1,311M faces/s** |
+| MC Asymptotic | Triangles | 1,716,382 | 3,432,760 | 2.71 ms | 1,267M faces/s |
+| Dual Contouring | Triangles | 1,716,384 | 3,432,764 | 3.88 ms | 884M faces/s |
+| Marching Cubes | Triangles | 1,716,382 | 3,432,760 | 7.90 ms | 434M faces/s |
+| Marching Tetrahedra | Triangles | 6,113,918 | 12,227,832 | 44.90 ms | 272M faces/s |
 
-| Algorithm | Mesh Output | Extracted Vertices | Extracted Faces / Quads | Latency (ms) | Throughput | Watertight |
-| :--- | :--- | :--- | :--- | :---: | :---: | :---: |
-| **Dual Marching Cubes (DMC)** | Triangles | **1,716,386** | **3,432,768** | **3.44 ms** | **~1.0B faces/s** | **Yes** |
-| **Dual Marching Cubes (DMC)** | Pure Quads | **1,716,386** | **1,716,384** | **3.22 ms** | **533M quads/s** | **Yes** |
-| **Dual Contouring (DC + Normals)** | Triangles | 1,716,386 | 3,432,768 | **4.79 ms** | **717M faces/s** | **Yes** |
-| **Marching Cubes Asymptotic (MCA)** | Triangles | 1,716,384 | 3,432,764 | 16.42 ms | **209M faces/s** | **Yes** |
+All figures are produced by `docs/_figures/make_benchmarks.py` and can be reproduced. Sign-mode costs, pipeline setup breakdown and memory scaling are on the **[benchmarks page](https://khoidoo.github.io/conquer3d/benchmarks.html)**.
 
 ---
 
@@ -132,7 +143,7 @@ The API reference does not stop at the Python surface. It descends through the p
 <summary><b>🔷 1. Isosurface Extraction &amp; Meshing</b></summary>
 <br>
 
-- **Dual Marching Cubes (`dmc`)**: High-throughput manifold surface extraction with pure quad $(Q, 4)$ or triangle $(F, 3)$ outputs (~1.0B faces/s).
+- **Dual Marching Cubes (`dmc`)**: High-throughput manifold surface extraction with pure quad $(Q, 4)$ or triangle $(F, 3)$ outputs (~1.3B faces/s measured).
 - **Dual Contouring (`dc`)**: Sharp CAD crease and mechanical corner preservation via GPU Quadratic Error Function (QEF) solving.
 - **Marching Cubes Asymptotic (`mca`)**: Decider-enhanced Marching Cubes resolving topological face ambiguities on-the-fly.
 - **Differentiable Poisson Surface Reconstruction (`dpsr`, `DPSR`)**: Differentiable spectral Fourier Poisson indicator field solving directly from oriented point clouds.

{conquer3d-0.7.3 → conquer3d-0.7.5}/README.md

@@ -27,9 +27,16 @@
 
 ---
 
+> [!NOTE]
+> The API documentation and the [documentation website](https://khoidoo.github.io/conquer3d/)
+> were written with [Claude](https://claude.ai/code). The library itself — every CUDA kernel,
+> data structure and operator — is the author's own work.
+
+---
+
 ## 🌟 Overview
 
-**Conquer3D** is an ultra-fast, GPU-native computational geometry and differentiable spatial computing library engineered in **PyTorch and CUDA**. Designed from the ground up for 3D computer vision, generative AI, neural surface reconstruction, and differentiable rendering, **Conquer3D** delivers up to **~1.0 Billion faces/second** isosurface extraction, exact CAD sharp crease preservation, and memory-efficient spatial acceleration structures.
+**Conquer3D** is an ultra-fast, GPU-native computational geometry and differentiable spatial computing library engineered in **PyTorch and CUDA**. Designed from the ground up for 3D computer vision, generative AI, neural surface reconstruction, and differentiable rendering, **Conquer3D** delivers up to **~1.3 Billion faces/second** isosurface extraction, exact CAD sharp crease preservation, and memory-efficient spatial acceleration structures.
 
 Every operator consumes and produces PyTorch tensors **in place** — no host round-trip, no format conversion — so meshing a field is an operation *inside* a training step rather than a preprocessing stage around it.
 
@@ -82,14 +89,18 @@ The API reference does not stop at the Python surface. It descends through the p
 
 ## ⚡ Benchmarks
 
-*Empirical extraction performance on **NVIDIA GeForce RTX 4090** on the **Fandisk CAD model** at **$1024^3$ resolution** (6.86M sparse vertices, 5.15M active voxels):*
+*Measured on **NVIDIA GeForce RTX 4090** (torch 2.8.0+cu128, CUDA 12.8) on the **Fandisk CAD model** at **$1024^3$ resolution** (5.15M active cells). Timed with CUDA events around the operator alone, median of 7 runs after 2 warm-ups:*
+
+| Algorithm | Mesh Output | Extracted Vertices | Extracted Faces / Quads | Latency (ms) | Throughput |
+| :--- | :--- | ---: | ---: | ---: | ---: |
+| **DMC (pure quads)** | Pure Quads | 1,716,384 | 1,716,382 | **2.51 ms** | **684M faces/s** |
+| **Dual Marching Cubes** | Triangles | 1,716,384 | 3,432,764 | **2.62 ms** | **1,311M faces/s** |
+| MC Asymptotic | Triangles | 1,716,382 | 3,432,760 | 2.71 ms | 1,267M faces/s |
+| Dual Contouring | Triangles | 1,716,384 | 3,432,764 | 3.88 ms | 884M faces/s |
+| Marching Cubes | Triangles | 1,716,382 | 3,432,760 | 7.90 ms | 434M faces/s |
+| Marching Tetrahedra | Triangles | 6,113,918 | 12,227,832 | 44.90 ms | 272M faces/s |
 
-| Algorithm | Mesh Output | Extracted Vertices | Extracted Faces / Quads | Latency (ms) | Throughput | Watertight |
-| :--- | :--- | :--- | :--- | :---: | :---: | :---: |
-| **Dual Marching Cubes (DMC)** | Triangles | **1,716,386** | **3,432,768** | **3.44 ms** | **~1.0B faces/s** | **Yes** |
-| **Dual Marching Cubes (DMC)** | Pure Quads | **1,716,386** | **1,716,384** | **3.22 ms** | **533M quads/s** | **Yes** |
-| **Dual Contouring (DC + Normals)** | Triangles | 1,716,386 | 3,432,768 | **4.79 ms** | **717M faces/s** | **Yes** |
-| **Marching Cubes Asymptotic (MCA)** | Triangles | 1,716,384 | 3,432,764 | 16.42 ms | **209M faces/s** | **Yes** |
+All figures are produced by `docs/_figures/make_benchmarks.py` and can be reproduced. Sign-mode costs, pipeline setup breakdown and memory scaling are on the **[benchmarks page](https://khoidoo.github.io/conquer3d/benchmarks.html)**.
 
 ---
 
@@ -99,7 +110,7 @@ The API reference does not stop at the Python surface. It descends through the p
 <summary><b>🔷 1. Isosurface Extraction &amp; Meshing</b></summary>
 <br>
 
-- **Dual Marching Cubes (`dmc`)**: High-throughput manifold surface extraction with pure quad $(Q, 4)$ or triangle $(F, 3)$ outputs (~1.0B faces/s).
+- **Dual Marching Cubes (`dmc`)**: High-throughput manifold surface extraction with pure quad $(Q, 4)$ or triangle $(F, 3)$ outputs (~1.3B faces/s measured).
 - **Dual Contouring (`dc`)**: Sharp CAD crease and mechanical corner preservation via GPU Quadratic Error Function (QEF) solving.
 - **Marching Cubes Asymptotic (`mca`)**: Decider-enhanced Marching Cubes resolving topological face ambiguities on-the-fly.
 - **Differentiable Poisson Surface Reconstruction (`dpsr`, `DPSR`)**: Differentiable spectral Fourier Poisson indicator field solving directly from oriented point clouds.

{conquer3d-0.7.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/dc_data.h

@@ -59,13 +59,20 @@ static __constant__ float dc_corner_uvw[8][3] = {
  * deterministically to one of four quadrant slots. Because adjacent cells agree on this
  * mapping, the dual quad around a shared edge is assembled consistently from all four
  * incident cells.
+ *
+ * Slots 0-3 must walk the four incident cells **counter-clockwise about the edge's own
+ * positive axis**, and all three edge families must agree on that handedness -- otherwise
+ * the faces of one family are wound backwards relative to the rest and the extracted mesh
+ * has inconsistent normals. The right-handed plane perpendicular to each axis is $(Y, Z)$
+ * for $+X$, $(Z, X)$ for $+Y$ and $(X, Y)$ for $+Z$; note that $+Y$ pairs with $(Z, X)$ and
+ * not $(X, Z)$, which is the easy mistake here.
  */
 static __constant__ int dc_edge_quadrant[12] = {
     0, // e=0 (+X) -> slot 0
     3, // e=1 (+Y) -> slot 3
-    3, // e=2 (+X) -> slot 3
+    1, // e=2 (+X) -> slot 1
     0, // e=3 (+Y) -> slot 0
-    1, // e=4 (+X) -> slot 1
+    3, // e=4 (+X) -> slot 3
     2, // e=5 (+Y) -> slot 2
     2, // e=6 (+X) -> slot 2
     1, // e=7 (+Y) -> slot 1

{conquer3d-0.7.3 → 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.3 → 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.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/dmc_data.h

@@ -79,9 +79,9 @@ static __constant__ float dmc_corner_uvw[8][3] = {
 static __constant__ int dmc_edge_quadrant[12] = {
     0, // e=0 (+X) -> slot 0
     3, // e=1 (+Y) -> slot 3
-    3, // e=2 (+X) -> slot 3
+    1, // e=2 (+X) -> slot 1
     0, // e=3 (+Y) -> slot 0
-    1, // e=4 (+X) -> slot 1
+    3, // e=4 (+X) -> slot 3
     2, // e=5 (+Y) -> slot 2
     2, // e=6 (+X) -> slot 2
     1, // e=7 (+Y) -> slot 1

{conquer3d-0.7.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/mc.cu

@@ -616,8 +616,15 @@ __global__ void interpolate_vertices_kernel(
  * @param[in] voxel_triangle_prefix_sums Device array of per-voxel output offsets.
  * @param[out] out_triangles Device array receiving triangle vertex index triples.
  * @note Launched with `NTHREADS` threads per block over a 1D grid.
- * @note Winding follows the table, giving outward-facing normals for a field that is
- * negative inside.
+ * @note The implementation is based on Bourke implementation at http://paulbourke.net/geometry/polygonise/.
+ * @note The adatation to CUDA at first is normal inconsistent where all normals are facing inwards.
+ * @note The canonical Lorensen-Cline / Bourke ::triTable is written for the convention
+ * that a corner bit is set when the corner is *below* the isolevel, and it winds each
+ * triangle so the right-hand normal points towards that below-isolevel region. For a
+ * signed distance field, below-isolevel is the *interior*, so emitting the table row
+ * verbatim yields inward-facing normals. The last two indices are therefore swapped on
+ * write, which reverses the winding and gives outward-facing normals for a field that is
+ * negative inside -- matching Dual Contouring and the rest of the library.
  */
 __global__ void assemble_triangles_kernel(
         const uint32_t num_active_voxels,
@@ -648,9 +655,11 @@ __global__ void assemble_triangles_kernel(
             uint32_t v1 = voxel_edge_to_vert_idx[active_voxel_idx * 12 + edge1];
             uint32_t v2 = voxel_edge_to_vert_idx[active_voxel_idx * 12 + edge2];
 
+            // Reversed winding: see the note above. The table's own order points the
+            // normal into the solid for a negative-inside field.
             out_triangles[(start_tri_idx + tri_count) * 3 + 0] = v0;
-            out_triangles[(start_tri_idx + tri_count) * 3 + 1] = v1;
-            out_triangles[(start_tri_idx + tri_count) * 3 + 2] = v2;
+            out_triangles[(start_tri_idx + tri_count) * 3 + 1] = v2;
+            out_triangles[(start_tri_idx + tri_count) * 3 + 2] = v1;
             
             tri_count++;
         }

{conquer3d-0.7.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/mca.cu

@@ -310,8 +310,8 @@ __global__ void generate_edges_and_triangles_mca_kernel(
         for (int t = 0; t < 5 && tri_edges[t * 3] != -1; ++t) {
             int local_edges[3] = {
                 tri_edges[t * 3 + 0],
-                tri_edges[t * 3 + 1],
-                tri_edges[t * 3 + 2]
+                tri_edges[t * 3 + 2],
+                tri_edges[t * 3 + 1]
             };
             #pragma unroll
             for (int e_idx = 0; e_idx < 3; ++e_idx) {

{conquer3d-0.7.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/mt_data.h

@@ -85,16 +85,16 @@ __constant__ int tetTriTable[16][7] = {
     {-1, -1, -1, -1, -1, -1, -1}, // 0x00
     { 0,  1,  2, -1, -1, -1, -1}, // 0x01
     { 0,  4,  3, -1, -1, -1, -1}, // 0x02
-    { 2,  1,  4,  4,  3,  1, -1}, // 0x03
+    { 1,  2,  4,  1,  4,  3, -1}, // 0x03
     { 1,  3,  5, -1, -1, -1, -1}, // 0x04
     { 0,  5,  2,  0,  3,  5, -1}, // 0x05
-    { 0,  4,  5,  0,  1,  5, -1}, // 0x06
-    { 2,  5,  4, -1, -1, -1, -1}, // 0x07
-    { 2,  4,  5, -1, -1, -1, -1}, // 0x08
-    { 0,  5,  4,  0,  1,  5, -1}, // 0x09
-    { 0,  2,  5,  0,  5,  3, -1}, // 0x0A
+    { 0,  4,  5,  0,  5,  1, -1}, // 0x06
+    { 2,  4,  5, -1, -1, -1, -1}, // 0x07
+    { 2,  5,  4, -1, -1, -1, -1}, // 0x08
+    { 0,  1,  5,  0,  5,  4, -1}, // 0x09
+    { 0,  5,  3,  0,  2,  5, -1}, // 0x0A
     { 1,  5,  3, -1, -1, -1, -1}, // 0x0B
-    { 2,  4,  1,  4,  1,  3, -1}, // 0x0C
+    { 1,  3,  4,  1,  4,  2, -1}, // 0x0C
     { 0,  3,  4, -1, -1, -1, -1}, // 0x0D
     { 0,  2,  1, -1, -1, -1, -1}, // 0x0E
     {-1, -1, -1, -1, -1, -1, -1}  // 0x0F

{conquer3d-0.7.3 → conquer3d-0.7.5}/conquer3d/csrc/ops/mtg_data.h

@@ -25,10 +25,10 @@ namespace mtg {
  */
 __constant__ int mtg_tets[6][4] = {
     {0, 2, 3, 7},
-    {0, 2, 6, 7},
+    {0, 2, 7, 6},
     {0, 4, 6, 7},
     {0, 6, 1, 2},
-    {0, 6, 1, 4},
+    {0, 6, 4, 1},
     {5, 6, 1, 4}
 };
 
@@ -60,16 +60,16 @@ __constant__ int mtg_triTable[16][7] = {
     {-1, -1, -1, -1, -1, -1, -1}, // 0x00
     { 0,  1,  2, -1, -1, -1, -1}, // 0x01
     { 0,  4,  3, -1, -1, -1, -1}, // 0x02
-    { 2,  1,  4,  4,  3,  1, -1}, // 0x03
+    { 1,  2,  4,  1,  4,  3, -1}, // 0x03
     { 1,  3,  5, -1, -1, -1, -1}, // 0x04
     { 0,  5,  2,  0,  3,  5, -1}, // 0x05
-    { 0,  4,  5,  0,  1,  5, -1}, // 0x06
-    { 2,  5,  4, -1, -1, -1, -1}, // 0x07
-    { 2,  4,  5, -1, -1, -1, -1}, // 0x08
-    { 0,  5,  4,  0,  1,  5, -1}, // 0x09
-    { 0,  2,  5,  0,  5,  3, -1}, // 0x0A
+    { 0,  4,  5,  0,  5,  1, -1}, // 0x06
+    { 2,  4,  5, -1, -1, -1, -1}, // 0x07
+    { 2,  5,  4, -1, -1, -1, -1}, // 0x08
+    { 0,  1,  5,  0,  5,  4, -1}, // 0x09
+    { 0,  5,  3,  0,  2,  5, -1}, // 0x0A
     { 1,  5,  3, -1, -1, -1, -1}, // 0x0B
-    { 2,  4,  1,  4,  1,  3, -1}, // 0x0C
+    { 1,  3,  4,  1,  4,  2, -1}, // 0x0C
     { 0,  3,  4, -1, -1, -1, -1}, // 0x0D
     { 0,  2,  1, -1, -1, -1, -1}, // 0x0E
     {-1, -1, -1, -1, -1, -1, -1}  // 0x0F

{conquer3d-0.7.3 → 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",