LinK3D: Linear Keypoints Representation for 3D LiDAR Point Cloud

TL;DR

LinK3D introduces a GPU-free, real-time 3D LiDAR feature representation that describes a keypoint by its aggregation neighbors, yielding a $180$-dimensional descriptor computed from a sectorized XY plane and oriented by a main direction. The method combines edge-point extraction, sector-based aggregation, and robust descriptor generation with an efficient matching scheme, achieving strong inlier performance on sparse LiDAR data and real-time CPU operation (about $30$ ms extraction and $20$ ms matching on a $64$-beam LiDAR at around $10~\mathrm{Hz}$). It demonstrates competitive LiDAR odometry results and broad applicability to downstream tasks, with code released publicly. While robust in structured scenes, LinK3D shows limitations in unstructured environments, motivating future work to enhance robustness and extend to more 3D vision tasks.

Abstract

Feature extraction and matching are the basic parts of many robotic vision tasks, such as 2D or 3D object detection, recognition, and registration. As is known, 2D feature extraction and matching have already achieved great success. Unfortunately, in the field of 3D, the current methods may fail to support the extensive application of 3D LiDAR sensors in robotic vision tasks due to their poor descriptiveness and inefficiency. To address this limitation, we propose a novel 3D feature representation method: Linear Keypoints representation for 3D LiDAR point cloud, called LinK3D. The novelty of LinK3D lies in that it fully considers the characteristics (such as the sparsity and complexity) of LiDAR point clouds and represents the keypoint with its robust neighbor keypoints, which provide strong constraints in the description of the keypoint. The proposed LinK3D has been evaluated on three public datasets, and the experimental results show that our method achieves great matching performance. More importantly, LinK3D also shows excellent real-time performance, faster than the sensor frame rate at 10 Hz of a typical rotating LiDAR sensor. LinK3D only takes an average of 30 milliseconds to extract features from the point cloud collected by a 64-beam LiDAR and takes merely about 20 milliseconds to match two LiDAR scans when executed on a computer with an Intel Core i7 processor. Moreover, our method can be extended to LiDAR odometry task, and shows good scalability. We release the implementation of our method at https://github.com/YungeCui/LinK3D.

Figures (7)

• Figure 1: The core idea of the proposed LinK3D and the matching results of two LiDAR scans based on LinK3D. LinK3D represents the current keypoint with its neighbor keypoints. The green lines are the valid matches. Accurate point-to-point matches can be obtained by matching the corresponding LinK3D descriptors.
• Figure 2: The workflow of the proposed LinK3D in terms of keypoint extraction and description. The keypoint extraction is first executed to generate aggregation keypoints. Afterward, the descriptor generation algorithm is performed to derive an efficient keypoint descriptor.
• Figure 3: The scattered edge points (marked by the red dashed box) and the clustered edge keypoints (marked by the blue dashed box) are in (a). The clustered edge keypoints are what we need. (b) shows the extracted edge keypoints by Algorithm \ref{['alg:A']}.
• Figure 4: Illustration of the aggregation process. The points are first divided into corresponding sector areas based on the angle in the XoY plane of the LiDAR coordinate system. Then the clustering operation is only performed within each sector area, rather than directly within the whole space. The purple points are what we need to generate the aggregation keypoints (red points), and the green points are the scattered points that will be filtered out.
• Figure 5: Illustration of the descriptor generation. The XoY plane, centered on the current keypoint $k_o$ is divided into 180 sector areas. We first search for the closest keypoint $k_1$ of $k_0$, then the main direction is the vector from $k_0$ to $k_1$. Then the closest keypoint in each sector area is searched for. The searched keypoints $k_1$, $k_2$, $k_3$, etc., are used for describing the current $k_0$. Through the vectorizing operation, by using the distance values between $k_o$ and $k_1$, $k_2$, $k_3$, etc., the 180-dimensional LinK3D descriptor will be obtained.