conquer3d 0.1.9__tar.gz

conquer3d-0.1.9/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Do Hoang Khoi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

conquer3d-0.1.9/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: conquer3d
+Version: 0.1.9
+Summary: Geometric Cuda Tool Box
+Author-email: Do Hoang Khoi <khoido8899@gmail.com>
+License: 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
+Project-URL: Issues, https://github.com/KhoiDOO/conquer3d/issues
+Keywords: geometry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Provides-Extra: cuda
+Requires-Dist: cuda-toolkit==12.8.2; extra == "cuda"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# 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
+python -m build --sdist
+twine upload dist/*
+```
+
+# 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}
+}
+```
+
+## 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)

conquer3d-0.1.9/README.md

@@ -0,0 +1,69 @@
+# 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
+python -m build --sdist
+twine upload dist/*
+```
+
+# 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}
+}
+```
+
+## 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)

conquer3d-0.1.9/conquer3d/_C.pyi

@@ -0,0 +1,69 @@
+"""
+Geocutool Python bindings
+"""
+from __future__ import annotations
+import torch
+import typing
+__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'PGSBVH', 'compute_gs_aabb_func', 'compute_gs_covi_func', '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).
+        """
+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 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.
+        """
+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 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.1.9/conquer3d/__init__.py

@@ -0,0 +1,5 @@
+import torch
+
+from . import _C
+
+__all__ = ['_C']

conquer3d-0.1.9/conquer3d/csrc/binds/data_structure/bvh.cpp

@@ -0,0 +1,135 @@
+#include <torch/extension.h>
+#include "../../data_structure/bvh.h"
+#include "../../check.h"
+
+#include <pybind11/pybind11.h>
+#include <optional>
+#include <vector>
+
+namespace py = pybind11;
+
+BVH::BVH(
+    const torch::Tensor &in_aabb_mins,
+    const torch::Tensor &in_aabb_maxs)
+{
+    CHECK_INPUT(in_aabb_mins);
+    CHECK_INPUT(in_aabb_maxs);
+    TORCH_CHECK(in_aabb_mins.scalar_type() == torch::kFloat32, "aabb_mins must be float32");
+    TORCH_CHECK(in_aabb_maxs.scalar_type() == torch::kFloat32, "aabb_maxs must be float32");
+    TORCH_CHECK(in_aabb_mins.size(1) == 3, "aabb_mins must have shape (N, 3)");
+    TORCH_CHECK(in_aabb_maxs.size(1) == 3, "aabb_maxs must have shape (N, 3)");
+
+    this->num_objects = static_cast<uint32_t>(in_aabb_mins.size(0));
+    
+    if (this->num_objects == 0)
+    {
+        throw std::runtime_error("Cannot build BVH with 0 objects.");
+    }
+
+    if (this->num_objects == 1)
+    {
+        this->num_nodes = 1;
+
+        auto options_int32 = in_aabb_mins.options().dtype(torch::kInt32);
+
+        // The Root is the only Leaf.
+        this->aabb_mins = in_aabb_mins.clone();
+        this->aabb_maxs = in_aabb_maxs.clone();
+        
+        // No children (-1 means null pointer)
+        this->bvh_children = torch::full({1, 2}, -1, options_int32);
+        
+        // The object ID is just index 0
+        this->object_ids = torch::zeros({1}, options_int32);
+        
+        // Bypass the entire Karras CUDA build!
+        return; 
+    }
+
+    // A Binary Tree with N leaves always has 2N - 1 total nodes!
+    this->num_nodes = 2 * this->num_objects - 1;
+    auto options = in_aabb_mins.options();
+
+    // Allocate the full flat arrays
+    this->aabb_mins    = torch::empty({this->num_nodes, 3}, options);
+    this->aabb_maxs    = torch::empty({this->num_nodes, 3}, options);
+    this->bvh_children = torch::empty({this->num_nodes, 2}, options.dtype(torch::kInt32));
+    this->bvh_parents  = torch::empty({this->num_nodes}, options.dtype(torch::kInt32));
+    this->object_ids   = torch::empty({this->num_objects}, options.dtype(torch::kInt32));
+
+    bvh::build(
+        this->num_objects,
+        this->num_nodes,
+        reinterpret_cast<const float3 *>(in_aabb_mins.data_ptr<float>()),
+        reinterpret_cast<const float3 *>(in_aabb_maxs.data_ptr<float>()),
+        reinterpret_cast<float3 *>(this->aabb_mins.data_ptr<float>()),
+        reinterpret_cast<float3 *>(this->aabb_maxs.data_ptr<float>()),
+        reinterpret_cast<int2 *>(this->bvh_children.data_ptr<int>()),
+        reinterpret_cast<int *>(this->bvh_parents.data_ptr<int>()),
+        reinterpret_cast<int *>(this->object_ids.data_ptr<int>())
+    );
+}
+
+std::tuple<torch::Tensor, torch::Tensor> BVH::query(
+    const torch::Tensor &query_aabb_mins,
+    const torch::Tensor &query_aabb_maxs)
+{
+    CHECK_INPUT(query_aabb_mins);
+    CHECK_INPUT(query_aabb_maxs);
+    TORCH_CHECK(query_aabb_mins.scalar_type() == torch::kFloat32, "query_aabb_mins must be float32");
+    TORCH_CHECK(query_aabb_maxs.scalar_type() == torch::kFloat32, "query_aabb_maxs must be float32");
+    TORCH_CHECK(query_aabb_mins.size(1) == 3, "query_aabb_mins must have shape (M, 3)");
+    TORCH_CHECK(query_aabb_maxs.size(1) == 3, "query_aabb_maxs must have shape (M, 3)");
+
+    const uint32_t num_queries = static_cast<uint32_t>(query_aabb_mins.size(0));
+    
+    auto options_int64 = query_aabb_mins.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(
+        num_queries,
+        this->num_objects,
+        reinterpret_cast<const float3 *>(query_aabb_mins.data_ptr<float>()),
+        reinterpret_cast<const float3 *>(query_aabb_maxs.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 &>(),
+             py::arg("in_aabb_mins"), 
+             py::arg("in_aabb_maxs"),
+             "Construct and build the Karras LBVH from Gaussian AABBs.")
+             
+        .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).");
+}