conquer3d 0.2.5__tar.gz → 0.2.6__tar.gz

{conquer3d-0.2.5/conquer3d.egg-info → conquer3d-0.2.6}/PKG-INFO

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

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/_C.pyi

@@ -14,9 +14,13 @@ class BVH:
         """
         Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).
         """
-    def query_ray(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+    def query_point(self, query_points: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         """
-        Query the BVH with rays. Returns (query_ids, object_ids).
+        Find the closest leaf AABB to each query point. Returns (query_ids, object_ids, distances)
+        """
+    def query_ray(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find all ray-AABB intersections. Returns (ray_ids, object_ids)
         """
     def query_self(self) -> tuple[torch.Tensor, torch.Tensor]:
         """
@@ -65,6 +69,10 @@ class MeshBVH(BVH):
         """
         Check if there are any self-intersecting triangle pairs
         """
+    def query_point(self, query_points: torch.Tensor, vertices: torch.Tensor, triangles: torch.Tensor, return_sdf: bool = False, return_prj_pts: bool = True, sign_mode: int = 0) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Find the closest triangle to each query point. Returns (query_ids, triangle_ids, projected_points, distances)
+        """
 class PGSBVH(BVH):
     def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
         """
@@ -115,6 +123,10 @@ class TriangleMesh:
         """
     def is_vertex_manifold(self) -> bool:
         ...
+    def query_points(self, query_pts: torch.Tensor, return_sdf: bool = False, return_prj_pts: bool = True, sign_mode: int = 0, distance_mode: int = 0) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Query points against the mesh. Returns (query_ids, triangle_ids, projected_points, distances)
+        """
     def remove_triangles_by_mask(self, keep_mask: torch.Tensor) -> None:
         ...
     @property

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/binds/data_structure/bvh.cpp

@@ -155,48 +155,81 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query_self()
 
 std::tuple<torch::Tensor, torch::Tensor> BVH::query_ray(
     const torch::Tensor &ray_origins,
-    const torch::Tensor &ray_dirs)
+    const torch::Tensor &ray_dirs,
+    int64_t max_capacity)
 {
     CHECK_INPUT(ray_origins);
     CHECK_INPUT(ray_dirs);
-    TORCH_CHECK(ray_origins.scalar_type() == torch::kFloat32, "ray_origins must be float32");
-    TORCH_CHECK(ray_dirs.scalar_type() == torch::kFloat32, "ray_dirs must be float32");
-    TORCH_CHECK(ray_origins.size(1) == 3, "ray_origins must have shape (M, 3)");
-    TORCH_CHECK(ray_dirs.size(1) == 3, "ray_dirs must have shape (M, 3)");
+    TORCH_CHECK(ray_origins.size(0) == ray_dirs.size(0), "ray_origins and ray_dirs must have the same number of rays");
 
-    const uint32_t num_queries = static_cast<uint32_t>(ray_origins.size(0));
-    auto options_int64 = ray_origins.options().dtype(torch::kInt64);
+    int num_queries = ray_origins.size(0);
 
-    if (num_queries == 0) {
-        throw std::runtime_error("Cannot query BVH with 0 queries.");
-    }
-
-    torch::Tensor out_query_ids = torch::empty({BVH_MAX_CAPACITY}, options_int64);
-    torch::Tensor out_object_ids = torch::empty({BVH_MAX_CAPACITY}, options_int64);
-    torch::Tensor hit_counter = torch::zeros({1}, options_int64);
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(ray_origins.device());
+    torch::Tensor out_query_ids = torch::empty({max_capacity}, options_i64);
+    torch::Tensor out_object_ids = torch::empty({max_capacity}, options_i64);
+    torch::Tensor hit_counter = torch::zeros({1}, options_i64);
 
     bvh::query_ray(
         num_queries,
         this->num_objects,
-        reinterpret_cast<const float3 *>(ray_origins.data_ptr<float>()),
-        reinterpret_cast<const float3 *>(ray_dirs.data_ptr<float>()),
-        reinterpret_cast<const float3 *>(this->aabb_mins.data_ptr<float>()),
-        reinterpret_cast<const float3 *>(this->aabb_maxs.data_ptr<float>()),
-        reinterpret_cast<const int2 *>(this->bvh_children.data_ptr<int>()),
-        reinterpret_cast<const int *>(this->object_ids.data_ptr<int>()),
-        reinterpret_cast<int64_t *>(out_query_ids.data_ptr<int64_t>()),
-        reinterpret_cast<int64_t *>(out_object_ids.data_ptr<int64_t>()),
-        reinterpret_cast<int64_t *>(hit_counter.data_ptr<int64_t>()),
-        static_cast<int64_t>(BVH_MAX_CAPACITY)
-    );
+        (const float3 *)ray_origins.data_ptr<float>(),
+        (const float3 *)ray_dirs.data_ptr<float>(),
+        (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_query_ids.data_ptr<int64_t>(),
+        out_object_ids.data_ptr<int64_t>(),
+        hit_counter.data_ptr<int64_t>(),
+        max_capacity);
+
+    int64_t h_hit_counter = hit_counter.item<int64_t>();
+
+    if (h_hit_counter >= max_capacity)
+    {
+        TORCH_WARN("BVH ray query capacity exceeded. Some hits were dropped.");
+        h_hit_counter = max_capacity;
+    }
 
-    int64_t num_hits = hit_counter.item<int64_t>();
-    num_hits = std::min(num_hits, static_cast<int64_t>(BVH_MAX_CAPACITY));
+    if (h_hit_counter == 0) {
+        return std::make_tuple(
+            torch::empty({0}, options_i64),
+            torch::empty({0}, options_i64)
+        );
+    }
 
     return std::make_tuple(
-        out_query_ids.slice(0, 0, num_hits), 
-        out_object_ids.slice(0, 0, num_hits)
-    );
+        out_query_ids.slice(0, 0, h_hit_counter),
+        out_object_ids.slice(0, 0, h_hit_counter));
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> BVH::query_point(
+    const torch::Tensor &query_points)
+{
+    CHECK_INPUT(query_points);
+
+    int num_queries = query_points.size(0);
+    
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(query_points.device());
+    auto options_f32 = torch::TensorOptions().dtype(torch::kFloat32).device(query_points.device());
+    
+    torch::Tensor out_query_ids = torch::empty({num_queries}, options_i64);
+    torch::Tensor out_object_ids = torch::empty({num_queries}, options_i64);
+    torch::Tensor out_distances = torch::empty({num_queries}, options_f32);
+
+    bvh::query_point(
+        num_queries,
+        this->num_objects,
+        (const float3 *)query_points.data_ptr<float>(),
+        (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_query_ids.data_ptr<int64_t>(),
+        out_object_ids.data_ptr<int64_t>(),
+        out_distances.data_ptr<float>());
+
+    return std::make_tuple(out_query_ids, out_object_ids, out_distances);
 }
 
 void bind_ds_bvh(py::module_& m)
@@ -216,7 +249,11 @@ void bind_ds_bvh(py::module_& m)
              "Query the BVH against itself. Returns unique overlapping (query_ids, object_ids).")
 
         .def("query_ray", &BVH::query_ray,
-             py::arg("ray_origins"), 
+             py::arg("ray_origins"),
              py::arg("ray_dirs"),
-             "Query the BVH with rays. Returns (query_ids, object_ids).");
+             py::arg("max_capacity") = BVH_MAX_CAPACITY,
+             "Find all ray-AABB intersections. Returns (ray_ids, object_ids)")
+        .def("query_point", &BVH::query_point,
+             py::arg("query_points"),
+             "Find the closest leaf AABB to each query point. Returns (query_ids, object_ids, distances)");
 }

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/binds/data_structure/mesh_bvh.cpp

