conquer3d 0.4.0__tar.gz → 0.4.2__tar.gz

{conquer3d-0.4.0/conquer3d.egg-info → conquer3d-0.4.2}/PKG-INFO

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

{conquer3d-0.4.0 → conquer3d-0.4.2}/conquer3d/__init__.py

@@ -1,4 +1,10 @@
 import torch
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version('conquer3d')
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"
 
 from . import _C
 from . import creation

conquer3d-0.4.2/conquer3d/conversion/tmesh.py

@@ -0,0 +1,83 @@
+import torch
+import tqdm
+from conquer3d.data_structure.grid import create_voxel_grid, compute_active_voxels
+
+def tmesh2voxel(tm, res, grid_min=None, grid_max=None, chunk_size=5000000, device='cuda', show_progress=True):
+    """
+    Constructs a dense voxel grid from a TriangleMesh and evaluates its SDF.
+    
+    Returns:
+        grid_vertices, voxels, idx_grids, sdfs
+    """
+    if grid_min is None:
+        grid_min = [-1.0, -1.0, -1.0]
+    if grid_max is None:
+        grid_max = [1.0, 1.0, 1.0]
+        
+    if isinstance(res, int):
+        res_list = [res, res, res]
+    else:
+        res_list = list(res)
+    grid_vertices, voxels, idx_grids = create_voxel_grid(grid_min, grid_max, res_list, device=device)
+    
+    num_points = grid_vertices.shape[0]
+    sdfs = torch.empty(num_points, dtype=torch.float32, device=device)
+    
+    iterator = range(0, num_points, chunk_size)
+    if show_progress:
+        iterator = tqdm.tqdm(iterator, desc="Computing SDF")
+        
+    for i in iterator:
+        end = min(i + chunk_size, num_points)
+        chunk_points = grid_vertices[i:end]
+        _, _, _, chunk_sdf = tm.query_points(chunk_points, return_sdf=True, return_prj_pts=False, sign_mode=1)
+        sdfs[i:end] = chunk_sdf
+        
+    return grid_vertices, voxels, idx_grids, sdfs
+
+def tmesh2sparse(tm, res, grid_min=None, grid_max=None, chunk_size=5000000, iso=0.0, device='cuda', show_progress=True):
+    """
+    Computes the SDF and returns only the active voxels (sparse grid) near the surface.
+    This now completely bypasses dense memory allocation!
+    
+    Returns:
+        grid_vertices, active_voxels, idx_grids, sdfs
+    """
+    if grid_min is None:
+        grid_min = [-1.0, -1.0, -1.0]
+    if grid_max is None:
+        grid_max = [1.0, 1.0, 1.0]
+        
+    if isinstance(res, int):
+        res_list = [res, res, res]
+    else:
+        res_list = list(res)
+
+    from conquer3d.data_structure import create_voxel_grid_from_tmesh
+    
+    if tm.bvh is None:
+        tm.build_bvh()
+        
+    grid_vertices, active_voxels, unique_vert_ids = create_voxel_grid_from_tmesh(
+        grid_min, grid_max, res_list, tm
+    )
+    
+    num_points = grid_vertices.shape[0]
+    sdfs = torch.empty(num_points, dtype=torch.float32, device=device)
+    
+    iterator = range(0, num_points, chunk_size)
+    if show_progress:
+        iterator = tqdm.tqdm(iterator, desc="Computing Sparse SDF")
+        
+    for i in iterator:
+        end = min(i + chunk_size, num_points)
+        chunk_points = grid_vertices[i:end]
+        _, _, _, chunk_sdf = tm.query_points(chunk_points, return_sdf=True, return_prj_pts=False, sign_mode=1)
+        sdfs[i:end] = chunk_sdf
+        
+    # Since we strictly extracted surface-intersecting voxels in C++, 
+    # we don't strictly need to re-filter them, but we can do a quick check to refine the band.
+    # However, marching_cubes only uses active_voxels.
+    # To keep identical API, we return None for idx_grids since it's dense and unnecessary.
+    return grid_vertices, active_voxels.to(torch.int64), None, sdfs
+

