CP+: Camera Poses Augmentation with Large-scale LiDAR Maps

TL;DR

This paper introduces CP+, a framework that enhances camera pose accuracy and colorization by aligning images with large-scale LiDAR point clouds through feature extraction and iterative optimization.

Contribution

The novel CP+ framework improves camera pose estimation and colorization by directly aligning images with LiDAR point clouds using 2D-3D line correspondences.

Findings

Enhanced camera pose accuracy in large-scale scenes

Improved colorization quality of point clouds

Effective alignment of images with LiDAR data

Abstract

Large-scale colored point clouds have many advantages in navigation or scene display. Relying on cameras and LiDARs, which are now widely used in reconstruction tasks, it is possible to obtain such colored point clouds. However, the information from these two kinds of sensors is not well fused in many existing frameworks, resulting in poor colorization results, thus resulting in inaccurate camera poses and damaged point colorization results. We propose a novel framework called Camera Pose Augmentation (CP+) to improve the camera poses and align them directly with the LiDAR-based point cloud. Initial coarse camera poses are given by LiDAR-Inertial or LiDAR-Inertial-Visual Odometry with approximate extrinsic parameters and time synchronization. The key steps to improve the alignment of the images consist of selecting a point cloud corresponding to a region of interest in each camera view, extracting reliable edge features from this point cloud, and deriving 2D-3D line correspondences which are used towards iterative minimization of the re-projection error.

Equations

$$f(d)=\varphi -d,\varphi \ge ma{x}_{p_i\in P}(\Vert p_i\Vert ).$$

$$F(p_i)=p_i+2(R-\Vert p_i\Vert )\frac{p_i}{\Vert p_i\Vert }.$$

$$\text{K}=\text{var}(Q)=\frac{1}{m}\sum _{i=1}^m(q_i-\text{E}(q_i))(q_i-\text{E}(q_i){)}^T,$$

$$\hat{x}_{i}=\pi\biggl{(}\textbf{T}_{c}\begin{bmatrix}x_{i}\\ 1\end{bmatrix}\biggr{)}\in\mathbb{R}^{2},$$

$$\textbf{T}_{c}^{*}=\arg\min_{\textbf{T}_{c},y_{i}}\sum^{n}_{i=1}\text{n}^{T}\biggl{(}\pi\biggl{(}\textbf{T}_{c}\begin{bmatrix}x_{i}+\epsilon^{L}_{i}\\ 1\end{bmatrix}\biggr{)}-(y_{i}+\epsilon^{C}_{i})\biggr{)},$$

$$Residual(\textbf{T})=\frac{1}{n}\sum_{i=1}^{n}\biggl{\lVert}p_{i}-\pi\biggl{(}\textbf{T}\begin{bmatrix}\hat{p}_{i}\\ 1\end{bmatrix}\biggr{)}\biggr{\rVert},$$

Full text

I Introduction

Point clouds and optical images are useful for scene understanding, and cameras, LiDARs (Light Detection And Ranging) and Inertial Measurement Units (IMU) are widely employed in the underlying reconstruction and modeling tasks. However, combining the two modalities in order to reconstruct an RGB-colored point cloud is a highly challenging problem. Many applications utilize colorization or registration of 2D and 3D information, so it is very useful to get a better point cloud coloring.

A simple approach will just calibrate the extrinsic poses of all sensors [5] and utilize hardware synchronization to match the rigidly mounted sensors [6]. But in real systems often this calibration or hardware synchronization is not available or the error is too big, such that more advanced methods need to be employed to generate good point cloud coloring.

A popular approach to point cloud coloring are perspective-n-Point based (PnP-based) algorithms [9, 14, 13]. They can handle the 2D-3D registration problem well, when there are several reliable correspondences. However, finding these correspondences is difficult for most real situations, and thus there are many methods that only use the same sensor for these tasks, even localization and mapping, which reveals a modality gap on mutual information registration which is hard to overcome.

