Tổng quan về fast_gicp

Thư viện fast_gicp cung cấp một tập hợp các giải thuật căn chỉnh đám mây điểm (point cloud registration) dựa trên nền tảng GICP được tối ưu hóa hiệu suất. Thư viện này hỗ trợ cả triển khai đa luồng trên CPU và tăng tốc phần cứng thông qua GPU sử dụng CUDA. Điểm nổi bật của fast_gicp là khả năng tương thích hoàn toàn với giao diện đăng ký của PCL (Point Cloud Library), cho phép thay thế trực tiếp các module GICP mặc định trong các dự án hiện có.

Các giải thuật và Hiệu năng

Hệ thống cung cấp nhiều phương thức xử lý khác nhau để phù hợp với các ràng buộc về phần cứng và độ chính xác:

• FastGICP: Triển khai GICP đa luồng, đạt khoảng 40 FPS.
• FastGICPSingleThread: Phiên bản đơn luồng tối ưu hóa, đạt khoảng 15 FPS.
• FastVGICP: Giải thuật GICP dạng voxel đa luồng, tốc độ xử lý khoảng 70 FPS.
• FastVGICPCuda: Phiên bản VGICP tăng tốc bằng CUDA, đạt hiệu suất khoảng 120 FPS.
• NDTCuda: Giải thuật NDT (Normal Distributions Transform) dạng D2D trên GPU, tốc độ lên tới 500 FPS.

Cơ chế hoạt động

Hiệu suất vượt trội của fast_gicp đến từ các kỹ thuật tối ưu hóa cốt lõi:

• Xử lý song song: Sử dụng OpenMP để phân chia tác vụ tính toán trên nhiều lõi CPU.
• Kỹ thuật Voxel hóa: Giảm mật độ điểm_cloud thông qua lưới voxel, giúp giảm tải tính toán mà vẫn duy trì độ chính xác hình học.
• Tăng tốc GPU: Tận dụng kiến trúc CUDA để thực hiện các phép tính ma trận và tìm kiếm lân cận song song quy mô lớn.

Các lớp chính trong thư viện bao gồm FastGICP (đa luồng), FastVGICP (voxel hóa) và NDTCuda (tăng tốc GPU), được định nghĩa trong các file header tương ứng within the include directory.

Hướng dẫn Cài đặt

Yêu cầu hệ thống

Để biên dịch và chạy thư viện, môi trường phát triển cần có các thành phần sau:

• PCL (Point Cloud Library)
• Eigen3
• OpenMP
• Sophus & nvbio (tùy chọn cho một số tính năng nâng cao)
• CUDA Toolkit (bắt buộc nếu muốn sử dụng các phiên bản GPU)

Biên dịch từ mã nguồn

Sao chép repository và cấu hình build system như sau:

git clone https://gitcode.com/gh_mirrors/fa/fast_gicp --recursive
mkdir fast_gicp/build && cd fast_gicp/build
cmake .. -DCMAKE_BUILD_TYPE=Release
# Kích hoạt tùy chọn CUDA nếu cần
# cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_VGICP_CUDA=ON
make -j8

Tích hợp với ROS

Đối với dự án ROS, sao chép mã nguồn vào workspace và biên dịch:

cd ~/catkin_ws/src
git clone https://gitcode.com/gh_mirrors/fa/fast_gicp --recursive
cd .. && catkin_make -DCMAKE_BUILD_TYPE=Release

Cài đặt gói Python

Thư viện hỗ trợ binding cho Python, cho phép gọi trực tiếp từ script:

cd fast_gicp
python3 setup.py install --user

Sử dụng với Python

Dưới đây là ví dụ về cách tổ chức mã nguồn để thực hiện căn chỉnh đám mây điểm sử dụng giao diện Python của fast_gicp.

Giao diện hàm trực tiếp

import pygicp
import numpy as np

def register_clouds(reference_pts, sensor_pts):
    """
    Thực hiện căn chỉnh giữa đám mây điểm tham chiếu và đám mây điểm cảm biến.
    """
    # Đảm bảo dữ liệu đầu vào là numpy array dạng float
    ref_cloud = np.asarray(reference_pts, dtype=np.float32)
    scan_cloud = np.asarray(sensor_pts, dtype=np.float32)

    # Gọi hàm căn chỉnh với tham số tùy chỉnh
    transform_matrix = pygicp.align_points(
        ref_cloud, 
        scan_cloud, 
        method="VGICP_CUDA",      # Lựa chọn giải thuật tăng tốc
        downsample_resolution=0.3, # Độ phân giải khi lấy mẫu xuống
        voxel_resolution=0.6       # Kích thước voxel
    )
    return transform_matrix

Giao diện hướng đối tượng

Phương pháp này cho phép kiểm soát chi tiết hơn các tham số của bộ căn chỉnh:

import pygicp

# Tiền xử lý: Giảm mật độ điểm
ref_downsampled = pygicp.downsample(reference_data, 0.25)
scan_downsampled = pygicp.downsample(sensor_data, 0.25)

# Khởi tạo bộ căn chỉnh
matcher = pygicp.FastGICP()
matcher.set_input_target(ref_downsampled)
matcher.set_input_source(scan_downsampled)

# Cấu hình tham số vận hành
matcher.set_num_threads(4)
matcher.set_max_correspondence_distance(1.0)

# Thực thi quá trình khớp
matcher.align()

# Trích xuất ma trận biến đổi cuối cùng
final_pose = matcher.get_final_transformation()

Đánh giá Hiệu năng

Kết quả kiểm tra được thực hiện trên phần cứng CPU Core i9-9900K và GPU GeForce RTX2080Ti với dữ liệu đầu vào khoảng 17.000 điểm:

• PCL GICP gốc: 127.5ms
• PCL NDT gốc: 53.6ms
• FastGICP (Đa luồng): 20.2ms
• FastVGICP (Đa luồng): 18.1ms
• FastVGICPCuda (GPU): 5.9ms

Để chạy thử nghiệm trên dữ liệu mẫu, sử dụng lệnh sau:

roscd fast_gicp/data
rosrun fast_gicp gicp_align 251370668.pcd 251371071.pcd

Kiểm thử trên bộ dữ liệu KITTI

Thư viện hỗ trợ sẵn các script để đánh giá trên chuỗi dữ liệu KITTI Odometry:

• Môi trường C++/ROS: rosrun fast_gicp gicp_kitti /path/to/kitti/sequences/00/velodyne
• Môi trường Python: python3 kitti.py /path/to/kitti/sequences/00/velodyne

Lưu ý cấu hình

Trong một số trường hợp cụ thể, việc giới hạn số lượng luồng xử lý thấp hơn mức tối đa mặc định có thể mang lại hiệu suất tốt hơn do giảm thiểu độ trễ chuyển ngữ cảnh. Người dùng nên thử nghiệm điều chỉnh thông số này thông qua phương thức set_num_threads() để tìm ra cấu hình tối ưu cho phần cứng đích.

Tài liệu tham khảo

Nghiên cứu nền tảng: Kenji Koide, Masashi Yokozuka, Shuji Oishi, and Atsuhiko Banno, "Voxelized GICP for fast and accurate 3D point cloud registration", ICRA2021.