conquer3d 0.2.1__tar.gz → 0.2.5__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.2.1
+Version: 0.2.5
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/KhoiDOO/conquer3d
 Project-URL: Repository, https://github.com/KhoiDOO/conquer3d.git
 Project-URL: Documentation, https://github.com/KhoiDOO/conquer3d#readme
@@ -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}
 }
 ```
 
@@ -90,5 +127,7 @@ series = {EGGH-HPG'12}
 ## Repository
 - [cuBQL](https://github.com/NVIDIA/cuBQL)
 - [cudaKDTree](https://github.com/ingowald/cudaKDTree)
-- [Kaolin] (https://github.com/NVIDIAGameWorks/kaolin)
-- [Pytorch3D] (https://github.com/facebookresearch/pytorch3d)
+- [Kaolin](https://github.com/NVIDIAGameWorks/kaolin)
+- [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
+- [Open3D](https://www.open3d.org/)
+- [trimesh](https://github.com/mikedh/trimesh)

conquer3d-0.2.5/README.md

@@ -0,0 +1,109 @@
+# Conquer3D
+
+# Setup
+
+## Build from source
+```bash
+git clone https://github.com/KhoiDOO/geocutool.git
+pip install pybind11-stubgen 
+
+# then
+cd geocutool
+pip install -e . --no-build-isolation
+
+# or 
+pip install pybind11-stubgen
+pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
+```
+
+## To run notebooks in examples
+```bash
+conda create -c conda-forge -n geocutool python=3.10 gxx_linux-64=13 gcc_linux-64=13 -y
+conda activate geocutool
+
+conda install nvidia::cuda-toolkit==12.8.2 -y
+
+pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
+
+pip install pybind11-stubgen
+pip install git+https://github.com/KhoiDOO/geocutool.git --no-build-isolation
+
+pip install plotly open3d jupyter trimesh
+```
+
+# Development
+```bash
+pip install build twine
+rm -rf dist
+python -m build --sdist
+twine upload dist/* --verbose
+```
+
+# Reference
+
+## 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}
+}
+```
+
+```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}
+}
+```
+
+## Blog Post
+- [Thinking Parallel, Part I: Collision Detection on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-i-collision-detection-gpu/)
+- [Thinking Parallel, Part II: Tree Traversal on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-ii-tree-traversal-gpu/)
+- [Thinking Parallel, Part III: Tree Construction on the GPU](https://developer.nvidia.com/blog/thinking-parallel-part-iii-tree-construction-gpu/)
+
+## Repository
+- [cuBQL](https://github.com/NVIDIA/cuBQL)
+- [cudaKDTree](https://github.com/ingowald/cudaKDTree)
+- [Kaolin](https://github.com/NVIDIAGameWorks/kaolin)
+- [Pytorch3D](https://github.com/facebookresearch/pytorch3d)
+- [Open3D](https://www.open3d.org/)
+- [trimesh](https://github.com/mikedh/trimesh)

conquer3d-0.2.5/conquer3d/_C.pyi

@@ -0,0 +1,191 @@
+"""
+Geocutool Python bindings
+"""
+from __future__ import annotations
+import torch
+import typing
+__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'MeshBVH', 'PGSBVH', 'TriangleMesh', 'compute_gs_aabb_func', 'compute_gs_covi_func', 'create_sphere', 'solve_gs_neighbor_mahalanobis_radius_func', 'solve_pgs_cluster_tangency_radius_func']
+class BVH:
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH from Gaussian AABBs.
+        """
+    def query(self, query_aabb_mins: torch.Tensor, query_aabb_maxs: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        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).
+        """
+class GSBVH(BVH):
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH for Gaussians.
+        """
+    def query_edge(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, opacities: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find the single highest-density Gaussian intersected by each line segment.
+        """
+    def query_edge_pair(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Find all Gaussians intersected by each line segment.
+        """
+    def query_voxel_pair(self, vx_aabb_mins: torch.Tensor, vx_aabb_maxs: torch.Tensor, means: torch.Tensor, covis: torch.Tensor, opacities: torch.Tensor, gs_aabb_mins: torch.Tensor, gs_aabb_maxs: torch.Tensor, contact_points: torch.Tensor, isos: float | torch.Tensor = 11.345, ar_threshold: float = 0.0, p_threshold: float = 0.0, return_centroids: bool = False, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """
+        Perform exact Broad-to-Narrow phase intersection between Voxels and Gaussians.
+        """
+class KDTree:
+    def __init__(self, points: torch.Tensor) -> None:
+        """
+        Initializes and builds the KDTree on the GPU.
+        """
+    def query(self, query_points: torch.Tensor, k: int = 1, exclude_self: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Queries the KDTree for the K nearest neighbors.
+        """
+class MeshBVH(BVH):
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        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
+        """
+    def is_self_intersection(self, vertices: torch.Tensor, triangles: torch.Tensor) -> bool:
+        """
+        Check if there are any self-intersecting triangle pairs
+        """
+class PGSBVH(BVH):
+    def __init__(self, in_aabb_mins: torch.Tensor, in_aabb_maxs: torch.Tensor) -> None:
+        """
+        Construct and build the Karras LBVH for Planar Gaussians.
+        """
+    def query_edge(self, edge_starts: torch.Tensor, edge_ends: torch.Tensor, means: torch.Tensor, normals: torch.Tensor, opacities: torch.Tensor, covis: torch.Tensor, isos: float | torch.Tensor = 11.345) -> tuple[torch.Tensor, torch.Tensor]:
+        """
+        Find the single highest-density PGS intersected by each line segment.
+        """
+    def query_voxel_pair(self, vx_aabb_mins: torch.Tensor, vx_aabb_maxs: torch.Tensor, means: torch.Tensor, normals: torch.Tensor, covis: torch.Tensor, gs_aabb_mins: torch.Tensor, gs_aabb_maxs: torch.Tensor, isos: float | torch.Tensor = 11.345, return_centroids: bool = False, return_centroid_densities: bool = False, max_capacity: int = 10000000) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor | None, torch.Tensor | None]:
+        """
+        Perform exact Broad-to-Narrow phase intersection between Voxels and PGS.
+        """
+class TriangleMesh:
+    def __init__(self, in_vertices: torch.Tensor, in_triangles: torch.Tensor, in_vertex_normals: torch.Tensor | None = None, in_vertex_colors: torch.Tensor | None = None) -> None:
+        ...
+    def build_bvh(self) -> MeshBVH:
+        ...
+    def compute_edges_to_triangle_map(self) -> None:
+        ...
+    def compute_triangle_areas(self) -> None:
+        ...
+    def compute_triangle_normals(self) -> None:
+        ...
+    def compute_vertices_to_triangle_map(self) -> None:
+        ...
+    def get_edges_to_triangle_map(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        ...
+    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:
+        ...
+    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:
+        ...
+    @property
+    def bvh(self) -> MeshBVH:
+        ...
+    @property
+    def edge_to_triangle_counts(self) -> torch.Tensor:
+        ...
+    @property
+    def edge_to_triangle_indices(self) -> torch.Tensor:
+        ...
+    @property
+    def edge_to_triangle_offsets(self) -> torch.Tensor:
+        ...
+    @property
+    def edges(self) -> torch.Tensor:
+        ...
+    @property
+    def euler_characteristic(self) -> int:
+        ...
+    @property
+    def genus(self) -> int:
+        ...
+    @property
+    def num_triangles(self) -> int:
+        ...
+    @property
+    def surface_area(self) -> torch.Tensor:
+        ...
+    @property
+    def triangle_areas(self) -> torch.Tensor:
+        ...
+    @property
+    def triangle_normals(self) -> torch.Tensor:
+        ...
+    @property
+    def triangles(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_colors(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_normals(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_counts(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_indices(self) -> torch.Tensor:
+        ...
+    @property
+    def vertex_to_triangle_offsets(self) -> torch.Tensor:
+        ...
+    @property
+    def vertices(self) -> torch.Tensor:
+        ...
+def compute_gs_aabb_func(means: torch.Tensor, scales: torch.Tensor, covis: torch.Tensor, isos: torch.Tensor | None, iso: float, tol: float, level: int) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+    Compute AABB for 3D Gaussians
+    """
+def compute_gs_covi_func(means: torch.Tensor, rotations: torch.Tensor, scales: torch.Tensor, rotnorm: bool, tol: float, level: int) -> torch.Tensor:
+    """
+    Compute covariance matrices for 3D Gaussians
+    """
+def create_sphere(sectors: int = 32, stacks: int = 16, radius: float = 1.0) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Creates a UV sphere returning (vertices, triangles) tensors on the CPU.
+    """
+def solve_gs_neighbor_mahalanobis_radius_func(means: torch.Tensor, covis: torch.Tensor, k: int) -> torch.Tensor:
+    """
+    Solve Gaussian Neighbor Mahalanobis Radius
+    """
+def solve_pgs_cluster_tangency_radius_func(means: torch.Tensor, normals: torch.Tensor, covis: torch.Tensor, k: int = 16) -> tuple[torch.Tensor, torch.Tensor]:
+    ...

conquer3d-0.2.5/conquer3d/__init__.py

@@ -0,0 +1,8 @@
+import torch
+
+from . import _C
+from . import creation
+from . import data_structure
+from . import primitive
+
+__all__ = ['_C', 'creation', 'data_structure', 'primitive']

conquer3d-0.2.5/conquer3d/creation/__init__.py

@@ -0,0 +1,5 @@
+from .triangle_creation import create_sphere
+
+__all__ = [
+    "create_sphere",
+]

conquer3d-0.2.5/conquer3d/creation/triangle_creation.py

@@ -0,0 +1,23 @@
+import torch
+from typing import Tuple
+
+from .._C import create_sphere as create_sphere_c
+
+def create_sphere(
+    sectors: int = 32,
+    stacks: int = 16,
+    radius: float = 1.0
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """
+    Creates a UV sphere returning (vertices, triangles) tensors on the CPU.
+
+    Args:
+        sectors (int, optional): Number of longitudinal sectors. Defaults to 32.
+        stacks (int, optional): Number of latitudinal stacks. Defaults to 16.
+        radius (float, optional): Radius of the sphere. Defaults to 1.0.
+
+    Returns:
+        vertices: (N, 3) float32 tensor of vertex positions.
+        triangles: (M, 3) int32 tensor of triangle indices.
+    """
+    return create_sphere_c(sectors, stacks, radius)

conquer3d-0.2.5/conquer3d/csrc/binds/creation/triangle_creation.cpp

@@ -0,0 +1,13 @@
+#include <torch/extension.h>
+#include <pybind11/pybind11.h>
+#include "../../creation/triangle_creation.h"
+
+namespace py = pybind11;
+
+void bind_creation_triangle_creation(py::module_& m) {
+    m.def("create_sphere", &triangle_creation::create_sphere, 
+          py::arg("sectors") = 32, 
+          py::arg("stacks") = 16, 
+          py::arg("radius") = 1.0f,
+          "Creates a UV sphere returning (vertices, triangles) tensors on the CPU.");
+}

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

@@ -120,7 +120,86 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query(
     );
 }
 
-void bind_ds_bvh(py::module &m)
+std::tuple<torch::Tensor, torch::Tensor> BVH::query_self()
+{
+    auto options_int64 = this->aabb_mins.options().dtype(torch::kInt64);
+    
+    if (this->num_objects == 0) {
+        throw std::runtime_error("Cannot query BVH with 0 objects.");
+    }
+    
+    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_self(
+        this->num_objects,
+        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)
+    );
+}
+
+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")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),
@@ -131,5 +210,13 @@ void bind_ds_bvh(py::module &m)
         .def("query", &BVH::query,
              py::arg("query_aabb_mins"), 
              py::arg("query_aabb_maxs"),
-             "Query the BVH with bounding boxes or segments. Returns (query_ids, object_ids).");
+             "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).")
+
+        .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.1 → conquer3d-0.2.5}/conquer3d/csrc/binds/data_structure/gs_bvh.cpp

@@ -312,7 +312,7 @@ std::tuple<torch::Tensor, torch::Tensor> GSBVH::query_edge(
     return std::make_tuple(hit_mask, out_gaus_ids);
 }
 
-void bind_ds_gs_bvh(py::module &m)
+void bind_ds_gs_bvh(py::module_& m)
 {
     py::class_<GSBVH, BVH>(m, "GSBVH")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),

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.1 → conquer3d-0.2.5}/conquer3d/csrc/binds/data_structure/pgs_bvh.cpp

@@ -222,7 +222,7 @@ std::tuple<torch::Tensor, torch::Tensor> PGSBVH::query_edge(
     return std::make_tuple(hit_mask, out_gaus_ids);
 }
 
-void bind_ds_pgs_bvh(py::module &m)
+void bind_ds_pgs_bvh(py::module_& m)
 {
     py::class_<PGSBVH, BVH>(m, "PGSBVH")
         .def(py::init<const torch::Tensor &, const torch::Tensor &>(),