An intuitive idea is to construct a small 3D map with a series of images using a Structure-from-Motion (SFM) [21] approach, and then to match the map into the prior LiDAR map by Iterative Closest Point (ICP)-like methods with scale. This idea is computationally intensive. In addition, this approach needs the feature descriptors or intensities, which may be inconsistent under changing circumstances. Since directly registering two different types of sensor information is error-prone, we will aim at geometry-feature-based methods. Those features on geometry structures can be captured in 2D and 3D data and are not affected by dynamic elements like different illumination.

Furthermore, because of the richness of edge features in most scenes, extraction and matching of geometric edges makes it possible to solve the 2D-3D registration problem. Nevertheless, direct 2D-3D geometric line correspondence matching does also easily lead to some registration error.

To overcome the above problems and challenges, and thanks to existing methods like [15], which can provide not only a good LiDAR mapping result but also a series of coarse camera poses, we propose a new framework for camera localization augmentation with the LiDAR mapping result for the purpose of point cloud colorization. Because the degradation situations are to be avoided as much as possible, in addition to actively handling these cases, some pre-processing can be performed on the input point cloud and images, such as removing blurry images and removing dynamic objects [20] from the input point cloud. In addition, depending on coarse camera poses and intrinsic parameters, 2D-3D line matching can be accelerated by selecting a suitable pending point cloud (ROI).

We have done experiments to test our algorithm, which illustrate that our algorithm has a significant improvement in point cloud colorization. It works with different kinds of LiDAR, including spinning and solid state LiDAR and a camera (see Fig. 1(a) and 1(b)). We test the accuracy of our algorithm and other camera re-localization methods on the same dataset, while using LiDAR-Inertial-Visual Odometry and Visual-Inertial Odometry (VIO) algorithms as baselines.

The main contributions of our work are:

• •

We propose and implement a novel approach for monocular camera pose improvement in prior LiDAR maps, which is capable of handling reconstruction tasks in large-scale scenes.

• •

Multi-layer voxelization is adopted in the framework. At each step of the LiDAR processing flow, including dynamic object removal, ROI filtering, and 3D line extraction, the multi-layer voxel maps data structure is used for input and output as a whole instead of the initial point cloud, which simplifies and speeds up the algorithm.

• •

We carefully study and analyse numerous degraded optimization situations and failure cases for re-localization.

• •

Various experiments have been conducted to test our method, which show the robustness and accuracy of our system.

II Related Work

In addition to the PNP-based methods and SFM-based methods mentioned above, traditional Visual-Inertial Odometry (VIO) methods [19] and RANSAC-based or Branch-and-bound methods [8, 2] can provide the camera poses in the global map. However, these methods rely heavily on the point correspondences to handle 2D-3D matching problem, and are also causing the problem of missing scale.

The 2D and 3D lines detection from images and the point cloud, respectively, and the according matching method is an intuitive approach to solve the visual based localization problem. Unlike using features, the edges or planes have higher-order semantic information. [23] presented one of these kinds of methods based on VIO and it optimizes the camera poses obtained from the VIO algorithm.

Learning-based methods [4, 7, 3] are also designed to obtain the better pose estimates, directly registering the images to the LiDAR information. But their results are not stable on the camera localization tasks.

Our work is inspired by 2D-3D matching for camera localization [23]. However, it considers all 3D edges extracted in the input point cloud and uses a learning-based method to extract 2D lines in the image. Thus, the applicability and robustness of the algorithm are relatively weak. We improve upon this by adding a ROI filtering operation and classifying the extracted 3D lines before 2D-3D matching. In [24, 17] the target-less calibration method was identified to provide comparable results with the state of the art (SOTA) traditional target-based calibration method, and in this paper we adopt the idea of line detection and matching in the target-less calibration method and compare with other re-localization or mapping methods.

III Overview of the System

The overview our framework is shown in Fig. 2, which contains two main processing flows for image and point cloud input. Before these two flows, the LiDAR odometry and mapping algorithm [22, 15] is implemented to generate a global and correct-enough point cloud map. Here, the LiDAR-only bundle adjustment [18] is also an optional pre-processing step to enhance the point cloud results. If we use a LIO-based method, we can obtain correct-enough LiDAR poses, which help to get a smooth and almost-accurate trajectory of the motion with the high frequency IMU data. Relying on the rough extrinsic parameter and time synchronization, the coarse camera poses are then calculated.