{conquer3d-0.4.0 → conquer3d-0.4.2}/conquer3d/csrc/binds/data_structure/grid.cpp

@@ -4,6 +4,8 @@
 #include <tuple>
 #include <string>
 #include <vector>
+#include "../../data_structure/mesh_bvh.h"
+#include "../../data_structure/triangle_mesh.h"
 
 namespace py = pybind11;
 
@@ -139,9 +141,78 @@ torch::Tensor compute_active_voxels(torch::Tensor voxels, torch::Tensor sdf, flo
     return active_indices;
 }
 
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> create_voxel_grid_from_tmesh(
+    std::vector<float> grid_min,
+    std::vector<float> grid_max,
+    std::vector<int64_t> res,
+    TriangleMesh &tmesh
+) {
+    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.");
+
+    int64_t rx = res[0];
+    int64_t ry = res[1];
+    int64_t rz = res[2];
+
+    MeshBVH bvh = tmesh.build_bvh();
+    auto vertices = tmesh.get_vertices();
+    auto triangles = tmesh.get_triangles();
+
+    auto active_voxel_ids = bvh.get_active_voxel_ids_from_grid(grid_min, grid_max, res, vertices, triangles);
+
+    if (active_voxel_ids.size(0) == 0) {
+        return std::make_tuple(
+            torch::empty({0, 3}, torch::TensorOptions().dtype(torch::kFloat32).device(vertices.device())),
+            torch::empty({0, 8}, torch::TensorOptions().dtype(torch::kInt32).device(vertices.device())),
+            torch::empty({0}, torch::TensorOptions().dtype(torch::kInt64).device(vertices.device()))
+        );
+    }
+
+    auto vi = active_voxel_ids.div((ry - 1) * (rz - 1), "trunc");
+    auto rem = active_voxel_ids.remainder((ry - 1) * (rz - 1));
+    auto vj = rem.div(rz - 1, "trunc");
+    auto vk = rem.remainder(rz - 1);
+
+    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 active_voxels = torch::stack({v0, v1, v2, v3, v4, v5, v6, v7}, -1);
+
+    torch::Tensor unique_vert_ids, inverse_indices, counts;
+    std::tie(unique_vert_ids, inverse_indices, counts) = torch::_unique2(active_voxels.flatten(), true, true, false);
+
+    auto remapped_voxels = inverse_indices.view({-1, 8}).to(torch::kInt32);
+
+    auto u_i = unique_vert_ids.div(ry * rz, "trunc");
+    auto u_rem = unique_vert_ids.remainder(ry * rz);
+    auto u_j = u_rem.div(rz, "trunc");
+    auto u_k = u_rem.remainder(rz);
+
+    float spacing_x = (grid_max[0] - grid_min[0]) / (rx - 1);
+    float spacing_y = (grid_max[1] - grid_min[1]) / (ry - 1);
+    float spacing_z = (grid_max[2] - grid_min[2]) / (rz - 1);
+
+    auto x = grid_min[0] + u_i.to(torch::kFloat32) * spacing_x;
+    auto y = grid_min[1] + u_j.to(torch::kFloat32) * spacing_y;
+    auto z = grid_min[2] + u_k.to(torch::kFloat32) * spacing_z;
+
+    auto sparse_grid_vertices = torch::stack({x, y, z}, 1).contiguous();
+
+    return std::make_tuple(sparse_grid_vertices, remapped_voxels, unique_vert_ids);
+}
+
 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("create_voxel_grid_from_tmesh", &create_voxel_grid_from_tmesh, "Creates a sparse 3D voxel grid strictly around the surface.",
+          py::arg("grid_min"), py::arg("grid_max"), py::arg("res"), py::arg("tmesh"));
     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"));
     m.def("compute_active_voxels", &compute_active_voxels, "Computes active voxels intersecting the surface",

{conquer3d-0.4.0 → conquer3d-0.4.2}/conquer3d/csrc/binds/data_structure/mesh_bvh.cpp

@@ -187,6 +187,112 @@ std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> MeshBVH::
     return std::make_tuple(out_query_ids, out_object_ids, out_projected_pts, out_distances);
 }
 
