conquer3d 0.7.7__tar.gz → 0.7.8__tar.gz

{conquer3d-0.7.7/conquer3d.egg-info → conquer3d-0.7.8}/PKG-INFO

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

{conquer3d-0.7.7 → conquer3d-0.7.8}/conquer3d/csrc/data_structure/bvh.cu

@@ -5,6 +5,7 @@
 
 #include "bvh.h"
 #include "zcurve.h"
+#include "bvh_traverse.cuh"
 #include "../primitive/ray.h"
 
 #include <thrust/device_vector.h>
@@ -434,41 +435,19 @@ __global__ void query_bvh_kernel(
         float3 q_max = query_maxs[q_idx];
 
         // The local thread stack
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        
-        // Push the Root Node (Index 0) to start
-        stack[0] = 0; 
-
-        while (stack_ptr >= 0) 
-        {
-            int node_idx = stack[stack_ptr--]; 
-
-            if (aabb::test_aabb_overlap(q_min, q_max, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx])) 
-            {
-                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;
-                    }
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                return aabb::test_aabb_overlap(q_min, q_max,
+                    bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            },
+            [&] (int 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] = object_ids[leaf_idx];
                 }
-            }
-        }
+                return true;
+            });
     }
 
     void query(
@@ -545,42 +524,22 @@ __global__ void query_self_bvh_kernel(
         float3 q_max = bvh_aabb_maxs[node_offset + leaf_idx];
         int original_q_id = object_ids[leaf_idx];
 
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        stack[0] = 0; 
-
-        while (stack_ptr >= 0) 
-        {
-            int node_idx = stack[stack_ptr--]; 
-
-            if (aabb::test_aabb_overlap(q_min, q_max, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx])) 
-            {
-                if (node_idx >= num_objects - 1) 
-                {
-                    int other_leaf_idx = node_idx - (num_objects - 1);
-                    int original_obj_id = object_ids[other_leaf_idx];
-
-                    if (original_q_id < original_obj_id) 
-                    {
-                        uint64_t write_idx = (uint64_t)atomicAdd((unsigned long long int*)hit_counter, 1ULL);
-
-                        if (write_idx < max_capacity) {
-                            out_query_ids[write_idx] = original_q_id;
-                            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;
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                return aabb::test_aabb_overlap(q_min, q_max,
+                    bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            },
+            [&] (int other_leaf_idx) {
+                int original_obj_id = object_ids[other_leaf_idx];
+                if (original_q_id < original_obj_id) {
+                    uint64_t write_idx = (uint64_t)atomicAdd((unsigned long long int*)hit_counter, 1ULL);
+                    if (write_idx < max_capacity) {
+                        out_query_ids[write_idx] = original_q_id;
+                        out_object_ids[write_idx] = original_obj_id;
                     }
                 }
-            }
-        }
+                return true;
+            });
     }
 
     void query_self(
@@ -655,40 +614,20 @@ __global__ void query_ray_bvh_kernel(
 
         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;
-                    }
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                float t_hit;
+                return ray.is_intersect_aabb(bvh_aabb_mins[node_idx],
+                                             bvh_aabb_maxs[node_idx], t_hit);
+            },
+            [&] (int 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] = object_ids[leaf_idx];
                 }
-            }
-        }
+                return true;
+            });
     }
 
     void query_ray(

conquer3d-0.7.8/conquer3d/csrc/data_structure/bvh_traverse.cuh

@@ -0,0 +1,82 @@
+/**
+ * @file bvh_traverse.cuh
+ * @brief Shared stack-based descent over a Linear BVH.
+ *
+ * @details Every query in the library walks the hierarchy the same way: pop a node, ask
+ * whether it is worth entering, and either visit it as a leaf or push its two children.
+ * Only the node test and the leaf action differ. Writing that loop once and passing those
+ * two steps as functors keeps the traversal -- including the stack bound, the leaf index
+ * arithmetic and the overflow guard -- in a single place, so a fix lands everywhere rather
+ * than in one of eighteen copies.
+ *
+ * The functors are device lambdas and are fully inlined, so the generated code matches the
+ * hand-written loop it replaces.
+ *
+ * @note Two query shapes are deliberately *not* expressed here and remain hand-written:
+ * nearest-point search, which pushes the closer child last and prunes each child against
+ * the running best distance, and the Fast Winding Number descent, which does work on the
+ * branch where the node test *fails* rather than skipping it. Forcing either into this
+ * interface would obscure it for no gain.
+ */
+
+#ifndef BVH_TRAVERSE_CUH
+#define BVH_TRAVERSE_CUH
+
+#include "../constants.h"
+#include <cuda_runtime.h>
+
+namespace bvh
+{
+    /**
+     * @brief Walks the hierarchy, visiting every leaf the node test admits.
+     *
+     * @tparam NodeTest  Callable `bool(int node_idx)`; return false to prune the subtree.
+     * @tparam LeafVisit Callable `bool(int leaf_idx)` receiving the leaf's slot in
+     *         `object_ids`; return false to abandon the traversal, which is how
+     *         any-hit queries stop at their first result.
+     *
+     * @param[in] num_objects Number of primitives $N$; internal nodes occupy $[0, N-1)$ and
+     *     leaves $[N-1, 2N-1)$.
+     * @param[in] children Device array of $N - 1$ child index pairs.
+     * @param[in] node_test Predicate deciding whether to enter a node.
+     * @param[in] leaf_visit Action performed at an admitted leaf.
+     *
+     * @warning The stack holds `BVH_STACK_SIZE` entries in local memory. A hierarchy deeper
+     * than that silently drops the remaining children rather than failing, so a
+     * pathologically unbalanced tree can under-report. Morton ordering keeps real trees
+     * far shallower than the bound.
+     */
+    template <class NodeTest, class LeafVisit>
+    __device__ __forceinline__ void traverse(
+        const int num_objects,
+        const int2 *__restrict__ children,
+        NodeTest node_test,
+        LeafVisit leaf_visit)
+    {
+        int stack[BVH_STACK_SIZE];
+        int stack_ptr = 0;
+        stack[0] = 0;
+
+        while (stack_ptr >= 0)
+        {
+            const int node_idx = stack[stack_ptr--];
+
+            if (!node_test(node_idx))
+                continue;
+
+            if (node_idx >= num_objects - 1)
+            {
+                if (!leaf_visit(node_idx - (num_objects - 1)))
+                    return;
+            }
+            else if (stack_ptr + 2 < BVH_STACK_SIZE)
+            {
+                const int2 c = children[node_idx];
+                if (c.x >= 0) stack[++stack_ptr] = c.x;
+                if (c.y >= 0) stack[++stack_ptr] = c.y;
+            }
+        }
+    }
+}
+
+#endif // BVH_TRAVERSE_CUH

{conquer3d-0.7.7 → conquer3d-0.7.8}/conquer3d/csrc/data_structure/mesh_bvh.cu

@@ -4,6 +4,7 @@
  */
 
 #include "mesh_bvh.h"
+#include "bvh_traverse.cuh"
 #include "../primitive/triangle.h"
 #include "../primitive/edge.h"
 #include <thrust/device_vector.h>
@@ -239,42 +240,19 @@ __global__ void filter_ray_triangle_intersections_kernel(
         Ray ray2(p, ray_dir, 0.0f);
 
         int hit_count = 0;
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        stack[0] = 0;
-
-        while (stack_ptr >= 0)
-        {
-            int node_idx = stack[stack_ptr--];
-
-            float t_hit_aabb;
-            if (!ray2.is_intersect_aabb(bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx], t_hit_aabb))
-            {
-                continue;
-            }
-
-            if (node_idx >= num_objects - 1)
-            {
-                int tri_id = object_ids[node_idx - (num_objects - 1)];
-                int3 tri = triangles[tri_id];
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                float t_hit_aabb;
+                return ray2.is_intersect_aabb(bvh_aabb_mins[node_idx],
+                                              bvh_aabb_maxs[node_idx], t_hit_aabb);
+            },
+            [&] (int leaf_idx) {
+                int3 tri = triangles[object_ids[leaf_idx]];
                 Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
-
                 float t_hit, u, v;
-                if (T.is_intersect_ray(ray2, t_hit, u, v))
-                {
-                    hit_count++;
-                }
-            }
-            else
-            {
-                if (stack_ptr + 2 < BVH_STACK_SIZE)
-                {
-                    int2 children = bvh_children[node_idx];
-                    stack[++stack_ptr] = children.x;
-                    stack[++stack_ptr] = children.y;
-                }
-            }
-        }
+                if (T.is_intersect_ray(ray2, t_hit, u, v)) hit_count++;
+                return true;
+            });
 
         return (hit_count % 2 == 1) ? -1.0f : 1.0f;
     }