For the image input, we will determine whether it is blurry or not. The image will be thrown away if it is, because existing image deblur algorithms do not work well. Furthermore, some digital image processing methods like histogram equalization is used first, in order to set a unified threshold to judge the blur situations. It is worth noting that in most cases, when we collect data, exposure is usually fixed. Therefore, in order to ensure the continuity of the color of the point cloud, we only use the original images for the colorization test without some special pre-processing. After that, we detect 2D edges with the Canny algorithm.

For the global point cloud input, we will remove dynamic objects first, which is an upfront work in the pipeline if we want to handle a series of camera poses with corresponding images. Then we select the point cloud ROI based on the camera view. Only the depth-continuous edges will be extracted by intersecting planes detection, because depth-discontinuous edges in 3D point clouds are often not reliable for matching 2D-3D lines.

With 2D and 3D lines extracted by two processing flows, a matching optimization algorithm is used to obtain the optimal camera pose parameters of the 2D image in the 3D point cloud. We also deal with some degraded optimization problems in this step. The optical image textured point cloud of ROI can be rendered using the camera pose parameters.

If this framework is employed in a small-scale local scene, the removing dynamic objects and ROI filtering parts will be skipped, which will speed up the pipeline of 2D-3D correspondences matching and providing a near real-time performance.

IV Methodology

IV-A Multi-layer Voxelization

The main idea is inspired by the concept of adaptive voxelization [18, 17] and OctoMap [10]. In our approach, the previous work of dynamic object removal [20], ROI filtering [11], and 3D line extraction [17] work with a voxel-like data structure, thus we implement a multi-layer voxelization process for versatility and simplicity of data transmission.

Our voxel map is constructed by an Octotree data structure. The roots here are the results of traditional voxelization for 3D point cloud, which means we voxelize the point cloud by a default and slightly larger size (e.g, $2m$) first. Then all roots/voxels will be divided into eight child nodes/ small voxels (child nodes are half the length of the parent node), until the voxel will reach the proper minimal size (e.g, $62.5mm$). Only all leaves store the corresponding small point cloud data in order to save storage. The voxel map helps to accelerate the preliminary selection of the point cloud, and also simplifies the initial point cloud data.

IV-B Dynamic Object Removal

We adopt the ray-tracing based method presented in [20] to filter the dynamic objects. But unlike traditional ray-tracing based methods, the algorithm will compare simultaneously various scans and apply some additional heuristics.

The main idea of the ray-tracing based method for filtering dynamic objects is to construct a global occupancy grid stored as a voxel data structure for point clouds and to determine whether each grid/voxel will be hit or seen through. Then the voxel will be viewed as a dynamic one, if it is first hit by a LiDAR scan, and then is seen through by the optical path of other LiDAR scans. The point cloud in this voxel will be filtered. Most of the previous algorithms [1] adopted the idea with directly storing the numbers of hits or see-throughs into each voxel, thus they contained some false positive cases, the static voxels are incorrectly marked as dynamic ones, caused by LiDAR spots with approaching angles in the same scan (self-intersection cases). To deal with this situation, each voxel stores a set of LiDAR scan identifiers. For each voxel, we will traverse all voxels on an optical path from the origin of the LiDAR to it (ray-tracing), if one of these voxels contains the same scan identifier, the voxel will not be considered to be a dynamic one.

In addition to the above-mentioned indirect processing of voxel occupancy situations, there are still a lot of false positive cases, which mainly include two kinds of situations due to heterogeneous sampling of surfaces for LiDAR scanning. One is when the incident angle is relatively large, the LiDAR scan will pass through the voxels where the LiDAR spots with a small incident angle is located; The second one is in the occlusion case, where the LiDAR scan at the edge of the foreground object will be easily passed through by other scans. Thus, the setting of safe maximum search distances [20] for each LiDAR spot can avoid these false positives. Voxels below the maximum distance are not filtered.

In this part, we build the voxel map at first and set a suitable minimal size of voxel (e.g, $62.5mm$). Then dynamic object removal with the highest-layer of voxel map will prune branches in this map.

IV-C Region of Interest Filtering for point cloud