@@ -32,5 +32,13 @@ void bind_ds_mesh_bvh(py::module_& m)
              py::arg("vertices"),
              py::arg("triangles"),
              py::arg("return_distance") = false,
-             "Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])");
+             "Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])")
+        .def("query_point", &MeshBVH::query_point,
+             py::arg("query_points"),
+             py::arg("vertices"),
+             py::arg("triangles"),
+             py::arg("return_sdf") = false,
+             py::arg("return_prj_pts") = true,
+             py::arg("sign_mode") = 0,
+             "Find the closest triangle to each query point. Returns (query_ids, triangle_ids, projected_points, distances)");
 }

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/binds/data_structure/triangle_mesh.cpp

@@ -97,6 +97,21 @@ bool TriangleMesh::is_self_intersection()
     return this->bvh.value().is_self_intersection(this->vertices, this->triangles);
 }
 
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> TriangleMesh::query_points(
+    const torch::Tensor &query_pts,
+    bool return_sdf,
+    bool return_prj_pts,
+    int sign_mode,
+    int distance_mode)
+{
+    if (distance_mode == 0) {
+        this->build_bvh();
+        return this->bvh.value().query_point(query_pts, this->vertices, this->triangles, return_sdf, return_prj_pts, sign_mode);
+    } else {
+        throw std::runtime_error("distance_mode != 0 not implemented yet");
+    }
+}
+
 std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> TriangleMesh::get_ray_intersection(
     const torch::Tensor &ray_origins,
     const torch::Tensor &ray_dirs,
@@ -338,6 +353,13 @@ void bind_ds_triangle_mesh(py::module_ &m)
              py::arg("ray_dirs"),
              py::arg("return_distance") = false,
              "Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])")
