Abstract
This paper presents a novel framework for accelerating 3D registration—the computational process of stitching multiple 3D scans into a unified model—by leveraging a heterogeneous cluster of multi-core CPUs and GPUs. By implementing a "functionality distribution" scheme that assigns specific tasks to the processor architecture best suited for them, the authors achieved a 15x speedup over single-core registration. Furthermore, the system demonstrates superior accuracy and efficiency compared to state-of-the-art implementations like KinectFusion (KinFu), particularly when handling large-scale datasets.
Introduction
3D scanning has become increasingly accessible due to the proliferation of low-cost sensors like the Microsoft Kinect. However, transforming raw "range images" or point clouds into high-fidelity 3D models remains a significant computational bottleneck. This process, known as 3D registration, requires the precise alignment of scans taken from various viewpoints into a single coordinate system.
Traditional registration is often performed "pair-wise" (aligning two scans at a time), which is susceptible to cumulative error, or "multi-view" (aligning multiple scans simultaneously), which is more accurate but computationally intensive. While single-GPU acceleration is common, this research explores the untapped potential of using a cluster of computers, each equipped with both multi-core CPUs and GPUs, to manage the massive datasets required for professional-grade modeling.
Methodology
The proposed system utilizes a distance-based registration algorithm. Unlike the standard Iterative Closest Point (ICP) algorithm, which relies on time-consuming nearest-neighbor searches for every point, this method employs a 3D distance field to streamline alignment.
Functionality Distribution
A core contribution of this work is the strategic division of labor between different processor types. The authors identified that CPUs and GPUs possess distinct architectural strengths:
- Multi-core CPU (Distance Value Computation): This phase involves complex memory locking mechanisms. On a GPU, many threads attempting to update the same grid point simultaneously lead to "lock contention," significantly degrading performance. The multi-core CPU, with its sophisticated cache and fewer, more powerful cores, handles these operations more efficiently.
- GPU (Error Calculation and Minimization): Once the distance field is established, the system performs massive parallel mathematical operations to minimize alignment errors. This task is perfectly suited for the GPU’s high-throughput architecture.
Influence-Based Partitioning
To scale the workload across a cluster, the authors moved beyond simple "spatial partitioning" (dividing 3D space into uniform tiles). Instead, they developed "influence-based partitioning," which identifies only the specific grid points affected by the 3D model. By distributing only these relevant points across cluster nodes, the system reduces redundant computation and communication overhead.
Multi-view Optimization
The framework extends these accelerations to multi-view registration. This allows the system to minimize errors across an entire group of scans simultaneously, providing a more robust and accurate final model than sequential pair-wise alignment.
Experimental Setup and Datasets
The system was evaluated using a combination of industry benchmarks and custom laboratory scans:
- Standard Benchmarks: Classic models from the Stanford 3D Scanning Repository, including the Bunny, Thai Statue, Lucy, Happy Buddha, Dragon, and Armadillo.
- Custom Scans: High-resolution scans of everyday objects such as a Vase, Tripod, and Computer Table.
- Comparative Analysis: Custom sequences of 8 to 15 range images were used to benchmark the system against the open-source KinectFusion (KinFu) implementation.
Key Insights
The Lock Bottleneck
The research highlights that the GPU is not a universal solution for all parallel tasks. During distance field computation, the overhead of managing thread locks on a GPU outweighs its raw processing power. This finding underscores the importance of heterogeneous computing, where the CPU is treated as a primary compute partner rather than just a controller.
Cluster Scalability
Multi-view registration was found to be more "cluster-friendly" than pair-wise registration. Because multi-view tasks involve more work per GPU kernel call, they effectively hide memory latency and minimize the relative impact of network communication between nodes. To further streamline coordination, the system uses "redundant mapping," where every node maintains a map of the total computation to divide work equally without constant master-slave communication.
Results
- Performance Gains: The system achieved a total speedup of up to 15x compared to a single-core CPU implementation.
- Partitioning Efficiency: On a cluster of 20 CPU cores and 5 GPUs, influence-based partitioning outperformed traditional spatial partitioning by approximately 1.3x.
- Accuracy: In head-to-head comparisons, the multi-view approach consistently surpassed KinFu in accuracy. Notably, the proposed method produced high-quality models using only 10 range images, whereas KinFu required 15 images to reach a lower level of precision.
- Reconstruction Speed: For full model reconstruction, the multi-view approach was 25% to 30% faster than the pair-wise approach on the same cluster hardware.
Limitations and Future Work
While the system provides significant speedups, it currently assumes a homogeneous cluster where all nodes have identical power. Future iterations could incorporate load-balancing for heterogeneous clusters with varying hardware capabilities. Additionally, the authors identified "processor idleness" as an area for improvement; currently, the CPU and GPU operate sequentially. Implementing a "pipelining" strategy—where the CPU calculates the distance field for a subsequent scan while the GPU processes the current one—could further increase throughput. Finally, automating the grouping of scans based on overlap would remove the current requirement for manual grouping.
Summary updated