conquer3d 0.7.9__tar.gz → 0.8.2__tar.gz

{conquer3d-0.7.9/conquer3d.egg-info → conquer3d-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conquer3d
-Version: 0.7.9
+Version: 0.8.2
 Summary: Geometric Cuda Tool Box
 Author-email: Do Hoang Khoi <khoido8899@gmail.com>
 License-Expression: MIT
@@ -96,58 +96,41 @@ verts.sum().backward()          # gradients flow back into the field
 
 ## 🔬 Qualitative Results
 
-Every figure below is real library output on the bundled benchmark assets, regenerated
-by `docs/_figures/make_figures.py` — nothing is mocked or hand-drawn. More, at full size,
-on the **[showcase](https://khoidoo.github.io/conquer3d/)**.
-
 ### Isosurface extraction
 
-<img src="docs/assets/img/fig-algorithms.webp" alt="Four extractors on one signed distance field" width="100%">
+<img src="docs/assets/img/fig-algorithms.webp" alt="Isosurface extraction" width="100%">
 
-One signed distance field on a 64³ narrow-band grid of 19,329 cells, meshed by four
-extractors — Marching Cubes, MC Asymptotic, Dual Contouring and Dual Marching Cubes —
-with the source mesh on the left. The lower row crops the crease where Marching Cubes
-and Dual Contouring disagree most.
+One signed distance field meshed by four different extractors.
 
-### Sharp features from Hermite data
+### Sharp features
 
-<img src="docs/assets/img/fig-hermite.webp" alt="Dual methods with and without Hermite data" width="100%">
+<img src="docs/assets/img/fig-hermite.webp" alt="Sharp features" width="100%">
 
-Dual Contouring and Dual Marching Cubes run twice each: once with normals interpolated
-from the grid, once with exact Hermite data from `compute_hermite_from_mesh`, which
-ray-casts all 25,832 sign-crossing edges for the true intersection and face normal.
-The crease is reconstructed rather than rounded.
+Exact Hermite data lets the dual methods reconstruct a crease instead of rounding it.
 
-### Detail is a resolution dial
+### Grid resolution
 
-<img src="docs/assets/img/fig-resolution.webp" alt="Resolution ladder from 64 to 2048 cubed" width="100%">
+<img src="docs/assets/img/fig-resolution.webp" alt="Grid resolution" width="100%">
 
-Dual Marching Cubes on the Armadillo at seven grid resolutions from 64³ to 2048³.
-Face count runs from 12,076 to 13,294,500, with Chamfer and Hausdorff distance to the
-source measured at every step.
+The same model extracted from 64³ up to 2048³, with the error measured at each step.
 
-### From mesh to surface, step by step
+### Extraction pipeline
 
-<img src="docs/assets/img/fig-pipeline.webp" alt="Sparse grid construction and extraction" width="100%">
+<img src="docs/assets/img/fig-pipeline.webp" alt="Extraction pipeline" width="100%">
 
-The input mesh, the narrow-band cells allocated around it (7,863 of a possible 64,000
-at 40³), the signed distance shown as a cutaway, the 2,646 bipolar cells, and the
-extracted surface. No dense volume is ever held.
+Every stage of one extraction, from input mesh to extracted surface.
 
-### Six ways to decide inside
+### Sign modes
 
-<img src="docs/assets/img/fig-sign-modes.webp" alt="Six sign determination modes" width="100%">
+<img src="docs/assets/img/fig-sign-modes.webp" alt="Sign modes" width="100%">
 
-One axial slice signed by each of the six sign modes and contoured at zero — ray parity,
-pseudonormal, winding number, flood fill, hybrid consensus, and coarse-fine fill.
+One slice through a mesh, signed by each of the six ways of deciding inside.
 
-### Ray queries against the hierarchies
+### Ray queries
 
-<img src="docs/assets/img/fig-meshbvh.webp" alt="Ray-triangle and ray-voxel queries" width="100%">
+<img src="docs/assets/img/fig-meshbvh.webp" alt="Ray queries" width="100%">
 
-`MeshBVH.get_ray_intersection` returns the triangles a ray pierces; `BVH.query_ray`
-returns the narrow-band cells it crosses. Five rays from five origins, each drawn as far
-as its own first hit.
+Which triangles and which voxels a ray hits, found through the BVH.
 
 ---
 

{conquer3d-0.7.9 → conquer3d-0.8.2}/README.md

@@ -63,58 +63,41 @@ verts.sum().backward()          # gradients flow back into the field
 
 ## 🔬 Qualitative Results
 
-Every figure below is real library output on the bundled benchmark assets, regenerated
-by `docs/_figures/make_figures.py` — nothing is mocked or hand-drawn. More, at full size,
-on the **[showcase](https://khoidoo.github.io/conquer3d/)**.
-
 ### Isosurface extraction
 
-<img src="docs/assets/img/fig-algorithms.webp" alt="Four extractors on one signed distance field" width="100%">
+<img src="docs/assets/img/fig-algorithms.webp" alt="Isosurface extraction" width="100%">
 
-One signed distance field on a 64³ narrow-band grid of 19,329 cells, meshed by four
-extractors — Marching Cubes, MC Asymptotic, Dual Contouring and Dual Marching Cubes —
-with the source mesh on the left. The lower row crops the crease where Marching Cubes
-and Dual Contouring disagree most.
+One signed distance field meshed by four different extractors.
 
-### Sharp features from Hermite data
+### Sharp features
 
-<img src="docs/assets/img/fig-hermite.webp" alt="Dual methods with and without Hermite data" width="100%">
+<img src="docs/assets/img/fig-hermite.webp" alt="Sharp features" width="100%">
 
-Dual Contouring and Dual Marching Cubes run twice each: once with normals interpolated
-from the grid, once with exact Hermite data from `compute_hermite_from_mesh`, which
-ray-casts all 25,832 sign-crossing edges for the true intersection and face normal.
-The crease is reconstructed rather than rounded.
+Exact Hermite data lets the dual methods reconstruct a crease instead of rounding it.
 
-### Detail is a resolution dial
+### Grid resolution
 
-<img src="docs/assets/img/fig-resolution.webp" alt="Resolution ladder from 64 to 2048 cubed" width="100%">
+<img src="docs/assets/img/fig-resolution.webp" alt="Grid resolution" width="100%">
 
-Dual Marching Cubes on the Armadillo at seven grid resolutions from 64³ to 2048³.
-Face count runs from 12,076 to 13,294,500, with Chamfer and Hausdorff distance to the
-source measured at every step.
+The same model extracted from 64³ up to 2048³, with the error measured at each step.
 
-### From mesh to surface, step by step
+### Extraction pipeline
 
-<img src="docs/assets/img/fig-pipeline.webp" alt="Sparse grid construction and extraction" width="100%">
+<img src="docs/assets/img/fig-pipeline.webp" alt="Extraction pipeline" width="100%">
 
-The input mesh, the narrow-band cells allocated around it (7,863 of a possible 64,000
-at 40³), the signed distance shown as a cutaway, the 2,646 bipolar cells, and the
-extracted surface. No dense volume is ever held.
+Every stage of one extraction, from input mesh to extracted surface.
 
-### Six ways to decide inside
+### Sign modes
 
-<img src="docs/assets/img/fig-sign-modes.webp" alt="Six sign determination modes" width="100%">
+<img src="docs/assets/img/fig-sign-modes.webp" alt="Sign modes" width="100%">
 
-One axial slice signed by each of the six sign modes and contoured at zero — ray parity,
-pseudonormal, winding number, flood fill, hybrid consensus, and coarse-fine fill.
+One slice through a mesh, signed by each of the six ways of deciding inside.
 
-### Ray queries against the hierarchies
+### Ray queries
 
-<img src="docs/assets/img/fig-meshbvh.webp" alt="Ray-triangle and ray-voxel queries" width="100%">
+<img src="docs/assets/img/fig-meshbvh.webp" alt="Ray queries" width="100%">
 
-`MeshBVH.get_ray_intersection` returns the triangles a ray pierces; `BVH.query_ray`
-returns the narrow-band cells it crosses. Five rays from five origins, each drawn as far
-as its own first hit.
+Which triangles and which voxels a ray hits, found through the BVH.
 
 ---
 

{conquer3d-0.7.9 → conquer3d-0.8.2}/conquer3d/_C.pyi

@@ -4,7 +4,7 @@ Conquer3D Python bindings
 from __future__ import annotations
 import torch
 import typing
-__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'MeshBVH', 'PGSBVH', 'Ray', 'Triangle', 'TriangleMesh', 'build_sparse_grid_from_active_voxels', 'compute_active_voxels', 'compute_flood_fill', 'compute_flood_fill_cf', 'compute_grid_normal', 'compute_gs_aabb_func', 'compute_gs_covi_func', 'compute_zcurve', 'create_sphere', 'create_tetrahedra', 'create_voxel_cloud_from_tmesh', 'create_voxel_grid', 'create_voxel_grid_from_tmesh', 'dual_contouring', 'dual_contouring_backward', 'dual_marching_cubes', 'dual_marching_cubes_backward', 'get_active_voxel_ids_from_depth', 'marching_cubes', 'marching_cubes_asymptotic', 'marching_cubes_asymptotic_backward', 'marching_cubes_backward', 'marching_tetrahedra', 'marching_tetrahedra_backward', 'marching_tetrahedra_grid', 'marching_tetrahedra_grid_backward', 'one_sided_chamfer_distance', 'one_sided_chamfer_distance_backward', 'single_view_volume_integral', 'solve_gs_neighbor_mahalanobis_radius_func', 'solve_pgs_cluster_tangency_radius_func']
+__all__: list[str] = ['BVH', 'GSBVH', 'KDTree', 'MeshBVH', 'PGSBVH', 'Ray', 'Triangle', 'TriangleMesh', 'build_sparse_grid_from_active_voxels', 'compute_active_voxels', 'compute_flood_fill', 'compute_flood_fill_cf', 'compute_grid_normal', 'compute_gs_aabb_func', 'compute_gs_covi_func', 'compute_superquadric_mesh_func', 'compute_zcurve', 'create_sphere', 'create_tetrahedra', 'create_voxel_cloud_from_tmesh', 'create_voxel_grid', 'create_voxel_grid_from_tmesh', 'dual_contouring', 'dual_contouring_backward', 'dual_marching_cubes', 'dual_marching_cubes_backward', 'get_active_voxel_ids_from_depth', 'marching_cubes', 'marching_cubes_asymptotic', 'marching_cubes_asymptotic_backward', 'marching_cubes_backward', 'marching_tetrahedra', 'marching_tetrahedra_backward', 'marching_tetrahedra_grid', 'marching_tetrahedra_grid_backward', 'one_sided_chamfer_distance', 'one_sided_chamfer_distance_backward', 'single_view_volume_integral', 'solve_gs_neighbor_mahalanobis_radius_func', 'solve_pgs_cluster_tangency_radius_func']
 class BVH:
     """
     
@@ -1450,6 +1450,50 @@ def compute_gs_covi_func(means: torch.Tensor, rotations: torch.Tensor, scales: t
                   >>> from conquer3d._C import compute_gs_covi_func
                   >>> covis = compute_gs_covi_func(means, rotations, scales, True, 1e-6, 0)
     """
+def compute_superquadric_mesh_func(scales: torch.Tensor, exponents: torch.Tensor, rotations: torch.Tensor, translations: torch.Tensor, resolution: int = 30, return_labels: bool = False) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """
+              Tessellates a set of superquadrics into a single triangle mesh (CUDA).
+    
+              Each primitive is meshed analytically from Barr's parametric form on an
+              `(resolution, resolution)` grid of angles spaced by approximately equal arc length,
+              then rotated and translated into world space. The per-primitive meshes are packed
+              into one vertex and triangle array by offsetting indices.
+    
+              Args:
+                  scales (torch.Tensor): (K, 3) float32 semi-axes on CUDA, strictly positive.
+                  exponents (torch.Tensor): (K, 2) float32 shape exponents on CUDA.
+                  rotations (torch.Tensor): (K, 3, 3) float32 local-to-world rotations on CUDA.
+                  translations (torch.Tensor): (K, 3) float32 primitive centres on CUDA.
+                  resolution (int, optional): Angular samples along each axis. Each primitive
+                      contributes `resolution * (resolution - 2) + 2` vertices and
+                      `2 * resolution * (resolution - 2)` triangles. Defaults to 30.
+                  return_labels (bool, optional): If True, also returns the originating primitive
+                      index of every vertex. Defaults to False.
+    
+              Returns:
+                  Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
+                      - vertices (torch.Tensor): (V, 3) float32 world coordinates.
+                      - triangles (torch.Tensor): (F, 3) int32 vertex indices.
+                      - labels (torch.Tensor): (V,) int32 primitive index per vertex, or None
+                        when `return_labels` is False.
+    
+              Note:
+                  The result is a concatenation, not a union: it holds one closed surface per
+                  primitive, and wherever two primitives overlap their triangles pass through one
+                  another with no shared vertices. Each individual primitive is watertight with
+                  Euler characteristic 2.
+    
+              Note:
+                  The surface is evaluated in float64 and narrowed on write. Near the poles a
+                  float32 angle perturbs the cosine by an order of magnitude, and the fractional
+                  power turns that into a visible displacement on exactly the sharp corners this
+                  tessellation exists to capture.
+    
+              Example:
+                  >>> from conquer3d._C import compute_superquadric_mesh_func
+                  >>> verts, tris, _ = compute_superquadric_mesh_func(
+                  ...     scales, exponents, rotations, translations, 40)
+    """
 def compute_zcurve(points: torch.Tensor) -> torch.Tensor:
     """
               Computes 30-bit 3D Morton space-filling Z-curve codes for points in normalized [0, 1]^3.

{conquer3d-0.7.9 → conquer3d-0.8.2}/conquer3d/conversion/__init__.py

@@ -1,9 +1,7 @@
 """Geometric format and volumetric conversion pipelines.
 
-This module provides bidirectional conversions between:
-- Dense voxel grids and sparse COO coordinates (`voxel2sparse`, `sparse2voxel`).
-- Dense occupancy grids and sparse COO indices (`dense_occ2sparse_coo`, `sparse_coo2dense_occ`).
-- Triangle meshes and dense/sparse voxel signed distance fields (`tmesh2voxel`, `tmesh2sparse`, `tmesh2voxelcloud`).
+Bidirectional conversions between dense grids, sparse COO coordinates, occupancy volumes,
+and the signed distance fields built from a triangle mesh.
 """
 
 from .grid import (

{conquer3d-0.7.9 → conquer3d-0.8.2}/conquer3d/csrc/binds/creation/triangle_creation.cpp

@@ -4,9 +4,10 @@
 
 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,
+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,
           R"pbdoc(
           Generates a parameterized UV sphere mesh on CPU.
 
@@ -25,8 +26,7 @@ void bind_creation_triangle_creation(py::module_ &m) {
               >>> from conquer3d._C import create_sphere
               >>> verts, tris = create_sphere(sectors=32, stacks=16, radius=1.0)
           )pbdoc");
-    m.def("create_tetrahedra", &triangle_creation::create_tetrahedra,
-          py::arg("radius") = 1.0f,
+    m.def("create_tetrahedra", &triangle_creation::create_tetrahedra, py::arg("radius") = 1.0f,
           R"pbdoc(
           Generates a regular 4-faced tetrahedron mesh inscribed in a sphere of given radius on CPU.
 

{conquer3d-0.7.9 → conquer3d-0.8.2}/conquer3d/csrc/binds/data_structure/bvh.cpp

@@ -8,9 +8,7 @@
 
 namespace py = pybind11;
 
-BVH::BVH(
-    const torch::Tensor &in_aabb_mins,
-    const torch::Tensor &in_aabb_maxs)
+BVH::BVH(const torch::Tensor &in_aabb_mins, const torch::Tensor &in_aabb_maxs)
 {
     CHECK_INPUT(in_aabb_mins);
     CHECK_INPUT(in_aabb_maxs);
@@ -57,21 +55,17 @@ BVH::BVH(
     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>()));
+    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)
+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);
@@ -94,27 +88,21 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query(
 
     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));
+    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));
+    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_self()
@@ -130,29 +118,23 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query_self()
     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));
+    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));
+    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,
-    int64_t max_capacity)
+std::tuple<torch::Tensor, torch::Tensor> BVH::query_ray(const torch::Tensor &ray_origins, const torch::Tensor &ray_dirs,
+                                                        int64_t max_capacity)
 {
     CHECK_INPUT(ray_origins);
     CHECK_INPUT(ray_dirs);
@@ -165,19 +147,11 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query_ray(
     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,
-        (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);
+    bvh::query_ray(num_queries, this->num_objects, (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>();
 
@@ -189,18 +163,13 @@ std::tuple<torch::Tensor, torch::Tensor> BVH::query_ray(
 
     if (h_hit_counter == 0)
     {
-        return std::make_tuple(
-            torch::empty({0}, options_i64),
-            torch::empty({0}, options_i64));
+        return std::make_tuple(torch::empty({0}, options_i64), torch::empty({0}, options_i64));
     }
 
-    return std::make_tuple(
-        out_query_ids.slice(0, 0, h_hit_counter),
-        out_object_ids.slice(0, 0, h_hit_counter));
+    return std::make_tuple(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)
+std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> BVH::query_point(const torch::Tensor &query_points)
 {
     CHECK_INPUT(query_points);
 
@@ -214,21 +183,16 @@ std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> BVH::query_point(
     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>());
+        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) {
+void bind_ds_bvh(py::module_ &m)
+{
     py::class_<BVH>(m, "BVH", R"pbdoc(
         GPU-accelerated Linear Bounding Volume Hierarchy (LBVH) built using Karras (2012) Radix LBVH algorithm.
 
@@ -238,8 +202,7 @@ void bind_ds_bvh(py::module_ &m) {
             >>> bvh = BVH(aabb_mins, aabb_maxs)
             >>> query_ids, obj_ids = bvh.query(query_mins, query_maxs)
         )pbdoc")
-        .def(py::init<const torch::Tensor &, const torch::Tensor &>(),
-             py::arg("in_aabb_mins"), py::arg("in_aabb_maxs"),
+        .def(py::init<const torch::Tensor &, const torch::Tensor &>(), py::arg("in_aabb_mins"), py::arg("in_aabb_maxs"),
              R"pbdoc(
              Constructs and builds the GPU BVH from primitive AABBs.
 
@@ -250,8 +213,7 @@ void bind_ds_bvh(py::module_ &m) {
              Example:
                  >>> bvh = BVH(aabb_mins, aabb_maxs)
              )pbdoc")
-        .def("query", &BVH::query,
-             py::arg("query_aabb_mins"), py::arg("query_aabb_maxs"),
+        .def("query", &BVH::query, py::arg("query_aabb_mins"), py::arg("query_aabb_maxs"),
              R"pbdoc(
              Queries the BVH with bounding boxes for broad-phase collision.
 
@@ -279,8 +241,8 @@ void bind_ds_bvh(py::module_ &m) {
              Example:
                  >>> q_ids, obj_ids = bvh.query_self()
              )pbdoc")
-        .def("query_ray", &BVH::query_ray,
-             py::arg("ray_origins"), py::arg("ray_dirs"), py::arg("max_capacity") = BVH_MAX_CAPACITY,
+        .def("query_ray", &BVH::query_ray, py::arg("ray_origins"), py::arg("ray_dirs"),
+             py::arg("max_capacity") = BVH_MAX_CAPACITY,
              R"pbdoc(
              Finds all ray-AABB intersections using fast Kay-Kajiya slab testing.
 
@@ -297,8 +259,7 @@ void bind_ds_bvh(py::module_ &m) {
              Example:
                  >>> ray_ids, obj_ids = bvh.query_ray(origins, dirs)
              )pbdoc")
-        .def("query_point", &BVH::query_point,
-             py::arg("query_points"),
+        .def("query_point", &BVH::query_point, py::arg("query_points"),
              R"pbdoc(
              Finds the closest leaf AABB and distance to each 3D query point.