The main concept of this part is to find the visible part of the point cloud from the viewpoint, which is the application of the Generalized Hidden Point Removal (GHPR) operator [11]. It mainly contains two steps: point transformation and convex hull construction.

A naive mirror kernel will be applied to speed up the processing for visibility checking of the point cloud, which can be written as

[TABLE]

Here, the point $p_{i}$ is in the point set $P\subset\mathbb{R}^{3}$ sampled from a continuous surface and $d=||p_{i}||$. The equation indicates flipping around a spherical mirror with radius $R=\frac{1}{2}\phi$, and $C$ denotes the center of the sphere. Then a radius transformation [12] can be defined as

[TABLE]

The new point set $\hat{P}\subset\mathbb{R}^{3}$ will be obtained by applying this radius transformation. The points reside on the convex hull of $\hat{P}\bigcup C$ and determine which points are reachable or not, representing $\hat{P}^{*}\subset\hat{P}$. Then we find the relevant reachable point subset $P^{*}\subset P$. Depending on the camera intrinsic parameters, the points selected finally are the visible points.

In order to simplify and speed up the work flow, we select some root nodes in the voxel map with a preset maximum search distance (e.g, $20m$), that is, part of the point cloud to be processed. Apart from pre-selection, we do not consider every point in the pending point cloud to filter our ROI, but consider nodes/voxels in higher layers in the voxel map as a whole. Without loss of generality, we take all leaf nodes from selected root nodes into account. After that, we down-sample the point cloud by treating each leaf node/voxel as a point (i.e. the center of the voxel), which accelerates the process of computing the convex hull. A few points that would have been filtered out will also be retained, but these points should be retained for later processing due to the inaccurate camera poses. It is for this reason that some operations about point cloud expansion need to be implemented in practice. First we properly widen the field of view (FOV) of the viewpoint before filtering. Then each visible voxel is also traversed and its adjacent voxels are marked as visible, further expanding the ROI filtering results. Fig. 1(d) and 1(c) show the point cloud of ROI from the camera viewpoint and the corresponding image.

Because occlusion detection of 3D line features is difficult, the 3D line maps can not directly select ROI for 3D lines easily. Some methods [23] collect all visible 3D lines without discarding occluded ones, and rely only on the camera intrinsic parameters and poses information. Consequently, there will be many occluded lines when doing with a large-scale point cloud.

This situation is indicated by Fig. 3. In this case, we can find there exists a corridor behind the visible wall (Fig. 3(d)), so the 3D lines extracted in the initial point cloud are shown in Fig. 3(c), which greatly increases the difficulty of 2D-3D correspondence matching, even though all depth-discontinuous edges are already excluded. Based on this consideration, we will filter the point cloud of ROI according to each image pose and then extract the 3D lines, rather than directly extracting all 3D lines in the beginning.

IV-D 3D Line Detection

In general, there exist two types of feature edges: depth-continuous and depth-discontinuous edges, as displayed in Fig. 4. The depth-discontinuous edges are prone to the foreground inflation and bleeding points, resulting in the zero- or multi-value projection problems. It is thus intuitive that the depth-discontinuous edges are not reliable for matching with the image information. Thus, to acquire depth-continuous ones, we will detect two intersecting planes beforehand.

Similar to the method presented in [17], we traverse all root nodes in the range of ROI. With regard to each point $q_{i}\in Q\ (i=1,...,m)$ contained in a node, the covariance matrix K of a $3$-dimension vector $q_{i}$ is

[TABLE]

where $\textbf{E}(q_{i})=\frac{1}{m}\sum^{m}_{i=1}q_{i}$. Three eigenvectors of K represent the main orthogonal directions of the point cloud and the corresponding three eigenvalues are proportional to dispersion in these directions. Therefore, if the smallest eigenvalue is close to [math], the node/voxel will be considered as a planar one. In practice, calculating and comparing the ratio eigenvalues of a covariance matrix on these points is a more reasonable way to determine the voxel situations.