+        .def("query_points", &TriangleMesh::query_points,
+             py::arg("query_pts"),
+             py::arg("return_sdf") = false,
+             py::arg("return_prj_pts") = true,
+             py::arg("sign_mode") = 0,
+             py::arg("distance_mode") = 0,
+             "Query points against the mesh. Returns (query_ids, triangle_ids, projected_points, distances)")
         .def_property_readonly("edges", &TriangleMesh::get_edges)
         .def_property_readonly("edge_to_triangle_offsets", &TriangleMesh::get_edge_to_triangle_offsets)
         .def_property_readonly("edge_to_triangle_counts", &TriangleMesh::get_edge_to_triangle_counts)

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/data_structure/bvh.cu

@@ -542,4 +542,97 @@ namespace bvh
             max_capacity
         );
     }
+
+    __global__ void query_point_bvh_kernel(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3* __restrict__ query_points,
+        const float3* __restrict__ bvh_aabb_mins,
+        const float3* __restrict__ bvh_aabb_maxs,
+        const int2* __restrict__ bvh_children,
+        const int* __restrict__ object_ids,
+        int64_t* __restrict__ out_query_ids,
+        int64_t* __restrict__ out_object_ids,
+        float* __restrict__ out_distances)
+    {
+        uint32_t q_idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (q_idx >= num_queries) return;
+
+        float3 p = query_points[q_idx];
+
+        int stack[BVH_STACK_SIZE];
+        int stack_ptr = 0;
+        stack[0] = 0; 
+        
+        float best_dist_sq = FLT_MAX;
+        int best_leaf_original_id = -1;
+
+        while (stack_ptr >= 0) 
+        {
+            int node_idx = stack[stack_ptr--]; 
+
+            float dist_sq = aabb::compute_squared_distance(p, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            
+            if (dist_sq > best_dist_sq) continue; // Prune branch
+
+            if (node_idx >= num_objects - 1) 
+            {
+                if (dist_sq < best_dist_sq) {
+                    best_dist_sq = dist_sq;
+                    best_leaf_original_id = object_ids[node_idx - (num_objects - 1)];
+                }
+            } 
+            else 
+            {
+                if (stack_ptr + 2 < BVH_STACK_SIZE)
+                {
+                    int2 children = bvh_children[node_idx];
+                    
+                    float dist_l = aabb::compute_squared_distance(p, bvh_aabb_mins[children.x], bvh_aabb_maxs[children.x]);
+                    float dist_r = aabb::compute_squared_distance(p, bvh_aabb_mins[children.y], bvh_aabb_maxs[children.y]);
+                    
+                    if (dist_l > dist_r) {
+                        stack[++stack_ptr] = children.x; 
+                        stack[++stack_ptr] = children.y;
+                    } else {
+                        stack[++stack_ptr] = children.y;
+                        stack[++stack_ptr] = children.x;
+                    }
+                }
+            }
+        }
+        
+        out_query_ids[q_idx] = q_idx;
+        out_object_ids[q_idx] = best_leaf_original_id;
+        out_distances[q_idx] = sqrtf(best_dist_sq);
+    }
+
+    void query_point(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3* __restrict__ query_points,
+        const float3* __restrict__ bvh_aabb_mins,
+        const float3* __restrict__ bvh_aabb_maxs,
+        const int2* __restrict__ bvh_children,
+        const int* __restrict__ object_ids,
+        int64_t* __restrict__ out_query_ids,
+        int64_t* __restrict__ out_object_ids,
+        float* __restrict__ out_distances)
+    {
+        uint32_t threads = NTHREADS;
+        uint32_t blocks = (num_queries + threads - 1) / threads;
+
+        query_point_bvh_kernel<<<blocks, threads>>>(
+            num_queries,
+            num_objects,
+            query_points,
+            bvh_aabb_mins,
+            bvh_aabb_maxs,
+            bvh_children,
+            object_ids,
+            out_query_ids,
+            out_object_ids,
+            out_distances
+        );
+    }
 }

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/data_structure/bvh.h