@@ -934,41 +912,18 @@ __global__ void query_voxel_mesh_bvh_kernel(
         float3 q_min = query_mins[q_idx];
         float3 q_max = query_maxs[q_idx];
 
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        stack[0] = 0;
-
         bool is_intersect = false;
-
-        while (stack_ptr >= 0)
-        {
-            int node_idx = stack[stack_ptr--];
-
-            if (!aabb::test_aabb_overlap(q_min, q_max, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]))
-                continue;
-
-            if (node_idx >= num_objects - 1)
-            {
-                int tri_id = object_ids[node_idx - (num_objects - 1)];
-                int3 tri = triangles[tri_id];
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                return aabb::test_aabb_overlap(q_min, q_max,
+                    bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            },
+            [&] (int leaf_idx) {
+                int3 tri = triangles[object_ids[leaf_idx]];
                 Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
-
-                if (T.is_voxel_intersect(q_min, q_max))
-                {
-                    is_intersect = true;
-                    break;
-                }
-            }
-            else
-            {
-                if (stack_ptr + 2 < BVH_STACK_SIZE)
-                {
-                    int2 children = bvh_children[node_idx];
-                    stack[++stack_ptr] = children.x;
-                    stack[++stack_ptr] = children.y;
-                }
-            }
-        }
+                if (T.is_voxel_intersect(q_min, q_max)) { is_intersect = true; return false; }
+                return true;
+            });
 
         out_intersect[q_idx] = is_intersect;
     }