If a node/voxel does not contain a plane, its child nodes will be searched until the child is planar or all leaf nodes are traversed. The method is better than directly extracting planes in default size voxels by fitting with RANSAC [24], because RANSAC can lead to wrong extractions. For each planar node, we scan all adjacent voxels. If the adjacent voxel is also planar and the angle between the normal vectors of two planes is within a range, the intersection edge can be constructed, which is a depth-continuous edge.

IV-E Line Matching

First we sample several global frame points $x_{i}\in X\subset\mathbb{R}^{3}$ for each 3D edge we extracted before. With the coarse camera pose $\textbf{T}_{c}\in SE(3)$, the 3D-2D projection can be written as

[TABLE]

where $\pi(\cdot)$ is the function which implements the camera model and applies known camera intrinsic parameters. Then we will find the nearest neighbor $y_{i}\in Y$ of $\hat{x}_{i}$ in the 2D line extracted in the input image. In addition, the normal vector n of this edge is considered to remove some common error matches (e.g, non-parallel but close lines).

With the 2D and 3D lines extracted, we formulate the problem for 2D-3D correspondence as:

[TABLE]

where $\epsilon^{L}_{i}$ and $\epsilon^{C}_{i}$ represent the noise models [24] for LiDAR and camera, respectively. By minimizing the re-projection distance of the 2D-3D correspondences [24] the more accurate camera pose is obtained.

V Evaluation and Results

V-A Metric for Single Image Evaluation

When using the solid state LiDAR, we first put the LiDAR in a stable pose for a period of time (e.g, $30s$), and collect an intensity-encoded colored point cloud (Fig. 5(a)) as the ground truth, which contains one or more checkerboards. Then we start running the LIO or LIO&VIO algorithm with this pose as the initial position, so as to obtain initial coarse camera poses $\textbf{T}_{init}$ and images. For the spinning LiDAR the ground truth is the result of LIO or LIO&VIO algorithm. The dataset is collected by this process, which contains rooms, corridors, corners, etc., and the area is about 1,200 $m^{2}$. Finally, the optimized poses $\textbf{T}_{res}$ are obtained through our algorithm. For each pose T whose image contains a checkerboard, with the camera model $\pi(\cdot)$, we have the residual of it:

[TABLE]

where $\hat{p}_{i}\in\hat{P}\ (i=1,...,n)$ denotes the corner point of the checkerboard we manually selected in the point cloud by its intensity information, and $p_{i}\in P\ (i=1,...,n)$ is the corner point of the checkerboard detected in the image. Fig. 5 shows the evaluation for one case in a scene. For the scene placement, we placed the checkerboard in a position with many edges, especially the corners.

V-B Augmentation of camera poses based on LIO Algorithm

We run our method based on LIO-SAM [22], and test other localization or re-localization algorithms. It is worth noting that some parts of the 2D-3D matching method based on [23] were rewritten to fit with our data, but the performance is basically in line with the test in [23], especially compared to VINS-Mono [19]. In addition, similar with calculating relative poses errors (RPE) [25], the poses of 2D-3D matching and VINS-Mono are aligned with the smooth trajectory built by LiDAR and high-frequency IMU data.

Fig. 6 shows the results of the comparison and that the performance of CP+ is obviously better than the baseline method (LIO-SAM). Here the maximum number of iterations in our CP+ method is set to three. The average computation time is $1.251s$.

V-C Augmentation for LIO&VIO Algorithm

Similarly, here we run our method based on R3LIVE [15]. Fig. 7 shows that our method can improve the pose estimates of LiDAR-Inertial-Visual systems. However, our method requires slightly higher precision for the initial pose estimates. Directly optimizing the results of VINS-mono [19], the augmentation is often not obvious, not much different from 2D-3D matching methods introduced before.

VI Conclusions

In this paper, we presented a novel framework for camera localization augmentation with LiDAR maps, which integrates LiDAR and camera data through the 2D-3D correspondence detection and matching. Our novel framework employs dynamic object removal, ROI filtering and a multi-layer voxel map data structure to speed up the algorithm. The experimental evaluation of our approach showed its superior point cloud colorization performance when compared to state of the art approaches. Furthermore, the geometric registration of LiDAR and camera data in this paper can also provide new ideas for the joint bundle adjustment of these two kinds of data.