@@ -33,7 +33,11 @@ public:
 
     std::tuple<torch::Tensor, torch::Tensor> query_ray(
         const torch::Tensor &ray_origins,
-        const torch::Tensor &ray_dirs);
+        const torch::Tensor &ray_dirs,
+        int64_t max_capacity = BVH_MAX_CAPACITY);
+
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> query_point(
+        const torch::Tensor &query_points);
 };
 
 namespace bvh
@@ -88,6 +92,18 @@ namespace bvh
         int64_t *__restrict__ out_object_ids,
         int64_t *__restrict__ hit_counter,
         const int64_t max_capacity);
+
+    __host__ void query_point(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3 *__restrict__ query_points,
+        const float3 *__restrict__ bvh_aabb_mins,
+        const float3 *__restrict__ bvh_aabb_maxs,
+        const int2 *__restrict__ bvh_children,
+        const int *__restrict__ object_ids,
+        int64_t *__restrict__ out_query_ids,
+        int64_t *__restrict__ out_object_ids,
+        float *__restrict__ out_distances);
 }
 
 #endif // BVH_H

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/data_structure/mesh_bvh.cu

@@ -203,3 +203,211 @@ std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> MeshBVH::
         return_distance ? out_distances.slice(0, 0, h_valid_counter) : out_distances
     );
 }