@@ -1066,40 +1021,18 @@ __global__ void count_active_voxels_mesh_bvh_kernel(
             q_min.y + voxel_size.y,
             q_min.z + voxel_size.z);
 
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        stack[0] = 0;
         bool is_intersect = false;
-
-        while (stack_ptr >= 0)
-        {
-            int node_idx = stack[stack_ptr--];
-
-            if (!aabb::test_aabb_overlap(q_min, q_max, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]))
-                continue;
-
-            if (node_idx >= num_objects - 1)
-            {
-                int tri_id = object_ids[node_idx - (num_objects - 1)];
-                int3 tri = triangles[tri_id];
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                return aabb::test_aabb_overlap(q_min, q_max,
+                    bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            },
+            [&] (int leaf_idx) {
+                int3 tri = triangles[object_ids[leaf_idx]];
                 Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
-
-                if (T.is_voxel_intersect(q_min, q_max))
-                {
-                    is_intersect = true;
-                    break;
-                }
-            }
-            else
-            {
-                if (stack_ptr + 2 < BVH_STACK_SIZE)
-                {
-                    int2 children = bvh_children[node_idx];
-                    stack[++stack_ptr] = children.x;
-                    stack[++stack_ptr] = children.y;
-                }
-            }
-        }
+                if (T.is_voxel_intersect(q_min, q_max)) { is_intersect = true; return false; }
+                return true;
+            });
 
         if (is_intersect) {
             atomicAdd(active_counter, 1ULL);
@@ -1166,40 +1099,18 @@ __global__ void collect_active_voxels_mesh_bvh_kernel(
             q_min.y + voxel_size.y,
             q_min.z + voxel_size.z);
 
-        int stack[BVH_STACK_SIZE];
-        int stack_ptr = 0;
-        stack[0] = 0;
         bool is_intersect = false;
-
-        while (stack_ptr >= 0)
-        {
-            int node_idx = stack[stack_ptr--];
-
-            if (!aabb::test_aabb_overlap(q_min, q_max, bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]))
-                continue;
-
-            if (node_idx >= num_objects - 1)
-            {
-                int tri_id = object_ids[node_idx - (num_objects - 1)];
-                int3 tri = triangles[tri_id];
+        bvh::traverse(num_objects, bvh_children,
+            [&] (int node_idx) {
+                return aabb::test_aabb_overlap(q_min, q_max,
+                    bvh_aabb_mins[node_idx], bvh_aabb_maxs[node_idx]);
+            },
+            [&] (int leaf_idx) {
+                int3 tri = triangles[object_ids[leaf_idx]];
                 Triangle T(vertices[tri.x], vertices[tri.y], vertices[tri.z]);
-
-                if (T.is_voxel_intersect(q_min, q_max))
-                {
-                    is_intersect = true;
-                    break;
-                }
-            }
-            else
-            {
-                if (stack_ptr + 2 < BVH_STACK_SIZE)
-                {
-                    int2 children = bvh_children[node_idx];
-                    stack[++stack_ptr] = children.x;
-                    stack[++stack_ptr] = children.y;
-                }
-            }
-        }
+                if (T.is_voxel_intersect(q_min, q_max)) { is_intersect = true; return false; }
+                return true;
+            });
 
         if (is_intersect) {
             unsigned long long write_idx = atomicAdd(active_counter, 1ULL);