+torch::Tensor MeshBVH::query_voxel(
+    const torch::Tensor &query_mins,
+    const torch::Tensor &query_maxs,
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles)
+{
+    int num_queries = query_mins.size(0);
+    int num_objects = this->object_ids.size(0);
+
+    auto options_bool = torch::TensorOptions().dtype(torch::kBool).device(query_mins.device());
+    torch::Tensor out_intersect = torch::empty({num_queries}, options_bool);
+
+    if (num_queries == 0 || num_objects == 0)
+    {
+        out_intersect.fill_(false);
+        return out_intersect;
+    }
+
+    mesh_bvh::query_voxel_mesh_bvh(
+        num_queries,
+        num_objects,
+        (const float3 *)query_mins.data_ptr<float>(),
+        (const float3 *)query_maxs.data_ptr<float>(),
+        (const float3 *)vertices.data_ptr<float>(),
+        (const int3 *)triangles.data_ptr<int>(),
+        (const float3 *)this->aabb_mins.data_ptr<float>(),
+        (const float3 *)this->aabb_maxs.data_ptr<float>(),
+        (const int2 *)this->bvh_children.data_ptr<int>(),
+        this->object_ids.data_ptr<int>(),
+        out_intersect.data_ptr<bool>());
+
+    return out_intersect;
+}
+
+torch::Tensor MeshBVH::get_active_voxel_ids_from_grid(
+    std::vector<float> grid_min,
+    std::vector<float> grid_max,
+    std::vector<int64_t> res,
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles)
+{
+    int64_t rx = res[0] - 1;
+    int64_t ry = res[1] - 1;
+    int64_t rz = res[2] - 1;
+    int64_t num_queries = rx * ry * rz;
+    int num_objects = this->object_ids.size(0);
+
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(vertices.device());
+
+    if (num_queries <= 0 || num_objects == 0)
+    {
+        return torch::empty({0}, options_i64);
+    }
+
+    float spacing_x = (grid_max[0] - grid_min[0]) / (res[0] - 1);
+    float spacing_y = (grid_max[1] - grid_min[1]) / (res[1] - 1);
+    float spacing_z = (grid_max[2] - grid_min[2]) / (res[2] - 1);
+
+    int3 res_int = make_int3(rx, ry, rz);
+    float3 g_min = make_float3(grid_min[0], grid_min[1], grid_min[2]);
+    float3 v_size = make_float3(spacing_x, spacing_y, spacing_z);
+
+    // Pass 1: Count active voxels
+    torch::Tensor active_counter = torch::zeros({1}, options_i64);
+
+    mesh_bvh::count_active_voxels_mesh_bvh(
+        res_int,
+        g_min,
+        v_size,
+        num_objects,
+        (const float3 *)vertices.data_ptr<float>(),
+        (const int3 *)triangles.data_ptr<int>(),
+        (const float3 *)this->aabb_mins.data_ptr<float>(),
+        (const float3 *)this->aabb_maxs.data_ptr<float>(),
+        (const int2 *)this->bvh_children.data_ptr<int>(),
+        this->object_ids.data_ptr<int>(),
+        active_counter.data_ptr<int64_t>());
+
+    int64_t num_active = active_counter.item<int64_t>();
+
+    if (num_active == 0)
+    {
+        return torch::empty({0}, options_i64);
+    }
+
+    // Pass 2: Collect active voxels
+    torch::Tensor out_active_ids = torch::empty({num_active}, options_i64);
+    active_counter.zero_();
+
+    mesh_bvh::collect_active_voxels_mesh_bvh(
+        res_int,
+        g_min,
+        v_size,
+        num_objects,
+        (const float3 *)vertices.data_ptr<float>(),
+        (const int3 *)triangles.data_ptr<int>(),
+        (const float3 *)this->aabb_mins.data_ptr<float>(),
+        (const float3 *)this->aabb_maxs.data_ptr<float>(),
+        (const int2 *)this->bvh_children.data_ptr<int>(),
+        this->object_ids.data_ptr<int>(),
+        active_counter.data_ptr<int64_t>(),
+        out_active_ids.data_ptr<int64_t>());
+
+    return out_active_ids;
+}
+
 void MeshBVH::build_winding_data(
     const torch::Tensor &vertices,
     const torch::Tensor &triangles)