+
+__device__ __forceinline__ float compute_sign_ray_parity(
+    const float3& p,
+    const int best_tri_id,
+    const float3* bvh_aabb_mins,
+    const float3* bvh_aabb_maxs,
+    const int2* bvh_children,
+    const int* object_ids,
+    const float3* vertices,
+    const int3* triangles,
+    const uint32_t num_objects)
+{
+    int3 tri = triangles[best_tri_id];
+    float3 v0 = vertices[tri.x];
+    float3 v1 = vertices[tri.y];
+    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);
+    }
+
+    Ray ray2(p, ray_dir, 0.0f);
+    
+    int hit_count = 0;
+    int stack[BVH_STACK_SIZE];
+    int stack_ptr = 0;
+    stack[0] = 0;
+    
+    while (stack_ptr >= 0) 
+    {
+        int node_idx = stack[stack_ptr--];
+        
+        float t_hit_aabb;
+        if (!ray2.is_intersect_aabb(bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx], t_hit_aabb)) {
+            continue;
+        }
+
+        if (node_idx >= num_objects - 1) 
+        {
+            int tri_id = object_ids[node_idx - (num_objects - 1)];
+            int3 tri = triangles[tri_id];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            
+            float t_hit, u, v;
+            if (T.is_intersect_ray(ray2, t_hit, u, v)) {
+                hit_count++;
+            }
+        } 
+        else 
+        {
+            if (stack_ptr + 2 < BVH_STACK_SIZE)
+            {
+                int2 children = bvh_children[node_idx];
+                stack[++stack_ptr] = children.x;
+                stack[++stack_ptr] = children.y;
+            }
+        }
+    }
+    
+    return (hit_count % 2 == 1) ? -1.0f : 1.0f;
+}
+
+__global__ void query_point_mesh_bvh_kernel(
+    const uint32_t num_queries,
+    const uint32_t num_objects,
+    const float3* __restrict__ query_points,
+    const float3* __restrict__ vertices,
+    const int3* __restrict__ triangles,
+    const float3* __restrict__ bvh_aabb_mins,
+    const float3* __restrict__ bvh_aabb_maxs,
+    const int2* __restrict__ bvh_children,
+    const int* __restrict__ object_ids,
+    int64_t* __restrict__ out_query_ids,
+    int64_t* __restrict__ out_object_ids,
+    float3* __restrict__ out_projected_pts,
+    float* __restrict__ out_distances,
+    bool return_sdf,
+    bool return_prj_pts,
+    int sign_mode)
+{
+    uint32_t q_idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (q_idx >= num_queries) return;
+
+    float3 p = query_points[q_idx];
+
+    int stack[BVH_STACK_SIZE];
+    int stack_ptr = 0;
+    stack[0] = 0; 
+    
+    float best_dist_sq = FLT_MAX;
+    int best_tri_id = -1;
+    float3 best_pt = make_float3(0, 0, 0);
+
+    while (stack_ptr >= 0) 
+    {
+        int node_idx = stack[stack_ptr--]; 
+
+        float dist_sq = aabb::compute_squared_distance(p, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+        
+        if (dist_sq > best_dist_sq) continue; // Prune branch
+
+        if (node_idx >= num_objects - 1) 
+        {
+            int tri_id = object_ids[node_idx - (num_objects - 1)];
+            int3 tri = triangles[tri_id];
+            Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
+            
+            float3 closest_pt = T.compute_closest_point(p);
+            float3 diff = p - closest_pt;
+            float pt_dist_sq = maths::dot(diff, diff);
+
+            if (pt_dist_sq < best_dist_sq) {
+                best_dist_sq = pt_dist_sq;
+                best_tri_id = tri_id;
+                best_pt = closest_pt;
+            }
+        } 
+        else 
+        {
+            if (stack_ptr + 2 < BVH_STACK_SIZE)
+            {
+                int2 children = bvh_children[node_idx];
+                
+                float dist_l = aabb::compute_squared_distance(p, bvh_aabb_mins[children.x], bvh_aabb_maxs[children.x]);
+                float dist_r = aabb::compute_squared_distance(p, bvh_aabb_mins[children.y], bvh_aabb_maxs[children.y]);
+                
+                if (dist_l > dist_r) {
+                    stack[++stack_ptr] = children.x; 
+                    stack[++stack_ptr] = children.y;
+                } else {
+                    stack[++stack_ptr] = children.y;
+                    stack[++stack_ptr] = children.x;
+                }
+            }
+        }
+    }
+    
+    float dist = sqrtf(best_dist_sq);
+
+    if (return_sdf && sign_mode == 0) {
+        dist *= compute_sign_ray_parity(p, best_tri_id, bvh_aabb_mins, bvh_aabb_maxs, bvh_children, object_ids, vertices, triangles, num_objects);
+    }
+
+    out_query_ids[q_idx] = q_idx;
+    out_object_ids[q_idx] = best_tri_id;
+    if (return_prj_pts && out_projected_pts != nullptr) {
+        out_projected_pts[q_idx] = best_pt;
+    }
+    out_distances[q_idx] = dist;
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> MeshBVH::query_point(
+    const torch::Tensor &query_points,
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles,
+    bool return_sdf,
+    bool return_prj_pts,
+    int sign_mode)
+{
+    if (sign_mode != 0) {
+        throw std::runtime_error("sign_mode != 0 not implemented yet");
+    }
+
+    int num_queries = query_points.size(0);
+    int num_objects = this->object_ids.size(0);
+
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(query_points.device());
+    auto options_f32 = torch::TensorOptions().dtype(torch::kFloat32).device(query_points.device());
+
+    torch::Tensor out_query_ids = torch::empty({num_queries}, options_i64);
+    torch::Tensor out_object_ids = torch::empty({num_queries}, options_i64);
+    torch::Tensor out_projected_pts;
+    if (return_prj_pts) {
+        out_projected_pts = torch::empty({num_queries, 3}, options_f32);
+    } else {
+        out_projected_pts = torch::empty({0, 3}, options_f32);
+    }
+    torch::Tensor out_distances = torch::empty({num_queries}, options_f32);
+
+    int threads = NTHREADS;
+    int blocks = (num_queries + threads - 1) / threads;
+
+    query_point_mesh_bvh_kernel<<<blocks, threads>>>(
+        num_queries,
+        num_objects,
+        (const float3*)query_points.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_query_ids.data_ptr<int64_t>(),
+        out_object_ids.data_ptr<int64_t>(),
+        return_prj_pts ? (float3*)out_projected_pts.data_ptr<float>() : nullptr,
+        out_distances.data_ptr<float>(),
+        return_sdf,
+        return_prj_pts,
+        sign_mode
+    );
+
+    return std::make_tuple(out_query_ids, out_object_ids, out_projected_pts, out_distances);
+}

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/data_structure/mesh_bvh.h

@@ -28,6 +28,14 @@ public:
         const torch::Tensor &vertices,
         const torch::Tensor &triangles,
         bool return_distance = false);
+
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> query_point(
+        const torch::Tensor &query_points,
+        const torch::Tensor &vertices,
+        const torch::Tensor &triangles,
+        bool return_sdf = false,
+        bool return_prj_pts = true,
+        int sign_mode = 0);
 };
 
 #endif // MESH_BVH_H

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/data_structure/triangle_mesh.h

