conquer3d 0.2.4__tar.gz → 0.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.4
+Version: 0.2.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -68,17 +68,54 @@ twine upload dist/* --verbose
 ## Research Paper
 ```bibtex
 @inproceedings{2383795.2383801,
-author = {Karras, Tero},
-title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
-year = {2012},
-isbn = {9783905674415},
-publisher = {Eurographics Association},
-address = {Goslar, DEU},
-booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
-pages = {33–37},
-numpages = {5},
-location = {Paris, France},
-series = {EGGH-HPG'12}
+    author = {Karras, Tero},
+    title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
+    year = {2012},
+    isbn = {9783905674415},
+    publisher = {Eurographics Association},
+    address = {Goslar, DEU},
+    booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
+    pages = {33–37},
+    numpages = {5},
+    location = {Paris, France},
+    series = {EGGH-HPG'12}
+}
+```
+
+```bibtex
+@article{10.1080/10867651.1997.10487472,
+    author = {M\"{o}ller, Tomas},
+    title = {A fast triangle-triangle intersection test},
+    year = {1997},
+    issue_date = {1997},
+    publisher = {A. K. Peters, Ltd.},
+    address = {USA},
+    volume = {2},
+    number = {2},
+    issn = {1086-7651},
+    url = {https://doi.org/10.1080/10867651.1997.10487472},
+    doi = {10.1080/10867651.1997.10487472},
+    journal = {J. Graph. Tools},
+    month = nov,
+    pages = {25–30},
+    numpages = {6}
+}
+```
+
+```bibtex
+@inproceedings{10.1145/1198555.1198746,
+    author = {M\"{o}ller, Tomas and Trumbore, Ben},
+    title = {Fast, minimum storage ray/triangle intersection},
+    year = {2005},
+    isbn = {9781450378338},
+    publisher = {Association for Computing Machinery},
+    address = {New York, NY, USA},
+    url = {https://doi.org/10.1145/1198555.1198746},
+    doi = {10.1145/1198555.1198746},
+    pages = {7–es},
+    keywords = {base transformation, intersection, ray tracing, ray/triangle-intersection},
+    location = {Los Angeles, California},
+    series = {SIGGRAPH '05}
 }
 ```
 

{conquer3d-0.2.4 → conquer3d-0.2.5}/README.md

@@ -44,17 +44,54 @@ twine upload dist/* --verbose
 ## Research Paper
 ```bibtex
 @inproceedings{2383795.2383801,
-author = {Karras, Tero},
-title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
-year = {2012},
-isbn = {9783905674415},
-publisher = {Eurographics Association},
-address = {Goslar, DEU},
-booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
-pages = {33–37},
-numpages = {5},
-location = {Paris, France},
-series = {EGGH-HPG'12}
+    author = {Karras, Tero},
+    title = {Maximizing parallelism in the construction of BVHs, octrees, and k-d trees},
+    year = {2012},
+    isbn = {9783905674415},
+    publisher = {Eurographics Association},
+    address = {Goslar, DEU},
+    booktitle = {Proceedings of the Fourth ACM SIGGRAPH / Eurographics Conference on High-Performance Graphics},
+    pages = {33–37},
+    numpages = {5},
+    location = {Paris, France},
+    series = {EGGH-HPG'12}
+}
+```
+
+```bibtex
+@article{10.1080/10867651.1997.10487472,
+    author = {M\"{o}ller, Tomas},
+    title = {A fast triangle-triangle intersection test},
+    year = {1997},
+    issue_date = {1997},
+    publisher = {A. K. Peters, Ltd.},
+    address = {USA},
+    volume = {2},
+    number = {2},
+    issn = {1086-7651},
+    url = {https://doi.org/10.1080/10867651.1997.10487472},
+    doi = {10.1080/10867651.1997.10487472},
+    journal = {J. Graph. Tools},
+    month = nov,
+    pages = {25–30},
+    numpages = {6}
+}
+```
+
+```bibtex
+@inproceedings{10.1145/1198555.1198746,
+    author = {M\"{o}ller, Tomas and Trumbore, Ben},
+    title = {Fast, minimum storage ray/triangle intersection},
+    year = {2005},
+    isbn = {9781450378338},
+    publisher = {Association for Computing Machinery},
+    address = {New York, NY, USA},
+    url = {https://doi.org/10.1145/1198555.1198746},
+    doi = {10.1145/1198555.1198746},
+    pages = {7–es},
+    keywords = {base transformation, intersection, ray tracing, ray/triangle-intersection},
+    location = {Los Angeles, California},
+    series = {SIGGRAPH '05}
 }
 ```
 

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

@@ -14,6 +14,10 @@ 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]:
+        """
+        Query the BVH with rays. Returns (query_ids, object_ids).
+        """
     def query_self(self) -> tuple[torch.Tensor, torch.Tensor]:
         """
         Query the BVH against itself. Returns unique overlapping (query_ids, object_ids).
@@ -49,6 +53,10 @@ class MeshBVH(BVH):
         """
         Construct MeshBVH from Triangle AABBs.
         """
+    def get_ray_intersection(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, vertices: torch.Tensor, triangles: torch.Tensor, return_distance: bool = False) -> typing.Any:
+        """
+        Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])
+        """
     def get_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> torch.Tensor:
         """
         Find all self-intersecting triangle pairs
@@ -87,8 +95,14 @@ class TriangleMesh:
         ...
     def get_non_manifold_vertices(self) -> torch.Tensor:
         ...
+    def get_ray_intersection(self, ray_origins: torch.Tensor, ray_dirs: torch.Tensor, return_distance: bool = False) -> typing.Any:
+        """
+        Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])
+        """
     def get_self_intersection(self) -> torch.Tensor:
-        ...
+        """
+        Find all self-intersecting triangle pairs
+        """
     def get_vertices_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
         ...
     def is_edge_manifold(self, allow_boundary_edge: bool = True) -> bool:
@@ -96,7 +110,9 @@ class TriangleMesh:
     def is_manifold(self, allow_boundary_edge: bool = True) -> bool:
         ...
     def is_self_intersection(self) -> bool:
-        ...
+        """
+        Check if there are any self-intersecting triangle pairs
+        """
     def is_vertex_manifold(self) -> bool:
         ...
     def remove_triangles_by_mask(self, keep_mask: torch.Tensor) -> None:

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

@@ -153,6 +153,52 @@ 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)
+{
+    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)");
+
+    const uint32_t num_queries = static_cast<uint32_t>(ray_origins.size(0));
+    auto options_int64 = ray_origins.options().dtype(torch::kInt64);
+
+    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);
+
+    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)
+    );
+
+    int64_t num_hits = hit_counter.item<int64_t>();
+    num_hits = std::min(num_hits, static_cast<int64_t>(BVH_MAX_CAPACITY));
+
+    return std::make_tuple(
+        out_query_ids.slice(0, 0, num_hits), 
+        out_object_ids.slice(0, 0, num_hits)
+    );
+}
+
 void bind_ds_bvh(py::module_& m)
 {
     py::class_<BVH>(m, "BVH")
@@ -167,5 +213,10 @@ void bind_ds_bvh(py::module_& m)
              "Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).")
              
         .def("query_self", &BVH::query_self,
-             "Query the BVH against itself. Returns unique overlapping (query_ids, object_ids).");
+             "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_dirs"),
+             "Query the BVH with rays. Returns (query_ids, object_ids).");
 }

conquer3d-0.2.5/conquer3d/csrc/binds/data_structure/mesh_bvh.cpp

@@ -0,0 +1,36 @@
+#include <torch/extension.h>
+#include "../../data_structure/mesh_bvh.h"
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void bind_ds_mesh_bvh(py::module_& m)
+{
+    py::class_<MeshBVH, BVH>(m, "MeshBVH")
+        .def(py::init<const torch::Tensor &, const torch::Tensor &>(),
+             py::arg("in_aabb_mins"), 
+             py::arg("in_aabb_maxs"),
+             "Construct MeshBVH from Triangle AABBs.")
+        .def("get_self_intersection", &MeshBVH::get_self_intersection,
+             py::arg("vertices"), 
+             py::arg("triangles"),
+             "Find all self-intersecting triangle pairs")
+        .def("is_self_intersection", &MeshBVH::is_self_intersection,
+             py::arg("vertices"), 
+             py::arg("triangles"),
+             "Check if there are any self-intersecting triangle pairs")
+        .def("get_ray_intersection", [](MeshBVH& self, const torch::Tensor& ray_origins, const torch::Tensor& ray_dirs, const torch::Tensor& vertices, const torch::Tensor& triangles, bool return_distance) -> py::object {
+                 auto result = self.get_ray_intersection(ray_origins, ray_dirs, vertices, triangles, return_distance);
+                 if (return_distance) {
+                     return py::cast(result);
+                 } else {
+                     return py::cast(std::make_tuple(std::get<0>(result), std::get<1>(result), std::get<2>(result)));
+                 }
+             },
+             py::arg("ray_origins"),
+             py::arg("ray_dirs"),
+             py::arg("vertices"),
+             py::arg("triangles"),
+             py::arg("return_distance") = false,
+             "Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_points, [distances])");
+}

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

@@ -97,6 +97,15 @@ 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::get_ray_intersection(
+    const torch::Tensor &ray_origins,
+    const torch::Tensor &ray_dirs,
+    bool return_distance)
+{
+    this->build_bvh();
+    return this->bvh.value().get_ray_intersection(ray_origins, ray_dirs, this->vertices, this->triangles, return_distance);
+}
+
 torch::Tensor TriangleMesh::get_triangle_areas()
 {
     if (!this->triangle_areas.defined())
@@ -313,8 +322,22 @@ void bind_ds_triangle_mesh(py::module_ &m)
         .def_property_readonly("surface_area", &TriangleMesh::get_surface_area)
         .def_property_readonly("bvh", &TriangleMesh::build_bvh)
         .def("build_bvh", &TriangleMesh::build_bvh)
-        .def("get_self_intersection", &TriangleMesh::get_self_intersection)
-        .def("is_self_intersection", &TriangleMesh::is_self_intersection)
+        .def("get_self_intersection", &TriangleMesh::get_self_intersection,
+             "Find all self-intersecting triangle pairs")
+        .def("is_self_intersection", &TriangleMesh::is_self_intersection,
+             "Check if there are any self-intersecting triangle pairs")
+        .def("get_ray_intersection", [](TriangleMesh& self, const torch::Tensor& ray_origins, const torch::Tensor& ray_dirs, bool return_distance) -> py::object {
+                 auto result = self.get_ray_intersection(ray_origins, ray_dirs, return_distance);
+                 if (return_distance) {
+                     return py::cast(result);
+                 } else {
+                     return py::cast(std::make_tuple(std::get<0>(result), std::get<1>(result), std::get<2>(result)));
+                 }
+             },
+             py::arg("ray_origins"),
+             py::arg("ray_dirs"),
+             py::arg("return_distance") = false,
+             "Find all ray-triangle intersections. Returns (ray_ids, triangle_ids, intersect_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.4 → conquer3d-0.2.5}/conquer3d/csrc/data_structure/bvh.cu

@@ -1,5 +1,6 @@
 #include "bvh.h"
 #include "zcurve.h"
+#include "../primitive/ray.h"
 
 #include <thrust/device_vector.h>
 #include <thrust/device_ptr.h>
@@ -453,4 +454,92 @@ namespace bvh
             max_capacity
         );
     }
+
+    __global__ void query_ray_bvh_kernel(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3* __restrict__ ray_origins,
+        const float3* __restrict__ ray_dirs,
+        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,
+        int64_t* __restrict__ hit_counter,
+        const int64_t max_capacity)
+    {
+        uint32_t q_idx = blockIdx.x * blockDim.x + threadIdx.x;
+        if (q_idx >= num_queries) return;
+
+        Ray ray(ray_origins[q_idx], ray_dirs[q_idx]);
+
+        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;
+
+            if (ray.is_intersect_aabb(bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx], t_hit)) 
+            {
+                if (node_idx >= num_objects - 1) 
+                {
+                    int leaf_idx = node_idx - (num_objects - 1);
+                    int original_obj_id = object_ids[leaf_idx];
+
+                    uint64_t write_idx = (uint64_t)atomicAdd((unsigned long long int*)hit_counter, 1ULL);
+
+                    if (write_idx < max_capacity) {
+                        out_query_ids[write_idx] = q_idx;
+                        out_object_ids[write_idx] = original_obj_id;
+                    }
+                } 
+                else 
+                {
+                    if (stack_ptr + 2 < BVH_STACK_SIZE)
+                    {
+                        int2 children = bvh_children[node_idx];
+                        stack[++stack_ptr] = children.x;
+                        stack[++stack_ptr] = children.y;
+                    }
+                }
+            }
+        }
+    }
+
+    void query_ray(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3* __restrict__ ray_origins,
+        const float3* __restrict__ ray_dirs,
+        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,
+        int64_t* __restrict__ hit_counter,
+        const int64_t max_capacity)
+    {
+        uint32_t threads = NTHREADS;
+        uint32_t blocks = (num_queries + threads - 1) / threads;
+
+        query_ray_bvh_kernel<<<blocks, threads>>>(
+            num_queries,
+            num_objects,
+            ray_origins,
+            ray_dirs,
+            bvh_aabb_mins,
+            bvh_aabb_maxs,
+            bvh_children,
+            object_ids,
+            out_query_ids,
+            out_object_ids,
+            hit_counter,
+            max_capacity
+        );
+    }
 }

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

@@ -4,6 +4,7 @@
 #include "../maths/maths.h"
 #include "../constants.h"
 #include "../primitive/aabb.h"
+#include "../primitive/ray.h"
 
 #include <torch/extension.h>
 #include <cuda_runtime.h>
@@ -29,6 +30,10 @@ public:
         const torch::Tensor &query_aabb_maxs);
 
     std::tuple<torch::Tensor, torch::Tensor> query_self();
+
+    std::tuple<torch::Tensor, torch::Tensor> query_ray(
+        const torch::Tensor &ray_origins,
+        const torch::Tensor &ray_dirs);
 };
 
 namespace bvh
@@ -69,6 +74,20 @@ namespace bvh
         int64_t *__restrict__ out_object_ids,
         int64_t *__restrict__ hit_counter,
         const int64_t max_capacity);
+
+    __host__ void query_ray(
+        const uint32_t num_queries,
+        const uint32_t num_objects,
+        const float3 *__restrict__ ray_origins,
+        const float3 *__restrict__ ray_dirs,
+        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,
+        int64_t *__restrict__ hit_counter,
+        const int64_t max_capacity);
 }
 
 #endif // BVH_H

conquer3d-0.2.5/conquer3d/csrc/data_structure/mesh_bvh.cu

@@ -0,0 +1,205 @@
+#include "mesh_bvh.h"
+#include "../primitive/triangles.h"
+#include <thrust/device_vector.h>
+
+
+__global__ void filter_self_intersections_kernel(
+    const int num_pairs,
+    const int64_t* query_ids,
+    const int64_t* object_ids,
+    const float3* vertices,
+    const int3* triangles,
+    int64_t* out_query_ids,
+    int64_t* out_object_ids,
+    int64_t* valid_counter)
+{
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= num_pairs) return;
+
+    int64_t idA = query_ids[idx];
+    int64_t idB = object_ids[idx];
+
+    int3 triA = triangles[idA];
+    int3 triB = triangles[idB];
+
+    // Filter shared vertices
+    if (triA.x == triB.x || triA.x == triB.y || triA.x == triB.z ||
+        triA.y == triB.x || triA.y == triB.y || triA.y == triB.z ||
+        triA.z == triB.x || triA.z == triB.y || triA.z == triB.z) {
+        return;
+    }
+
+    Triangle T1(vertices[triA.x], vertices[triA.y], vertices[triA.z]);
+    Triangle T2(vertices[triB.x], vertices[triB.y], vertices[triB.z]);
+
+    if (triangle::test_intersection(T1, T2)) {
+        uint64_t write_idx = (uint64_t)atomicAdd((unsigned long long int*)valid_counter, 1ULL);
+        out_query_ids[write_idx] = idA;
+        out_object_ids[write_idx] = idB;
+    }
+}
+
+torch::Tensor MeshBVH::get_self_intersection(
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles)
+{
+    // 1. Broad-phase AABB overlap query
+    auto [query_ids, object_ids] = this->query_self();
+    
+    int num_pairs = query_ids.size(0);
+    if (num_pairs == 0) {
+        return torch::empty({0, 2}, torch::TensorOptions().dtype(torch::kInt64).device(query_ids.device()));
+    }
+
+    // 2. Narrow-phase intersection
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(query_ids.device());
+    torch::Tensor out_query_ids = torch::empty({num_pairs}, options_i64);
+    torch::Tensor out_object_ids = torch::empty({num_pairs}, options_i64);
+    torch::Tensor valid_counter = torch::zeros({1}, options_i64);
+
+    int threads = NTHREADS;
+    int blocks = (num_pairs + threads - 1) / threads;
+
+    filter_self_intersections_kernel<<<blocks, threads>>>(
+        num_pairs,
+        query_ids.data_ptr<int64_t>(),
+        object_ids.data_ptr<int64_t>(),
+        (const float3*)vertices.data_ptr<float>(),
+        (const int3*)triangles.data_ptr<int>(),
+        out_query_ids.data_ptr<int64_t>(),
+        out_object_ids.data_ptr<int64_t>(),
+        valid_counter.data_ptr<int64_t>()
+    );
+
+    int64_t h_valid_counter = valid_counter.item<int64_t>();
+
+    if (h_valid_counter == 0) {
+        return torch::empty({0, 2}, options_i64);
+    }
+
+    out_query_ids = out_query_ids.slice(0, 0, h_valid_counter).unsqueeze(1);
+    out_object_ids = out_object_ids.slice(0, 0, h_valid_counter).unsqueeze(1);
+
+    return torch::cat({out_query_ids, out_object_ids}, 1);
+}
+
+bool MeshBVH::is_self_intersection(
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles)
+{
+    torch::Tensor pairs = this->get_self_intersection(vertices, triangles);
+    return pairs.size(0) > 0;
+}
+
+__global__ void filter_ray_triangle_intersections_kernel(
+    const int num_pairs,
+    const int64_t* query_ids,
+    const int64_t* object_ids,
+    const float3* ray_origins,
+    const float3* ray_dirs,
+    const float3* vertices,
+    const int3* triangles,
+    int64_t* out_query_ids,
+    int64_t* out_object_ids,
+    float3* out_intersect_pts,
+    float* out_distances,
+    bool return_distance,
+    int64_t* valid_counter)
+{
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= num_pairs) return;
+
+    int64_t ray_id = query_ids[idx];
+    int64_t tri_id = object_ids[idx];
+
+    Ray ray(ray_origins[ray_id], ray_dirs[ray_id]);
+    
+    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(ray, t_hit, u, v)) {
+        uint64_t write_idx = (uint64_t)atomicAdd((unsigned long long int*)valid_counter, 1ULL);
+        out_query_ids[write_idx] = ray_id;
+        out_object_ids[write_idx] = tri_id;
+        out_intersect_pts[write_idx] = ray.at(t_hit);
+        if (return_distance) {
+            out_distances[write_idx] = t_hit;
+        }
+    }
+}
+
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> MeshBVH::get_ray_intersection(
+    const torch::Tensor &ray_origins,
+    const torch::Tensor &ray_dirs,
+    const torch::Tensor &vertices,
+    const torch::Tensor &triangles,
+    bool return_distance)
+{
+    // 1. Broad-phase BVH query
+    auto [query_ids, object_ids] = this->query_ray(ray_origins, ray_dirs);
+    
+    int num_pairs = query_ids.size(0);
+    auto options_i64 = torch::TensorOptions().dtype(torch::kInt64).device(query_ids.device());
+    auto options_f32 = torch::TensorOptions().dtype(torch::kFloat32).device(query_ids.device());
+
+    if (num_pairs == 0) {
+        return std::make_tuple(
+            torch::empty({0}, options_i64),
+            torch::empty({0}, options_i64),
+            torch::empty({0, 3}, options_f32),
+            torch::empty({0}, options_f32)
+        );
+    }
+
+    // 2. Narrow-phase intersection
+    torch::Tensor out_query_ids = torch::empty({num_pairs}, options_i64);
+    torch::Tensor out_object_ids = torch::empty({num_pairs}, options_i64);
+    torch::Tensor out_intersect_pts = torch::empty({num_pairs, 3}, options_f32);
+    
+    torch::Tensor out_distances;
+    if (return_distance) {
+        out_distances = torch::empty({num_pairs}, options_f32);
+    } else {
+        out_distances = torch::empty({0}, options_f32);
+    }
+    
+    torch::Tensor valid_counter = torch::zeros({1}, options_i64);
+
+    int threads = NTHREADS;
+    int blocks = (num_pairs + threads - 1) / threads;
+
+    filter_ray_triangle_intersections_kernel<<<blocks, threads>>>(
+        num_pairs,
+        query_ids.data_ptr<int64_t>(),
+        object_ids.data_ptr<int64_t>(),
+        (const float3*)ray_origins.data_ptr<float>(),
+        (const float3*)ray_dirs.data_ptr<float>(),
+        (const float3*)vertices.data_ptr<float>(),
+        (const int3*)triangles.data_ptr<int>(),
+        out_query_ids.data_ptr<int64_t>(),
+        out_object_ids.data_ptr<int64_t>(),
+        (float3*)out_intersect_pts.data_ptr<float>(),
+        return_distance ? out_distances.data_ptr<float>() : nullptr,
+        return_distance,
+        valid_counter.data_ptr<int64_t>()
+    );
+
+    int64_t h_valid_counter = valid_counter.item<int64_t>();
+
+    if (h_valid_counter == 0) {
+        return std::make_tuple(
+            torch::empty({0}, options_i64),
+            torch::empty({0}, options_i64),
+            torch::empty({0, 3}, options_f32),
+            torch::empty({0}, options_f32)
+        );
+    }
+
+    return std::make_tuple(
+        out_query_ids.slice(0, 0, h_valid_counter),
+        out_object_ids.slice(0, 0, h_valid_counter),
+        out_intersect_pts.slice(0, 0, h_valid_counter),
+        return_distance ? out_distances.slice(0, 0, h_valid_counter) : out_distances
+    );
+}