conquer3d 0.2.8__tar.gz → 0.2.9__tar.gz

{conquer3d-0.2.8/conquer3d.egg-info → conquer3d-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.8
+Version: 0.2.9
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -56,7 +56,7 @@ pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https
 pip install pybind11-stubgen
 pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 
-pip install plotly open3d jupyter trimesh
+pip install plotly open3d jupyter trimesh point-cloud-utils
 ```
 
 # Development

{conquer3d-0.2.8 → conquer3d-0.2.9}/README.md

@@ -28,7 +28,7 @@ pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https
 pip install pybind11-stubgen
 pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 
-pip install plotly open3d jupyter trimesh
+pip install plotly open3d jupyter trimesh point-cloud-utils
 ```
 
 # Development

conquer3d-0.2.9/conquer3d/csrc/binds/data_structure/grid.cpp

@@ -0,0 +1,129 @@
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <tuple>
+#include <string>
+#include <vector>
+
+namespace py = pybind11;
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> create_voxel_grid(
+    std::vector<float> grid_min,
+    std::vector<float> grid_max,
+    std::vector<int64_t> res,
+    std::string device_str
+) {
+    TORCH_CHECK(grid_min.size() == 3, "grid_min must have 3 elements.");
+    TORCH_CHECK(grid_max.size() == 3, "grid_max must have 3 elements.");
+    TORCH_CHECK(res.size() == 3, "res must have 3 elements.");
+
+    c10::Device device(device_str);
+    auto options = torch::TensorOptions().device(device).dtype(torch::kFloat32);
+
+    int64_t rx = res[0];
+    int64_t ry = res[1];
+    int64_t rz = res[2];
+
+    auto x = torch::linspace(grid_min[0], grid_max[0], rx, options);
+    auto y = torch::linspace(grid_min[1], grid_max[1], ry, options);
+    auto z = torch::linspace(grid_min[2], grid_max[2], rz, options);
+
+    auto grids = torch::meshgrid({x, y, z}, "ij");
+    auto grid_x = grids[0].flatten();
+    auto grid_y = grids[1].flatten();
+    auto grid_z = grids[2].flatten();
+    
+    auto grid_vertices = torch::stack({grid_x, grid_y, grid_z}, 1).contiguous();
+
+    auto options_int = options.dtype(torch::kInt64);
+    auto i = torch::arange(rx - 1, options_int);
+    auto j = torch::arange(ry - 1, options_int);
+    auto k = torch::arange(rz - 1, options_int);
+
+    auto idx_grids = torch::meshgrid({i, j, k}, "ij");
+    auto vi = idx_grids[0];
+    auto vj = idx_grids[1];
+    auto vk = idx_grids[2];
+
+    // Voxel connectivity indexing mapping matching mc.cu
+    auto v0 = vi * ry * rz + vj * rz + vk;
+    auto v1 = (vi + 1) * ry * rz + vj * rz + vk;
+    auto v2 = (vi + 1) * ry * rz + (vj + 1) * rz + vk;
+    auto v3 = vi * ry * rz + (vj + 1) * rz + vk;
+    auto v4 = vi * ry * rz + vj * rz + (vk + 1);
+    auto v5 = (vi + 1) * ry * rz + vj * rz + (vk + 1);
+    auto v6 = (vi + 1) * ry * rz + (vj + 1) * rz + (vk + 1);
+    auto v7 = vi * ry * rz + (vj + 1) * rz + (vk + 1);
+
+    auto voxels = torch::stack({v0, v1, v2, v3, v4, v5, v6, v7}, -1).view({-1, 8}).contiguous().to(torch::kInt32);
+
+    auto i_v = torch::arange(rx, options_int);
+    auto j_v = torch::arange(ry, options_int);
+    auto k_v = torch::arange(rz, options_int);
+    auto idx_grids_v = torch::meshgrid({i_v, j_v, k_v}, "ij");
+    auto out_idx_grids = torch::stack({idx_grids_v[0].flatten(), idx_grids_v[1].flatten(), idx_grids_v[2].flatten()}, -1).contiguous();
+
+    return std::make_tuple(grid_vertices, voxels, out_idx_grids);
+}
+
+torch::Tensor compute_grid_normal(torch::Tensor sdf, torch::Tensor grid_vertices, torch::Tensor idx_grids, std::vector<int64_t> res) {
+    TORCH_CHECK(res.size() == 3, "res must have 3 elements.");
+    
+    auto i = idx_grids.select(1, 0);
+    auto j = idx_grids.select(1, 1);
+    auto k = idx_grids.select(1, 2);
+    
+    auto rx = res[0];
+    auto ry = res[1];
+    auto rz = res[2];
+    
+    auto i_prev = torch::clamp(i - 1, 0, rx - 1);
+    auto i_next = torch::clamp(i + 1, 0, rx - 1);
+    
+    auto j_prev = torch::clamp(j - 1, 0, ry - 1);
+    auto j_next = torch::clamp(j + 1, 0, ry - 1);
+    
+    auto k_prev = torch::clamp(k - 1, 0, rz - 1);
+    auto k_next = torch::clamp(k + 1, 0, rz - 1);
+    
+    auto idx_x_prev = i_prev * ry * rz + j * rz + k;
+    auto idx_x_next = i_next * ry * rz + j * rz + k;
+    
+    auto idx_y_prev = i * ry * rz + j_prev * rz + k;
+    auto idx_y_next = i * ry * rz + j_next * rz + k;
+    
+    auto idx_z_prev = i * ry * rz + j * rz + k_prev;
+    auto idx_z_next = i * ry * rz + j * rz + k_next;
+    
+    auto sdf_flat = sdf.flatten();
+    
+    auto diff_x = sdf_flat.index_select(0, idx_x_next) - sdf_flat.index_select(0, idx_x_prev);
+    auto diff_y = sdf_flat.index_select(0, idx_y_next) - sdf_flat.index_select(0, idx_y_prev);
+    auto diff_z = sdf_flat.index_select(0, idx_z_next) - sdf_flat.index_select(0, idx_z_prev);
+
+    auto vx = grid_vertices.select(1, 0);
+    auto vy = grid_vertices.select(1, 1);
+    auto vz = grid_vertices.select(1, 2);
+
+    auto dx = vx.index_select(0, idx_x_next) - vx.index_select(0, idx_x_prev);
+    auto dy = vy.index_select(0, idx_y_next) - vy.index_select(0, idx_y_prev);
+    auto dz = vz.index_select(0, idx_z_next) - vz.index_select(0, idx_z_prev);
+
+    dx = torch::where(dx == 0, torch::tensor(1e-5f, dx.options()), dx);
+    dy = torch::where(dy == 0, torch::tensor(1e-5f, dy.options()), dy);
+    dz = torch::where(dz == 0, torch::tensor(1e-5f, dz.options()), dz);
+
+    auto grad_x = diff_x / dx;
+    auto grad_y = diff_y / dy;
+    auto grad_z = diff_z / dz;
+    
+    auto normals = torch::stack({grad_x, grad_y, grad_z}, 1);
+    return torch::nn::functional::normalize(normals, torch::nn::functional::NormalizeFuncOptions().p(2).dim(1));
+}
+
+void bind_ds_grid(py::module_& m) {
+    m.def("create_voxel_grid", &create_voxel_grid, "Creates a structured 3D voxel grid.",
+          py::arg("grid_min"), py::arg("grid_max"), py::arg("res"), py::arg("device_str") = "cuda");
+    m.def("compute_grid_normal", &compute_grid_normal, "Computes surface normals for a grid.",
+          py::arg("sdf"), py::arg("grid_vertices"), py::arg("idx_grids"), py::arg("res"));
+}

conquer3d-0.2.9/conquer3d/csrc/binds/ops/chamfer.cpp

@@ -0,0 +1,42 @@
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+#include "../../ops/chamfer.h"
+#include "../../check.h"
+
+namespace py = pybind11;
+
+std::tuple<torch::Tensor, torch::Tensor> one_sided_chamfer_distance_wrapper(
+    torch::Tensor query_points,
+    torch::Tensor reference_points
+) {
+    CHECK_INPUT(query_points);
+    CHECK_INPUT(reference_points);
+
+    uint32_t num_query_points = query_points.size(0);
+    uint32_t num_reference_points = reference_points.size(0);
+
+    const float3* __restrict__ p_query_points = (float3*)query_points.data_ptr<float>();
+    const float3* __restrict__ p_reference_points = (float3*)reference_points.data_ptr<float>();
+
+    torch::Tensor distances = torch::empty({num_query_points}, query_points.options());
+    torch::Tensor indices = torch::empty({num_query_points}, query_points.options().dtype(torch::kInt64));
+
+    float* __restrict__ p_distances = distances.data_ptr<float>();
+    int64_t* __restrict__ p_indices = indices.data_ptr<int64_t>();
+
+    one_sided_chamfer_distance(
+        num_query_points,
+        p_query_points,
+        num_reference_points,
+        p_reference_points,
+        p_distances,
+        p_indices
+    );
+
+    return std::make_tuple(distances, indices);
+}
+
+void bind_ops_chamfer(py::module_& m) {
+    m.def("one_sided_chamfer_distance", &one_sided_chamfer_distance_wrapper, "One Sided Chamfer Distance",
+          py::arg("query_points"), py::arg("reference_points"));
+}

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/csrc/binds/ops/mc.cpp

@@ -5,10 +5,11 @@
 
 namespace py = pybind11;
 
-std::tuple<torch::Tensor, torch::Tensor> marching_cubes_wrapper(
+std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> marching_cubes_wrapper(
     torch::Tensor grid_vertices,
     torch::Tensor voxels,
     torch::Tensor voxel_values,
+    std::optional<torch::Tensor> grid_normals,
     float iso
 ) {
     CHECK_INPUT(grid_vertices);
@@ -21,11 +22,18 @@ std::tuple<torch::Tensor, torch::Tensor> marching_cubes_wrapper(
     const uint32_t* __restrict__ p_voxels = (uint32_t*)voxels.data_ptr<int32_t>();
     const float* __restrict__ p_voxel_values = voxel_values.data_ptr<float>();
 
+    const float3* __restrict__ p_grid_normals = nullptr;
+    if (grid_normals.has_value()) {
+        CHECK_INPUT(grid_normals.value());
+        p_grid_normals = (float3*)grid_normals.value().data_ptr<float>();
+    }
+
     return mc::marching_cubes(
         num_voxels,
         p_grid_vertices,
         p_voxels,
         p_voxel_values,
+        p_grid_normals,
         iso,
         grid_vertices.options(),
         voxels.options()
@@ -33,5 +41,7 @@ std::tuple<torch::Tensor, torch::Tensor> marching_cubes_wrapper(
 }
 
 void bind_ops_mc(py::module_& m) {
-    m.def("marching_cubes", &marching_cubes_wrapper, "Marching Cubes");
+    m.def("marching_cubes", &marching_cubes_wrapper, "Marching Cubes",
+          py::arg("grid_vertices"), py::arg("voxels"), py::arg("voxel_values"),
+          py::arg("grid_normals") = std::nullopt, py::arg("iso") = 0.0f);
 }

conquer3d-0.2.9/conquer3d/csrc/ops/chamfer.cu

@@ -0,0 +1,73 @@
+#include "../data_structure/kdtree.h"
+
+#include <cstdint>
+#include <thrust/device_vector.h>
+#include <thrust/sequence.h>
+
+__global__ void one_sided_chamfer_distance_kernel(
+    const uint32_t num_query_points,
+    const float3 *__restrict__ query_points,
+    const uint32_t num_reference_points,
+    const float3 *__restrict__ tree_points,
+    const int64_t *__restrict__ tree_inds,
+    float *__restrict__ distances,
+    int64_t *__restrict__ indices)
+{
+    uint32_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= num_query_points)
+        return;
+
+    float3 query_point = query_points[idx];
+
+    float best_dists[MAX_K];
+    int64_t best_inds[MAX_K];
+
+#pragma unroll
+    for (int i = 0; i < MAX_K; i++)
+    {
+        best_dists[i] = FLT_MAX;
+        best_inds[i] = -1;
+    }
+
+    kdtree::query_kdtree_loop(
+        query_point,
+        num_reference_points,
+        tree_points,
+        tree_inds,
+        1,
+        best_dists,
+        best_inds);
+    
+    distances[idx] = best_dists[0];
+    indices[idx] = best_inds[0];
+}
+
+void one_sided_chamfer_distance(
+    const uint32_t num_query_points,
+    const float3 *__restrict__ query_points,
+    const uint32_t num_reference_points,
+    const float3 *__restrict__ reference_points,
+    float *__restrict__ distances,
+    int64_t *__restrict__ indices)
+{
+    thrust::device_vector<float3> cloned_ref_points(reference_points, reference_points + num_reference_points);
+    thrust::device_vector<int64_t> reference_indices(num_reference_points);
+    thrust::sequence(reference_indices.begin(), reference_indices.end());
+
+    kdtree::build(
+        num_reference_points,
+        thrust::raw_pointer_cast(cloned_ref_points.data()),
+        thrust::raw_pointer_cast(reference_indices.data()));
+
+    uint32_t threads = NTHREADS;
+    uint32_t blocks = (num_query_points + threads - 1) / threads;
+
+    one_sided_chamfer_distance_kernel<<<blocks, threads>>>(
+        num_query_points,
+        query_points,
+        num_reference_points,
+        thrust::raw_pointer_cast(cloned_ref_points.data()),
+        thrust::raw_pointer_cast(reference_indices.data()),
+        distances,
+        indices);
+}

conquer3d-0.2.9/conquer3d/csrc/ops/chamfer.h

@@ -0,0 +1,18 @@
+#ifndef CHAMFER_H
+#define CHAMFER_H
+
+#include "../constants.h"
+#include "../maths/maths.h"
+
+#include <cuda_runtime.h>
+
+void one_sided_chamfer_distance(
+    const uint32_t num_query_points,
+    const float3* __restrict__ query_points,
+    const uint32_t num_reference_points,
+    const float3* __restrict__ reference_points,
+    float* __restrict__ distances,
+    int64_t* __restrict__ indices
+);
+
+#endif // CHAMFER_H

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/csrc/ops/mc.cu

@@ -1,5 +1,5 @@
 #include "mc.h"
-
+#include "../maths/maths.h"
 #include <cuda_runtime.h>
 #include <thrust/sort.h>
 #include <thrust/scan.h>
@@ -25,7 +25,7 @@ namespace mc
     struct num_triangles_functor
     {
         __device__ uint32_t operator()(const uint8_t code) const {
-            return trinumTable[code + 1] - trinumTable[code];
+            return (trinumTable[code + 1] - trinumTable[code]) / 3;
         }
     };
 
@@ -175,8 +175,10 @@ namespace mc
         const Edge* unique_edges,
         const float3* grid_vertices,
         const float* values,
+        const float3* grid_normals,
         const float iso,
-        float3* out_verts
+        float3* out_verts,
+        float3* out_normals
     )
     {
         uint32_t v_idx = blockIdx.x * blockDim.x + threadIdx.x;
@@ -196,28 +198,42 @@ namespace mc
 
         // 3. Interpolate (Differentiable formula)
         float3 p;
+        float3 n;
+        bool has_normals = grid_normals != nullptr;
+        float3 n0 = has_normals ? grid_normals[v0_idx] : make_float3(0, 0, 0);
+        float3 n1 = has_normals ? grid_normals[v1_idx] : make_float3(0, 0, 0);
 
         if (fabsf(iso - val0) < EPS)
         {
             p = p0;
+            if (has_normals) n = n0;
         }
         else if (fabsf(iso - val1) < EPS)
         {
             p = p1;
+            if (has_normals) n = n1;
         }
         else if (fabsf(val0 - val1) < EPS)
         {
             p = p0;
+            if (has_normals) n = n0;
         }
         else
         {
             float t = (val1 != val0) ? fmaxf(0.0f, fminf(1.0f, (iso - val0) / (val1 - val0))) : 0.5f;
-            p.x = p0.x + (p1.x - p0.x) * t;
-            p.y = p0.y + (p1.y - p0.y) * t;
-            p.z = p0.z + (p1.z - p0.z) * t;
+
+            p = p0 + (p1 - p0) * t;
+            
+            if (has_normals) {
+                n = n0 + (n1 - n0) * t;
+                n = maths::normalize(n);
+            }
         }
 
         out_verts[v_idx] = p;
+        if (has_normals) {
+            out_normals[v_idx] = n;
+        }
     }
 
     void compute_active_voxels(
@@ -340,15 +356,17 @@ namespace mc
         const Edge* unique_edges,
         const float3* grid_vertices,
         const float* values,
+        const float3* grid_normals,
         const float iso,
-        float3* out_verts
+        float3* out_verts,
+        float3* out_normals
     )
     {
         if (num_unique_edges == 0) return;
         int block_size = NTHREADS;
         int grid_size = (num_unique_edges + block_size - 1) / block_size;
         interpolate_vertices_kernel<<<grid_size, block_size>>>(
-            num_unique_edges, unique_edges, grid_vertices, values, iso, out_verts);
+            num_unique_edges, unique_edges, grid_vertices, values, grid_normals, iso, out_verts, out_normals);
     }
 
     void compute_number_triangles(
@@ -417,11 +435,12 @@ namespace mc
             num_active_voxels, used_voxel_codes, voxel_edge_to_vert_idx, voxel_triangle_prefix_sums, out_triangles);
     }
 
-    std::tuple<torch::Tensor, torch::Tensor> marching_cubes(
+    std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> marching_cubes(
         const uint32_t num_voxels,
         const float3* __restrict__ grid_vertices,
         const uint32_t* __restrict__ voxels,
         const float* __restrict__ voxel_values,
+        const float3* __restrict__ grid_normals,
         const float iso,
         torch::TensorOptions vert_options,
         torch::TensorOptions tri_options
@@ -437,9 +456,12 @@ namespace mc
 
         if (num_active_voxels == 0) {
             CHECK_CUDA_INTERNAL(cudaFree(voxel_codes));
+            std::optional<torch::Tensor> out_n = std::nullopt;
+            if (grid_normals != nullptr) out_n = torch::empty({0, 3}, vert_options);
             return std::make_tuple(
                 torch::empty({0, 3}, vert_options),
-                torch::empty({0, 3}, tri_options)
+                torch::empty({0, 3}, tri_options),
+                out_n
             );
         }
 
@@ -463,7 +485,15 @@ namespace mc
         torch::Tensor out_vertices = torch::empty({out_num_vertices, 3}, vert_options);
         float3* __restrict__ p_out_vertices = (float3*)out_vertices.data_ptr<float>();
 
-        interpolate_vertices(out_num_vertices, unique_edges, grid_vertices, voxel_values, iso, p_out_vertices);
+        std::optional<torch::Tensor> out_normals_opt = std::nullopt;
+        float3* __restrict__ p_out_normals = nullptr;
+        if (grid_normals != nullptr) {
+            torch::Tensor out_normals = torch::empty({out_num_vertices, 3}, vert_options);
+            p_out_normals = (float3*)out_normals.data_ptr<float>();
+            out_normals_opt = out_normals;
+        }
+
+        interpolate_vertices(out_num_vertices, unique_edges, grid_vertices, voxel_values, grid_normals, iso, p_out_vertices, p_out_normals);
 
         uint32_t out_num_triangles;
         uint32_t *__restrict__ voxel_triangle_prefix_sums;
@@ -484,6 +514,6 @@ namespace mc
         CHECK_CUDA_INTERNAL(cudaFree(voxel_edge_to_vert_idx));
         CHECK_CUDA_INTERNAL(cudaFree(voxel_triangle_prefix_sums));
 
-        return std::make_tuple(out_vertices, out_triangles);
+        return std::make_tuple(out_vertices, out_triangles, out_normals_opt);
     }
 }

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/csrc/ops/mc.h

@@ -7,14 +7,15 @@
 #include "../constants.h"
 #include "../primitive/edge.h"
 
-#include <stdint.h>
+#include <optional>
 
 namespace mc{
-    std::tuple<torch::Tensor, torch::Tensor> marching_cubes(
+    std::tuple<torch::Tensor, torch::Tensor, std::optional<torch::Tensor>> marching_cubes(
         const uint32_t num_voxels,
         const float3* __restrict__ grid_vertices,
         const uint32_t* __restrict__ voxels,
         const float* __restrict__ voxel_values,
+        const float3* __restrict__ grid_normals,
         const float iso,
         torch::TensorOptions vert_options,
         torch::TensorOptions tri_options

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/csrc/pybind.cpp

@@ -17,6 +17,7 @@ void bind_ds_grid(py::module_& m);
 void bind_creation_triangle_creation(py::module_& m);
 
 void bind_ops_mc(py::module_& m);
+void bind_ops_chamfer(py::module_& m);
 
 PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
     m.doc() = "Geocutool Python bindings";
@@ -35,4 +36,5 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
     bind_creation_triangle_creation(m);
     
     bind_ops_mc(m);
+    bind_ops_chamfer(m);
 }

conquer3d-0.2.9/conquer3d/ops/__init__.py

@@ -0,0 +1,11 @@
+from .marching_cubes import marching_cubes
+from .grid import create_voxel_grid, compute_grid_normal
+from .distance import one_sided_chamfer_distance, chamfer_distance
+
+__all__ = [
+    "marching_cubes",
+    "create_voxel_grid",
+    "compute_grid_normal",
+    "one_sided_chamfer_distance",
+    "chamfer_distance"
+]

conquer3d-0.2.9/conquer3d/ops/distance.py

@@ -0,0 +1,28 @@
+import torch
+import conquer3d._C as _C
+
+def one_sided_chamfer_distance(query_points: torch.Tensor, reference_points: torch.Tensor, squared: bool = True):
+    assert query_points.is_cuda and reference_points.is_cuda, "Points must be on CUDA"
+    assert query_points.dtype == torch.float32 and reference_points.dtype == torch.float32, "Points must be float32"
+    assert query_points.shape[1] == 3 and reference_points.shape[1] == 3, "Points must be 3D"
+    
+    query_points_c = query_points.contiguous()
+    reference_points_c = reference_points.contiguous()
+    
+    distances, indices = _C.one_sided_chamfer_distance(query_points_c, reference_points_c)
+    
+    if not squared:
+        # clamp to avoid NaN from floating point inaccuracies
+        distances = torch.sqrt(torch.clamp(distances, min=1e-12))
+        
+    return distances, indices
+
+def chamfer_distance(x: torch.Tensor, y: torch.Tensor, squared: bool = True, return_indices: bool = False):
+    dist_x_to_y, idx_x_to_y = one_sided_chamfer_distance(x, y, squared=squared)
+    dist_y_to_x, idx_y_to_x = one_sided_chamfer_distance(y, x, squared=squared)
+    
+    loss = dist_x_to_y.mean() + dist_y_to_x.mean()
+    
+    if return_indices:
+        return loss, idx_x_to_y, idx_y_to_x
+    return loss

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/ops/grid.py

@@ -7,7 +7,7 @@ def create_voxel_grid(
     grid_max: Union[List[float], Tuple[float, float, float]],
     res: Union[List[int], Tuple[int, int, int]],
     device: str = "cuda"
-) -> Tuple[torch.Tensor, torch.Tensor]:
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
     """
     Creates a structured 3D voxel grid efficiently.
     
@@ -18,9 +18,30 @@ def create_voxel_grid(
         device (str, optional): Target device for the tensors (e.g., "cuda" or "cpu"). Defaults to "cuda".
         
     Returns:
-        Tuple[torch.Tensor, torch.Tensor]:
+        Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
             - grid_vertices (torch.Tensor): A float32 tensor of shape (N, 3) containing all grid coordinates.
             - voxels (torch.Tensor): An int32 tensor of shape (V, 8) containing corner indices 
                                      for each voxel, mapped identically to the Marching Cubes convention.
+            - idx_grids (torch.Tensor): An int64 tensor of shape (N, 3) containing the (i, j, k) 3D coordinate indices for each vertex.
     """
     return _C.create_voxel_grid(list(grid_min), list(grid_max), list(res), device)
+
+def compute_grid_normal(
+    sdf: torch.Tensor,
+    grid_vertices: torch.Tensor,
+    idx_grids: torch.Tensor,
+    res: Union[List[int], Tuple[int, int, int]]
+) -> torch.Tensor:
+    """
+    Computes smooth normals (gradients) for a voxel grid using central differences.
+    
+    Args:
+        sdf (torch.Tensor): A float32 tensor of shape (N,) containing the SDF values.
+        grid_vertices (torch.Tensor): A float32 tensor of shape (N, 3) containing the grid coordinates.
+        idx_grids (torch.Tensor): An int64 tensor of shape (N, 3) containing the (i, j, k) indices, returned by create_voxel_grid.
+        res (List[int] | Tuple[int, int, int]): The number of vertices along each axis (rx, ry, rz).
+        
+    Returns:
+        torch.Tensor: A float32 tensor of shape (N, 3) containing the normalized gradient vectors.
+    """
+    return _C.compute_grid_normal(sdf.contiguous(), grid_vertices.contiguous(), idx_grids.contiguous(), list(res))

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d/ops/marching_cubes.py

@@ -1,5 +1,5 @@
 import torch
-from typing import Tuple
+from typing import Tuple, Optional
 
 # Explicitly import the compiled CMake target
 from .._C import marching_cubes as marching_cubes_func
@@ -8,8 +8,9 @@ def marching_cubes(
     grid_vertices: torch.Tensor,
     voxels: torch.Tensor,
     voxel_values: torch.Tensor,
+    grid_normals: Optional[torch.Tensor] = None,
     iso: float = 0.0
-) -> Tuple[torch.Tensor, torch.Tensor]:
+) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
     """
     Executes the Marching Cubes algorithm to extract an isosurface from a voxel grid.
 
@@ -17,12 +18,14 @@ def marching_cubes(
         grid_vertices (torch.Tensor): (V, 3) tensor of global vertex positions.
         voxels (torch.Tensor): (N, 8) tensor of voxel corner indices mapping to `grid_vertices`.
         voxel_values (torch.Tensor): (V,) tensor of SDF/scalar values at each vertex.
+        grid_normals (torch.Tensor, optional): (V, 3) optional tensor of SDF normals at each vertex. Defaults to None.
         iso (float, optional): The isosurface extraction threshold. Defaults to 0.0.
 
     Returns:
-        Tuple[torch.Tensor, torch.Tensor]:
+        Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
             - vertices (torch.Tensor): (M, 3) tensor of extracted mesh vertices.
             - triangles (torch.Tensor): (T, 3) tensor of extracted mesh triangle indices.
+            - normals (torch.Tensor, optional): (M, 3) tensor of extracted mesh vertex normals, if `grid_normals` was provided.
     """
     if not all(t.is_cuda for t in [grid_vertices, voxels, voxel_values]):
         raise ValueError("All input tensors must be CUDA tensors.")
@@ -30,13 +33,21 @@ def marching_cubes(
     grid_vertices_c = grid_vertices.contiguous().to(torch.float32)
     voxels_c = voxels.contiguous().to(torch.int32)
     voxel_values_c = voxel_values.contiguous().to(torch.float32)
+    
+    grid_normals_c = None
+    if grid_normals is not None:
+        if not grid_normals.is_cuda:
+            raise ValueError("grid_normals must be a CUDA tensor.")
+        grid_normals_c = grid_normals.contiguous().to(torch.float32)
+
     iso_c = float(iso)
 
-    vertices, triangles = marching_cubes_func(
+    vertices, triangles, out_normals = marching_cubes_func(
         grid_vertices_c,
         voxels_c,
         voxel_values_c,
+        grid_normals_c,
         iso_c
     )
 
-    return vertices, triangles
+    return vertices, triangles, out_normals

{conquer3d-0.2.8 → conquer3d-0.2.9/conquer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.8
+Version: 0.2.9
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -56,7 +56,7 @@ pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https
 pip install pybind11-stubgen
 pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
 
-pip install plotly open3d jupyter trimesh
+pip install plotly open3d jupyter trimesh point-cloud-utils
 ```
 
 # Development

{conquer3d-0.2.8 → conquer3d-0.2.9}/conquer3d.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ conquer3d/csrc/binds/data_structure/kdtree.cpp
 conquer3d/csrc/binds/data_structure/mesh_bvh.cpp
 conquer3d/csrc/binds/data_structure/pgs_bvh.cpp
 conquer3d/csrc/binds/data_structure/triangle_mesh.cpp
+conquer3d/csrc/binds/ops/chamfer.cpp
 conquer3d/csrc/binds/ops/mc.cpp
 conquer3d/csrc/binds/primitive/gs.cpp
 conquer3d/csrc/binds/primitive/pgs.cpp
@@ -48,6 +49,8 @@ conquer3d/csrc/maths/f4x1.h
 conquer3d/csrc/maths/f4x4.h
 conquer3d/csrc/maths/maths.h
 conquer3d/csrc/maths/ops.h
+conquer3d/csrc/ops/chamfer.cu
+conquer3d/csrc/ops/chamfer.h
 conquer3d/csrc/ops/mc.cu
 conquer3d/csrc/ops/mc.h
 conquer3d/csrc/ops/mc_data.h
@@ -65,6 +68,7 @@ conquer3d/csrc/primitive/ray.h
 conquer3d/csrc/primitive/triangles.h
 conquer3d/data_structure/__init__.py
 conquer3d/ops/__init__.py
+conquer3d/ops/distance.py
 conquer3d/ops/grid.py
 conquer3d/ops/marching_cubes.py
 conquer3d/primitive/__init__.py

{conquer3d-0.2.8 → conquer3d-0.2.9}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conquer3d"
-version = "0.2.8"
+version = "0.2.9"
 description = "Geometric Cuda Tool Box"
 readme = "README.md"
 license = "MIT"

conquer3d-0.2.8/conquer3d/csrc/binds/data_structure/grid.cpp

@@ -1,66 +0,0 @@
-#include <torch/extension.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
-#include <tuple>
-#include <string>
-#include <vector>
-
-namespace py = pybind11;
-
-std::tuple<torch::Tensor, torch::Tensor> create_voxel_grid(
-    std::vector<float> grid_min,
-    std::vector<float> grid_max,
-    std::vector<int64_t> res,
-    std::string device_str
-) {
-    TORCH_CHECK(grid_min.size() == 3, "grid_min must have 3 elements.");
-    TORCH_CHECK(grid_max.size() == 3, "grid_max must have 3 elements.");
-    TORCH_CHECK(res.size() == 3, "res must have 3 elements.");
-
-    c10::Device device(device_str);
-    auto options = torch::TensorOptions().device(device).dtype(torch::kFloat32);
-
-    int64_t rx = res[0];
-    int64_t ry = res[1];
-    int64_t rz = res[2];
-
-    auto x = torch::linspace(grid_min[0], grid_max[0], rx, options);
-    auto y = torch::linspace(grid_min[1], grid_max[1], ry, options);
-    auto z = torch::linspace(grid_min[2], grid_max[2], rz, options);
-
-    auto grids = torch::meshgrid({x, y, z}, "ij");
-    auto grid_x = grids[0].flatten();
-    auto grid_y = grids[1].flatten();
-    auto grid_z = grids[2].flatten();
-    
-    auto grid_vertices = torch::stack({grid_x, grid_y, grid_z}, 1).contiguous();
-
-    auto options_int = options.dtype(torch::kInt64);
-    auto i = torch::arange(rx - 1, options_int);
-    auto j = torch::arange(ry - 1, options_int);
-    auto k = torch::arange(rz - 1, options_int);
-
-    auto idx_grids = torch::meshgrid({i, j, k}, "ij");
-    auto vi = idx_grids[0];
-    auto vj = idx_grids[1];
-    auto vk = idx_grids[2];
-
-    // Voxel connectivity indexing mapping matching mc.cu
-    auto v0 = vi * ry * rz + vj * rz + vk;
-    auto v1 = (vi + 1) * ry * rz + vj * rz + vk;
-    auto v2 = (vi + 1) * ry * rz + (vj + 1) * rz + vk;
-    auto v3 = vi * ry * rz + (vj + 1) * rz + vk;
-    auto v4 = vi * ry * rz + vj * rz + (vk + 1);
-    auto v5 = (vi + 1) * ry * rz + vj * rz + (vk + 1);
-    auto v6 = (vi + 1) * ry * rz + (vj + 1) * rz + (vk + 1);
-    auto v7 = vi * ry * rz + (vj + 1) * rz + (vk + 1);
-
-    auto voxels = torch::stack({v0, v1, v2, v3, v4, v5, v6, v7}, -1).view({-1, 8}).contiguous().to(torch::kInt32);
-
-    return std::make_tuple(grid_vertices, voxels);
-}
-
-void bind_ds_grid(py::module_& m) {
-    m.def("create_voxel_grid", &create_voxel_grid, "Creates a structured 3D voxel grid.",
-          py::arg("grid_min"), py::arg("grid_max"), py::arg("res"), py::arg("device_str") = "cuda");
-}

conquer3d-0.2.8/conquer3d/ops/__init__.py

@@ -1,7 +0,0 @@
-from .marching_cubes import marching_cubes
-from .grid import create_voxel_grid
-
-__all__ = [
-    "marching_cubes",
-    "create_voxel_grid"
-]