@@ -61,6 +61,13 @@ public:
     torch::Tensor get_self_intersection();
     bool is_self_intersection();
 
+    std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> query_points(
+        const torch::Tensor &query_pts,
+        bool return_sdf = false,
+        bool return_prj_pts = true,
+        int sign_mode = 0,
+        int distance_mode = 0);
+
     std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> get_ray_intersection(
         const torch::Tensor &ray_origins,
         const torch::Tensor &ray_dirs,

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/primitive/aabb.h

@@ -112,6 +112,24 @@ namespace aabb
         out_surface_area = 2.0f * (dim_size.x * dim_size.y + dim_size.x * dim_size.z + dim_size.y * dim_size.z);
     }
 
+    __device__ __forceinline__ float compute_squared_distance(
+        const float3 &p,
+        const float3 &aabb_min,
+        const float3 &aabb_max)
+    {
+        float d2 = 0.0f;
+        if (p.x < aabb_min.x) d2 += (aabb_min.x - p.x) * (aabb_min.x - p.x);
+        else if (p.x > aabb_max.x) d2 += (p.x - aabb_max.x) * (p.x - aabb_max.x);
+        
+        if (p.y < aabb_min.y) d2 += (aabb_min.y - p.y) * (aabb_min.y - p.y);
+        else if (p.y > aabb_max.y) d2 += (p.y - aabb_max.y) * (p.y - aabb_max.y);
+        
+        if (p.z < aabb_min.z) d2 += (aabb_min.z - p.z) * (aabb_min.z - p.z);
+        else if (p.z > aabb_max.z) d2 += (p.z - aabb_max.z) * (p.z - aabb_max.z);
+        
+        return d2;
+    }
+
     __device__ __forceinline__ bool test_aabb_overlap(
         const float3 &query_aabb_min,
         const float3 &query_aabb_max,

{conquer3d-0.2.5 → conquer3d-0.2.6}/conquer3d/csrc/primitive/triangles.h

@@ -43,6 +43,50 @@ struct Triangle {
         }
         return false;
     }
+
+    __host__ __device__ __forceinline__ float3 compute_closest_point(const float3& p) const {
+        float3 ab = v1 - v0;
+        float3 ac = v2 - v0;
+        float3 ap = p - v0;
+
+        float d1 = maths::dot(ab, ap);
+        float d2 = maths::dot(ac, ap);
+        if (d1 <= 0.0f && d2 <= 0.0f) return v0;
+
+        float3 bp = p - v1;
+        float d3 = maths::dot(ab, bp);
+        float d4 = maths::dot(ac, bp);
+        if (d3 >= 0.0f && d4 <= d3) return v1;
+
+        float vc = d1*d4 - d3*d2;
+        if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f) {
+            float v = d1 / (d1 - d3);
+            return v0 + v * ab;
+        }
+
+        float3 cp = p - v2;
+        float d5 = maths::dot(ab, cp);
+        float d6 = maths::dot(ac, cp);
+        if (d6 >= 0.0f && d5 <= d6) return v2;
+
+        float vb = d5*d2 - d1*d6;
+        if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f) {
+            float w = d2 / (d2 - d6);
+            return v0 + w * ac;
+        }
+
+        float va = d3*d6 - d5*d4;
+        if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f) {
+            float w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+            return v1 + w * (v2 - v1);
+        }
+
+        float denom = 1.0f / (va + vb + vc);
+        float v = vb * denom;
+        float w = vc * denom;
+        return v0 + ab * v + ac * w;
+    }
+
     __host__ __device__ __forceinline__ float3 compute_normal() const {
         float3 edge1 = v1 - v0;
         float3 edge2 = v2 - v0;

{conquer3d-0.2.5 → conquer3d-0.2.6/conquer3d.egg-info}/PKG-INFO

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

{conquer3d-0.2.5 → conquer3d-0.2.6}/pyproject.toml

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