@@ -295,5 +401,18 @@ void bind_ds_mesh_bvh(py::module_ &m)
         Args:
             vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
             triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+        )doc")
+        .def("query_voxel", &MeshBVH::query_voxel, py::arg("query_mins"), py::arg("query_maxs"), py::arg("vertices"), py::arg("triangles"),
+             R"doc(
+        Queries whether each voxel intersects the mesh.
+        
+        Args:
+            query_mins (torch.Tensor): Shape (Q, 3) float32 tensor of voxel minimums.
+            query_maxs (torch.Tensor): Shape (Q, 3) float32 tensor of voxel maximums.
+            vertices (torch.Tensor): Shape (N, 3) float32 tensor of vertices.
+            triangles (torch.Tensor): Shape (M, 3) int32 tensor of triangles.
+            
+        Returns:
+            torch.Tensor: Boolean tensor of shape (Q,) indicating intersection.
         )doc");
 }

{conquer3d-0.4.0 → conquer3d-0.4.2}/conquer3d/csrc/binds/data_structure/triangle_mesh.cpp

@@ -296,6 +296,10 @@ void TriangleMesh::remove_isolated_vertices() {
     this->triangle_normals = torch::Tensor();
     this->surface_area = torch::Tensor();
     this->bvh.reset();
+    this->opt_edge_manifold = std::nullopt;
+    this->opt_edge_manifold_w_boundary = std::nullopt;
+    this->opt_vertex_manifold = std::nullopt;
+    this->opt_self_intersected = std::nullopt;
     this->edges = torch::Tensor();
     this->edge_to_triangle_offsets = torch::Tensor();
     this->edge_to_triangle_counts = torch::Tensor();
@@ -347,8 +351,13 @@ torch::Tensor TriangleMesh::get_self_intersection()
 
 bool TriangleMesh::is_self_intersection()
 {
+    if (this->opt_self_intersected.has_value()) {
+        return this->opt_self_intersected.value();
+    }
     this->build_bvh();
-    return this->bvh.value().is_self_intersection(this->vertices, this->triangles);
+    bool self_int = this->bvh.value().is_self_intersection(this->vertices, this->triangles);
+    this->opt_self_intersected = self_int;
+    return self_int;
 }
 
 std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> TriangleMesh::query_points(
@@ -358,6 +367,10 @@ std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> TriangleM
     int sign_mode,
     int distance_mode)
 {
+    if (!this->is_manifold(true)) {
+        sign_mode = 0;
+    }
+
     if (distance_mode == 0)
     {
         this->build_bvh();
@@ -541,15 +554,26 @@ bool TriangleMesh::is_edge_manifold(bool allow_boundary_edge)
 {
     if (this->num_triangles == 0)
         return true;
+
+    if (allow_boundary_edge && this->opt_edge_manifold_w_boundary.has_value()) {
+        return this->opt_edge_manifold_w_boundary.value();
+    } else if (!allow_boundary_edge && this->opt_edge_manifold.has_value()) {
+        return this->opt_edge_manifold.value();
+    }
+
     torch::Tensor counts = this->get_edge_to_triangle_counts();
+    bool is_manifold;
     if (allow_boundary_edge)
     {
-        return (counts <= 2).all().item<bool>();
+        is_manifold = (counts <= 2).all().item<bool>();
+        this->opt_edge_manifold_w_boundary = is_manifold;
     }
     else
     {
-        return (counts == 2).all().item<bool>();
+        is_manifold = (counts == 2).all().item<bool>();
+        this->opt_edge_manifold = is_manifold;
     }
+    return is_manifold;
 }
 
 void TriangleMesh::remove_triangles_by_mask(const torch::Tensor &keep_mask)
@@ -566,6 +590,10 @@ void TriangleMesh::remove_triangles_by_mask(const torch::Tensor &keep_mask)
     this->triangle_normals = torch::Tensor();
     this->surface_area = torch::Tensor();
     this->bvh.reset();
+    this->opt_edge_manifold = std::nullopt;
+    this->opt_edge_manifold_w_boundary = std::nullopt;
+    this->opt_vertex_manifold = std::nullopt;
+    this->opt_self_intersected = std::nullopt;
     this->edges = torch::Tensor();
     this->edge_to_triangle_offsets = torch::Tensor();
     this->edge_to_triangle_counts = torch::Tensor();
@@ -581,6 +609,33 @@ void TriangleMesh::remove_triangles_by_mask(const torch::Tensor &keep_mask)
     this->voronoi_areas = torch::Tensor();
 }
 
+void TriangleMesh::fix_normals()
+{
+    if (this->num_triangles == 0) return;
+    
+    if (!this->vertex_to_triangle_offsets.defined()) {
+        this->compute_vertices_to_triangle_map();
+    }
+    
+    triangle_mesh::fix_normals(
+        this->num_triangles,
+        reinterpret_cast<const float3 *>(this->vertices.data_ptr<float>()),
+        this->vertex_to_triangle_offsets,
+        this->vertex_to_triangle_counts,
+        this->vertex_to_triangle_indices,
+        reinterpret_cast<int3 *>(this->triangles.data_ptr<int>()));
+        
+    // Invalidate caches
+    this->triangle_areas = torch::Tensor();
+    this->triangle_normals = torch::Tensor();
+    this->vertex_normals = torch::Tensor();
+    this->bvh.reset();
+    this->opt_edge_manifold = std::nullopt;
+    this->opt_edge_manifold_w_boundary = std::nullopt;
+    this->opt_vertex_manifold = std::nullopt;
+    this->opt_self_intersected = std::nullopt;
+}
+
 int32_t TriangleMesh::get_euler_characteristic()
 {
     int32_t V = this->vertices.size(0);
@@ -648,8 +703,13 @@ torch::Tensor TriangleMesh::get_non_manifold_vertices()
 
 bool TriangleMesh::is_vertex_manifold()
 {
+    if (this->opt_vertex_manifold.has_value()) {
+        return this->opt_vertex_manifold.value();
+    }
     torch::Tensor nm_vertices = this->get_non_manifold_vertices();
-    return nm_vertices.size(0) == 0;
+    bool is_manifold = (nm_vertices.size(0) == 0);
+    this->opt_vertex_manifold = is_manifold;
+    return is_manifold;
 }
 
 bool TriangleMesh::is_manifold(bool allow_boundary_edge)
@@ -934,6 +994,11 @@ void bind_ds_triangle_mesh(py::module_ &m)
         Args:
             keep_mask (torch.Tensor): Shape (M,) boolean tensor indicating which triangles to keep.
         )doc")
+        .def("fix_normals", &TriangleMesh::fix_normals, R"doc(
+        Fixes the winding order and outward orientation of the mesh normals.
+        This uses a CUDA-accelerated BFS to ensure consistent winding, 
+        and computes signed volumes to ensure all disconnected components face outward.
+        )doc")
         .def("sample_points", &TriangleMesh::sample_points, py::arg("num_points"), py::arg("uniform") = false, py::arg("return_normals") = false, py::arg("return_colors") = false, py::arg("use_triangle_normal") = true, R"doc(
         Samples random points on the surface of the mesh.