Robust Keyframe-based Dense SLAM with an RGB-D Camera

11/14/2017 ∙ by Haomin Liu, et al. ∙ Zhejiang University 0

In this paper, we present RKD-SLAM, a robust keyframe-based dense SLAM approach for an RGB-D camera that can robustly handle fast motion and dense loop closure, and run without time limitation in a moderate size scene. It not only can be used to scan high-quality 3D models, but also can satisfy the demand of VR and AR applications. First, we combine color and depth information to construct a very fast keyframe-based tracking method on a CPU, which can work robustly in challenging cases (e.g. fast camera motion and complex loops). For reducing accumulation error, we also introduce a very efficient incremental bundle adjustment (BA) algorithm, which can greatly save unnecessary computation and perform local and global BA in a unified optimization framework. An efficient keyframe-based depth representation and fusion method is proposed to generate and timely update the dense 3D surface with online correction according to the refined camera poses of keyframes through BA. The experimental results and comparisons on a variety of challenging datasets and TUM RGB-D benchmark demonstrate the effectiveness of the proposed system.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 4

page 8

page 9

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Simultaneous localization and mapping (SLAM) is a fundamental problem in both, the robotics and computer vision communities. Over the past decade, real-time structure-from-motion or visual SLAM has seen many successes 

[1, 2, 3]. However, visual SLAM has inherent difficulty in handling textureless scenes and in reconstructing dense 3D information in real-time. Using depth sensors can help address these two problems. Along with the popularity of depth sensors (e.g. Microsoft Kinect and Intel RealSense 3D Camera), more and more SLAM approaches [4, 5, 6, 7, 8, 9] with depth or RGB-D sensors have been proposed.

Most dense SLAM methods use a frame-to-frame or frame-to-model alignment strategy, which easily results in accumulation of drift and fails eventually in challenging environments. Some methods [9, 6, 7] proposed to use non-rigid mesh deformation techniques with loop closure constraints to optimize the map and limit drift. However, the model error caused by inaccurate alignment cannot be fully corrected by these methods, which may lead to increasing tracking error and eventual failure.

Recently, BundleFusion [10] was proposed, an end-to-end real-time 3D reconstruction system that uses all RGB-D input and globally optimizes the camera poses and 3D structure in an efficient hierarchical way. Different from previous methods using a frame-to-model strategy, BundleFusion performs brute-force matching for each input frame with all other frames, and then aligns the 3D points for fusion. However, it requires two powerful GPUs (a NVIDIA GeForce GTX Titan X and a GTX Titan Black) to achieve real-time performance. Another major limitation is that it saves all RGB-D input data and only can run for about 10 minutes even with a very powerful PC, making it inappropriate for virtual reality and augmented reality applications which typically require much longer run time. Most recently, Maier et al. [11] proposed to improve this work by using a keyframe fusion and re-integration method based on DVO-SLAM [12], which can perform real-time dense SLAM with online surface correction using a single GPU.

In this paper, we present RKD-SLAM, a robust keyframe-based dense SLAM system for an RGB-D camera that is able to perform in real-time on a laptop without time limitation in a moderate size scene. RKD-SLAM also can handle fast camera motion and low-frame-rate live RGB-D sequences. The main contributions of our paper are as follows:

  1. We propose a robust keyframe-based RGB-D tracking method which combines visual and depth information to achieve robust and very fast camera tracking (about fps) on a single CPU.

  2. We propose an efficient incremental bundle adjustment algorithm which makes maximum use of intermediate computation for efficiency, while adaptively updating affected keyframes for map refinement.

  3. We propose an efficient keyframe-based depth representation and fusion method which can generate and timely update the dense 3D surface with online correction without delay.

Ii Related Work

In the past few years, many methods have been proposed to use RGB-D camera data for dense 3D reconstruction and real-time SLAM. Huang et al. [13] proposed to use RGB-D data for real-time odometry, while dense mapping is done offline using sparse bundle adjustment (BA). Endres et al. [14]

presented a 3D mapping system using various visual features in combination with depth to estimate camera motion, while using 3D occupancy grid maps to represent the environment. Kerl et al. 

[12] proposed a dense direct RGB-D odometry by minimizing photometric error and depth error that leads to a higher pose accuracy when compared to sparse feature based methods. Newcombe et al. [4] proposed an impressive dense SLAM system called KinectFusion, which used an iterative closest point (ICP) algorithm [15] to align each frame to the global model with volumetric fusion. KinectFusion works well in a small scene, but could not handle a large-scale scene because in large-scale scenes the memory requirements for the volumetric space representation quickly exceeds any available memory. In addition, it suffers from drift problems and cannot handle loop closure. Following KinectFusion, many methods have been proposed to address these two problems. Most of them [16, 17, 5] focused on exploiting more effective data structures for real-time volumetric fusion in a larger scale scene. For example, Kintinuous [16] extends the KinectFusion with volume shift. Niener et al. [5] proposed to use a sparse volumetric grid to store the volumetric information with spatial hashing. However, the drift problem of pose estimation and online dense surface adjustment are not addressed in these methods.

Drift-free pose estimation and sparse mapping have been extensively studied in visual SLAM. Many monocular SLAM methods have been proposed which can perform real-time tracking and sparse mapping in a small workspace [1] or even a street-scale scene [2, 3]. Relocalization and loop closure also can be handled online by some methods [2, 3, 18]. However, these methods do not generate dense 3D models. Although some methods [19, 20, 21, 22] have been proposed to reconstruct dense 3D models online, it is still either limited to a small scene, or drift-free dense 3D reconstruction is not considered.

Although some offline methods [23, 24, 25] can close loops to obtain a drift-free dense 3D reconstruction, the computation speed is still far from real-time. Recently, Whelan et al.[9] proposed a novel real-time dense RGB-D SLAM system with volumetric fusion, which can detect loop closure in a large-scale scene and correct drift through as-rigid-as-possible surface deformation. Instead of volumetric fusion, ElasticFusion [7] employed a surfel-based fusion method and also used the non-rigid surface deformation technique for loop closure and model refinement. Both of these methods use frame-to-model alignment, where the alignment error will affect the model accuracy, and the erroneous model will significantly harm the camera tracking. Using surface deformation with loop closure constraints cannot correct this error, so the tracking will eventually fail in complex environments. BundleFusion [10] uses brute-force matching to register frames, and re-integrates the depth maps of adjusted frames to obtain a globally consistent reconstruction. However, BundleFusion saves all input data, which is intractable for processing long sequences. In addition, the computation of brute-force matching also will become too time consuming for processing a very long sequence even with very powerful GPUs. Most recently, Maier et al. [11] proposed to use a keyframe fusion and re-integration strategy which can efficiently perform surface correction on-the-fly. In our system, we adopt this strategy with further improvement to perform depth fusion more timely.

Bundle Adjustment [26] or pose graph optimization [27, 28, 29] is frequently used in SLAM or SfM systems to reduce accumulation error or close loops to eliminate reconstruction drift. Several works exploited the incremental nature of SLAM to speed up BA or smoothing [30, 31, 32, 33]. Instead of constructing and factorizing the information matrix from scratch for each incoming frame, Kaess et al. [30] proposed to incrementally update the QR factorization of the information matrix. Later, Kaess et al. [31] further improved this method by using the Bayes tree to efficiently identify the subset of variables and the part of factorization that need to be updated. In [32], a similar method was proposed to update the mean of variables. In addition, it proposes an efficient method to update the covariance of variables. Most recently, Ila et al. [33] proposed to incrementally update Schur complement for achieving fast incremental bundle adjustment. The covariance matrix is also efficiently recovered in their method.

Iii Framework Overview

Fig. 1: Framework of our system
Fig. 2: Framework of our keyframe-based tracking.

Figure 1 illustrates the framework of our system, which performs tracking and mapping in parallel threads. For each input frame, which contains an RGB image and a depth image, our system combines RGB-D alignment and a homography-based feature tracking method with depth filtering to make camera tracking as robust as possible. We also extract ORB features [34] for keyframes and match them with bags-of-words place recognition method [35] to detect loop closure and build loop constraints. Periodically, an incremental BA is invoked in the background to refine the camera poses of keyframes and sparse 3D points. The mapping component will fuse the depth map of each input frame if its camera pose is accurately estimated. In order to allow adjusting of the dense surface online, the depth map is first fused to the keyframe with largest overlapping, which is followed by de-integration and integration in keyframes. This strategy allows our system to only re-integrate the depth maps and associated 3D point cloud of keyframes whose camera poses are refined by BA. By controlling the number of keyframes in a moderate size scene, our system can run in real-time without time limitation, even on a laptop.

Iv Keyframe-based Tracking

Our keyframe-based tracking leverages both intensity and depth information to track camera motion for each frame. We combine both dense RGB-D based and sparse feature based methods to make the odometry more robust. The framework is illustrated in Figure 2.

Iv-a Feature Tracking with Low-resolution RGB-D Alignment

For each current frame  (its camera pose is denoted as ), we first use a fast RGB-D alignment algorithm to estimate the relative pose from last frame . Here we only need a coarse estimate of , so we use “small blurry image” (SBI) as used in [36] to achieve strong real-time performance without GPU acceleration.

Similar to [12], we project the previous frame to current frame and estimate the relative pose by solving the following energy function combining photometric error and inverse depth error

(1)

where and are the SBIs of and respectively. and are the downsampled depth maps of and respectively. denotes the homogenous coordinate of , and extracts the -component of . is the projective function . and are the parameters controlling corresponding weights. is the Huber norm

In our experiments, we generally set the Huber threshold .

An accurate pose estimate is obtained by feature correspondences. We track the map features in keyframes to the current frame by the homography-based feature tracking proposed in [18] to handle strong rotation and fast motion. For reducing computation, we only use global homography for tracking. During strong rotation and fast motion, the perspective distortion between frames may be too large for robust feature matching. Homography helps to rectify the patch distortion, so that the simple zero-mean SSD [1] is able to work.

As in [18], we propagate the global homography from the last frame to the current frame. For a keyframe , the global homography is propagated as , where is obtained by direct image alignment using the small blurry image (SBI) as used in [36]:

(2)

where and are the SBIs of last frame and the current frame respectively. The tilde above the homography converts from the original image space to that of SBI. After obtaining a set of feature matches between keyframe and current frame , we refine by:

(3)

Incorporating into direct image alignment can prevent the solution being biased towards a major plane.

Note that we only need to track a small set of keyframes to the current frame. Similar to [3], we first select the set containing keyframes sharing common points with the last frame, then select the second set sharing common points with keyframes in .

Homography is also used to determine a small search region around instead of searching along the whole epipolar line. In this work, since we have depth measurement and the estimated camera pose obtained by RGB-D alignment , we define the search region as the union of the one around and the one around . Here denotes the homogenous coordinate of , and is the intrinsic matrix which is assumed to be known and constant.

With the relative pose estimated by low-resolution RGB-D alignment and the set of 3D-2D feature correspondences obtained by homography-based feature tracking, we estimate the camera pose by minimizing both the relative pose error and re-projection error

(4)

where maps the 3D rigid transform to

, and returns the minimal vector in

. Here, is the squared Mahalanobis distance, and is the measured depth value at in the current frame. and are normalization parameters that control the corresponding weights. In our experiments, they are generally set to pixel and , respectively.

Iv-B Depth Filtering

If tracking fails, we invoke the relocalization procedure as in [36] to track features again. Otherwise, we use the new feature measurements to filter depths of those features. In the pose estimation of (4), the 3D positions are assumed to be known and kept fixed during optimization. can be obtained directly from the depth measurement at the keyframe when the feature was first extracted, i.e. , where

. The depth value can be further refined by the following frames with new depth measurements. The depth filter must be robust to outliers since many features are extracted at object boundaries where depth measurements are unreliable.

We use the Bayesian depth filter proposed in [37], which has been successfully used in other SLAM systems like SVO [38] and REMODE [39]

. The filter continuously updates the joint distribution of the depth estimate

and the inlier probability

by each incoming depth measurement

with variance

. The distribution of the measurement given the correct and is modeled as a Gaussian + uniform mixture distribution:

(5)

Given the set of measurements , the Bayesian posterior distribution of and is estimated by

(6)

where is the prior on and . Simply evaluating all probabilities of (6) and choosing the best and is computationally too expensive. The authors of [37] propose a parametric Gaussian beta approximation to (6):

(7)

where ,

are parameters controlling the Gaussian distribution, and

,

are parameters controlling the beta distribution. These parameters are incrementally updated by each depth measurements. Substituting (

7) to (6), we obtain

(8)

By matching the first and second order moments for

and in (8), the updated parameters can be derived.

In our implementation, we use inverse depth [40], which is better approximated by a Gaussian distribution, i.e. . For each feature correspondence between keyframe and current frame , we obtain a new measurement for the inverse depth of as:

(9)

where . The filter continuously updates the joint distribution of and its inlier probability by each incoming . Please see [37] for more details. At last, we decide whether is selected as a new keyframe. The keyframe which has maximal number of feature matches with is denoted as . If the difference of view angle between and exceeds , or the distance between them exceeds  ( is the mean depth of ), then we select as a new keyframe.

Fig. 3: Comparison with/without low-resolution RGB-D alignment. (a) Warping frame 27 to frame 28 with the camera pose estimated by combining feature tracking and low resolution RGB-D alignment. (b) Warping frame 27 to frame 28 with the camera pose estimated by feature tracking only. (a) has much better alignment result than (b), which indicates that the estimated camera pose is more accurate.

Figure 3 shows a comparison with and without low-resolution RGB-D alignment. For simulating fast motion, we extract one frame for every 10 frames from “fr3_long_office” sequence in TUM RGB-D dataset [41] to constitute a new sequence and then perform tracking. With low-resolution RGB-D alignment, the tracking robustness is significantly improved but the computation does not increase much.

V Incremental Bundle Adjustment

BA is performed when a new keyframe is inserted, or a new loop is found. In the former case, performing global BA seems to be unnecessary because only the local map will actually change. However, only performing local BA tends to be suboptimal especially when the local map contains large error. In that case it is better to involve more variables to BA, or else the error cannot be completely eliminated. We propose an efficient incremental BA (called EIBA) that is able to provide nearly the same solution as global BA, but with significantly less computation time, which is proportional to how many variables are actually changed.

Before diving into our EIBA, we first revisit the algorithm of standard BA [26]. For easier illustration, we first introduce a regular BA function as follows:

which contains re-projection error term and inverse depth prior term. is the set of cameras in which point is visible. The Huber norms can be converted to the form of squared sum using re-weighting scheme [42]:

(10)

where (first two components for image re-projection and the third for depth prior). At each iteration, is linearized at the current estimate as

(11)

where is the Jacobian of with respect to , is the Jacobian of with respect to , and is the residual error of . So we have

(12)

where is the Jacobian matrix, is the error vector, is the number of re-projection functions, and is the number of cameras and points respectively. is the variable for the current iteration, , and . The update is obtained by solving the normal equations

(13)

Since each relates only one camera and one point, the normal equations are sparse and have the following form:

(14)

where and are and block matrices respectively, and only the diagonal block matrices and are non-zero. is a block matrix with non-zero block matrices if and only if point is visible in camera . For efficient indexing and computation, we actually do not construct the whole matrices for , and . Similar to [43], we compute and store the small non-zero block matrices , , . Compared to using general sparse matrix format, this data structure is more efficient and requires less memory space. Especially, when new keyframes or 3D points are added during incremental reconstruction, we do not need to reconstruct from scratch and only need to add new block matrices.

We first introduce the standard BA procedure as described in Algorithm 1. Equation (14) can be efficiently constructed as in step 1. A common strategy to solve (14) is to marginalize all points to construct the Schur complement and solve first

(15)

Note that is also sparse, with non-zero block matrix if and only if camera and share common points, thus can be efficiently constructed as in step 2 of Algorithm 1. The sparseness of can also be exploited to solve . We use the preconditioned conjugate gradient (PCG) algorithm [43] which naturally leverages the sparseness of . With solved , each can be solved separately by back substitution:

(16)
Step Complexity
1 or
2 or
3
4 or
TABLE I: Computational complexity for each step in standard BA (Algorithm 1).

Because of the criterion of keyframe selection, only a small number of keyframe pairs share common points. We assume the number of 3D points is , the number of keyframes is , and the average observation number of each 3D point in keyframes is . So the average number of the observations in each keyframe is . We assume the average number of PCG iterations is . Table I lists the computational complexity for each step, showing that most computation is required for steps 1 and 2. In most cases, is much larger than the number of PCG iterations , typically hundreds for and dozens for . Then the computation consumed in steps 1 and 2 would be hundreds of times larger than for step 3.

During incremental reconstruction, most variables are nearly unchanged after global BA, thus most computation in steps 1, 2, and 4 are actually unnecessary. Specifically, in step 1, the contribution of most s to (14) nearly remains the same between successive iterations. Here, we propose an efficient incremental BA (EIBA) algorithm which can make maximum use of intermediate computation to save computation. As shown in Algorithm 2, instead of constructing (14) from scratch at each iteration, we update (14) from the last iteration. We store the effect of to (14) in , , and . We initialize , , and in the beginning. They are re-computed if and only if the linearization point of is changed. In this case, we remove their contribution to (14) from the last iteration, refresh them, and update (14) for the current iteration. If and only if is updated, point must be re-marginalized. Then we update point marginalization and Schur complement (15) in a similar way, see Algorithm 2 for details. In step 3, we solve (15) by PCG, and change only if exceeds a threshold . In step 4, we perform back substitution only for points visible in the changed cameras, and change only if exceeds a threshold .

  1. Construct normal equations (14)

    ; ; ; ;
    for each point and each camera  do
         Construct linearized equation (11)
         
         
         
         
         
    end for
  2. Marginalize points to construct Schur complement (15)

    for each point and each camera pair  do
         
    end for
    for each point and each camera  do
         
    end for
  3. Update cameras

    Solve in (15) using PCG [43]
    for each keyframe  do
         
    end for
  4. Update points

    for each point  do
         Solve by (16)
         
    end for
Algorithm 1 One iteration in standard BA
  1. Update normal equations (14) and Schur complement (15)

    for each point and each camera that or is changed do
         Construct linearized equation (11)
         ; ;
         ; ;
         ; ;
         ; ;
         
         Mark updated
    end for
  2. Update point marginalization and Schur complement (15)

    for each point that is updated and each camera pair  do
         
         
         
    end for
    for each point that is updated and each camera  do
         ; ;
    end for
  3. Update cameras

    Solve in (15) using PCG [43]
    for each keyframe that  do
         
         Mark changed
    end for
  4. Update points

    for each point that any with is changed do
         Solve by (16)
         if  then
              
              Mark changed
         end if
    end for
Algorithm 2 One iteration in our incremental BA

The above paragraphs introduce the incremental optimization with a regular BA function. Actually, our EIBA is quite general and can be naturally extended to solve the following energy function:

(17)

where is the set of loop constraint. Each loop constraint is represented as relative pose with covariance . It does not harm the sparseness of normal equation or Schur complement. When the state of or is changed, the error function is re-linearized as

(18)

Then , and are updated to , and respectively. Similarly, and are updated to and respectively. In addition, we use inverse depth to parameterize . Assuming the first keyframe that is observed is frame , we have . So each re-projection equation actually relates two camera poses (i.e. and ) and one 3D point . So at each iteration, is linearized as

(19)

where is the Jacobian of with respect to . So in Step 1 of Algorithm 2, we also need to update , , and for each observation.

Sequence Num. of Camera / Points Num. of Observations EIBA iSAM2
No relinearization relinearizeSkip = 10 relinearizeSkip = 5
fr3_long_office 92 / 4322 12027 88.9ms 983.9ms 1968.2ms 2670.9ms
fr2_desk 63 / 2780 6897 34.8ms 507.8ms 850.4ms 1152.0ms
TABLE II: Timing comparison for incremental BA.

Although our incremental Schur complement is essentially similar to [33], our computation is more efficient with block-wise matrix computation and storing the updated matrix blocks for reducing calculation. In addition, we use preconditioned conjugate gradient (PCG) algorithm to solve the linear system, which is more efficient than using factorization methods due to the following reasons: 1) block-based PCG can better leverage the sparseness to efficiently solve Schur complement as verified in [43], and 2) PCG can make the most of the incremental nature because good initial values of the variables can be easily obtained in incremental BA so that a few iterations are generally enough to converge.

Kaess et al. [44] also performs incremental BA (called iSAM2) by updating a matrix factorization. In iSAM2, the square root information matrix of is encoded in a Bayes tree, in which each node contains a set of frontal variables and represents a conditional density , where is contained in the frontal variables of its parent node. Inserting a new keyframe will only affect nodes containing its visible points as frontal variables and their ancestor nodes. All the affected variables will be re-eliminated. For efficiency, it is better to push the visible points of the new keyframe to the root, i.e. marginalizing these points in the end. However, if their visible cameras are marginalized before them, correlations among these points will occur, which significantly degrades efficiency. In addition, if the camera is moving to and fro, a large number of invisible points may also be affected by iSAM2. By comparison, in our EIBA, points are always marginalized first to minimize fill-in, and only the points visible in the new keyframe will be affected. Although all the cameras will also be affected in step 3, since we are dealing with moderate size scenes, the number of cameras is much smaller than the number of points potentially affected by iSAM2. Besides, the Schur complement is very sparse, so that PCG is able to solve it very efficiently.

We use “fr3_long_office” and “fr2_desk” sequences from TUM RGB-D benchmark [41] to make comparisons with iSAM2. On “fr3_long_office”, there are keyframes, 3D points and observations. On “fr2_desk” sequence, there are keyframes, 3D points and observations. We perform incremental BA for (17) while adding each new keyframe. For fair comparison, both two mehods perform only one iteration. Since our EIBA applies SSE instructions for code optimization, we also enable SSE optimization while compiling Eigen library used in iSAM2. We use Gauss-Newton optimization method for both EIBA and iSAM2. In addition, the linearization parameter will significantly influence the speed and accuracy of iSAM2. In our experiments, we test three configurations for iSAM2, i.e. no linearization, linearization every 10 steps, and linearization every 5 steps. The running time is tested on a desktop PC with i7 3.6GHz CPU and 16G memory. Figure 4 shows the computation time for EIBA and iSAM2 while adding each new keyframe (the time of loading data is not included). Table 4 shows the total running time. As can be seen, for our EIBA, the computation almost keeps constant (about ms) when the number of keyframes increases, except when loop closure is detected, in which case the poses of more keyframes need to be updated. Although the computation of iSAM2 also almost keeps constant, it is generally slower than ours by an order of magnitude even without using linearization. The optimized reprojection error by EIBA is lower than iSAM2 without linearization and comparable with iSAM2 with relinearizeSkip = 5, as shown in Figure 5.

Especially, we found that the computation time of iSAM2 significantly increases when loop clousre is detected. In contrast, the computation time of EIBA does not increase so much (only increases to about ). The reason is that when a large loop detected, the information matrix will become very dense and almost all varaibles need to be updated. In EBA, although the Schur complement matrix will become very dense in this case, we use block-based PCG algorithm to solve the linear system which is more efficient than using a factoriation method.

Fig. 4: The computation time of our EIBA and iSAM2 while incrementally adding each new keyframe on “fr3_long_office” sequence.
Fig. 5: The optimized reprojection error (RMSE) for our EIBA and iSAM2 while incrementally adding each new keyframe on “fr3_long_office” sequence.

Vi Keyframe-based Dense Mapping

Similar to [11], we also do integration and de-integration in keyframes. We use a volumetric method with spatial hashing [5], to fuse the depth maps to construct the complete 3D model. Kahler et al. [8] proposed a very efficient volumetric integration method based on voxel block hashing. We adapt this method for fast volumetric fusion. When the camera pose of the current frame is estimated with good quality, we need to fuse the depth map into the global model. However, if we directly integrate the depth map of each frame and discard the frame, we could not correct the model again when a loop closure is detected or the poses of frames are refined by BA. A simple solution is to store all the depth maps and re-integrate them once the camera poses are refined. However, this will be intractable for real-time application since the number of frames always increases and may become very large. So we proposed to use keyframes to represent the depth data and operate integration and de-integration in keyframes.

If the current frame is selected as keyframe, we can directly integrate the depth map into the global model. For each voxel , its truncated signed distance is denoted as , and the weight is denoted as . For pixel in , its SDF is defined as , where denotes the projected depth in for voxel . If where is a pre-defined truncated value, we can update the corresponding TSDF of as

(20)

where is the integration weight for .

If is not selected as keyframe, we first find the keyframe which has maximal number of feature matches with , denoted as . We de-integrate the depth map of from the global model. Inspired by [10], the de-integration operation is similar to integration. If , each voxel can be updated as

(21)

After de-integration, we fuse depth map into by projecting it to , which is similar to that in [11]. The major difference is that we take into account the occlusion and store the unfused depths instead of simply discarding. For pixel in , its projection in is denoted as . If the difference of the inverse depth of pixel  (i.e. ) and the projected inverse depth of  (denoted as ) is less than a threshold , we filter the depth of as

(22)

About in (20), (21) and (22), we set it as follows: if is in a key frame, is set to the filtering number of , otherwise it is set to 1.

We count the fusion number for each keyframe to control the maximum number of depth fusion since too many fusions may be unnecessary and even degrade the reconstruction quality. Since the overlap of and is generally large, most depths of the current frame can be fused into except some pixels that are occluded or out of view. This strategy can significantly reduce the depth redundancy. If the number of unfused depths is less than a threshold , we simply discard these unfused 3D points. Otherwise, we create a point cloud set to store these unfused 3D points, and link it to  (we store the relative pose between and for 3D points projection during integration and de-integration). Then we integrate the updated depth map . If is not empty, the 3D points in are also projected into , and then we perform integration on . So for each incoming frame that is not selected as keyframe, we perform two integrations and one de-integration. Since the number of unfused 3D points in is small, the integration time is also small. So the computation time of our keyframe-based fusion is generally slightly larger than two times that of the traditional volumetric fusion method. In [11], they first fuse a constant number of non-keyframes to a nearest keyframe, and then integrate the depth map of this keyframe to the 3D model. The 3D model will be not updated until the keyframe fusion is finished. In our method, since we first de-integrate the old depth map of keyframe from 3D model and then re-integrate the updated depth map immediately while fusing each non-keyframe to , the 3D model can be timely updated without delay. If is large and the number of keyframes is not increased for a long time, it means that not sufficient new content has been scanned. In this case, we simply discard without fusion.

Fig. 6: Comparison with/without re-integration. (a) The reconstructed 3D model without re-integration. (b) The reconstructed 3D model with our keyframe-based re-integration, which is more accurate and globally consistent than (a), as highlighted with the red rectangle.

To further reduce redundancy, if the current frame is selected as keyframe, we find the point cloud sets linked to nearby keyframes and fuse them to . If the remaining number of points of is too small after fusion (less than in our experiments), we will simply discard it and de-integrate it from the global map. Otherwise, we only de-integrate the 3D points which have been fused into . For real-time computation, we only fuse point cloud sets in our experiments.

If the poses of keyframes are modified by BA, we need to re-integrate the depth maps of all the updated keyframes and their linked point cloud sets. However, if the number of adjusted keyframes is large, the re-integration time will be too large to satisfy real-time applications. Therefore, we propose to limit the number of re-integration operations for each time instance. We maintain a update queue for the keyframes which poses have been updated. The keyframes with largely changed poses will be re-integrated with higher priority. This strategy can guarantee that the mapping can always run with almost constant speed even when BA is invoked. In [11], they perform depth re-integration only when receiving a pose update, and the uncorrected depth maps of the adjusted poses need to wait for re-integration in a final pass. In contrast, we perform surface update for each time instance so that the surface can be corrected more timely. The uncorrected depth maps of the updated poses still have chance to be re-integrated in the next time instance, and do not need to wait for the re-integration in a final pass. Figure 6 shows a comparison with and without re-integration. As can be seen, due to accumulation error, if we do not re-integrate the depth maps, the reconstructed 3D surface has obvious artifacts. In contrast, with our keyframe-based re-integration, the reconstructed 3D surface becomes more accurate and globally consistent.

For further acceleration, we can fuse only one frame out of every two or more frames, which does not degrade much the reconstruction quality but can significantly accelerate the volumetric fusion.

Fig. 7: Our reconstructed 3D model for “Cubes” sequence.
Fig. 8: Comparison in a low-frame-rate example. (a) The reconstruction of ours. (b) The reconstruction of Kintinuous. (c) The reconstruction of ElasticFusion.
Fig. 9: Our reconstruction result of “Office” dataset with frames in total.

Vii Experimental Results

We have conducted experiments with both TUM RGB-D benchmark [41] and indoor sequences captured by ourselves. On a desktop PC with an Intel i5 3.3GHz CPU, 20GB memory and GTX 1070 graphics card (8GB video memory), the tracking component without GPU acceleration takes about ms per frame, and the dense mapping component in the foreground thread takes about ms per frame. The whole system enabling both tracking and dense mapping runs above 50fps. For a laptop with an Intel i7 2.6GHz CPU, 16GB memory and GTX 960M graphics card (4GB video memory), the system runs around 30fps. If we fuse only one out of three frames, the running time could be even faster.

Ours Ours Kintinuous ElasticFusion DVO-SLAM RGB-D SLAM MRSMap BundleFusion
(all frames) (key frames)
 fr1_360 13.0cm 10.9cm 10.8cm 8.3cm
 fr1_desk 2.5cm 2.1cm 3.7cm 2.0cm 2.1cm 2.3cm 4.3cm 1.6cm
 fr1_desk2 2.8cm 2.4cm 7.1cm 4.8cm 4.6cm 4.3cm 4.9cm
 fr1_floor 325.3cm 26.2cm -
 fr1_plant 5.0cm 3.8cm 4.7cm 2.2cm 2.8cm 9.1cm 2.6cm
 fr1_room 14.8cm 13.4cm 7.5cm 6.8cm 5.3cm 8.4cm 6.9cm
 fr1_rpy 2.2cm 3.7cm 2.8cm 2.5cm 2.0cm 2.6cm 2.7cm
 fr1_teddy 18.7cm 15.7cm 8.3cm 3.4cm
 fr1_xyz 1.0cm 0.7cm 1.7cm 1.1cm 1.1cm 1.4cm 1.3cm
 fr2_360_hemisphere 37.6cm 31.1cm -
 fr2_360_kidnap 132.6cm 6.1cm -
 fr2_coke 17.2cm 20.2cm -
 fr2_desk 7.2cm 7.1cm 3.4cm 7.1cm 1.7cm 5.7cm 5.2cm
 fr2_dishes 8.4cm 7.9cm -
 fr2_large_no_loop - - - 8.6cm
 fr2_large_with_loop 198.3cm 196.7cm -
 fr2_metallic_sphere 34.1cm 44.3cm -
 fr2_metallic_sphere2 11.1cm 8.4cm -
 fr2_pioneer360 40.5cm 35.8cm -
 fr2_pioneer_slam 91.2cm 85.5cm -
 fr2_pioneer_slam2 169.7cm 3.3cm -
 fr2_pioneer_slam3 28.1cm 19.1cm -
 fr2_rpy 0.8cm 0.6cm 1.5cm
 fr2_xyz 1.2cm 1.2cm 2.9cm 1.1cm 1.8cm 0.8cm 2.0cm 1.1cm
 fr2_flowerbouquet 7.0cm 5.0cm
 fr2_flowerbouquet_brownbackground 53.3cm 51.7cm
 fr2_desk_with_person 4.7cm 4.5cm
 fr3_cabinet 39.9cm 7.9cm -
 fr3_large_cabinet 20.9cm 14.8cm 9.9cm
 fr3_long_office_household 3.2cm 2.8cm 3.0cm 1.7cm 3.5cm 3.2cm 4.2cm 2.2cm
 fr3_nostructure_notexture_far - - -
 fr3_nostructure_notexture_near_with_loop - - -
 fr3_nostructure_texture_far 10.8cm 5.3cm 7.4cm
 fr3_nostructure_texture_near_withloop 2.9cm 2.7cm 3.1cm 1.6cm 1.8cm 1.7cm 201.8cm 1.2cm
 fr3_structure_notexture_far - - 3.0cm
 fr3_structure_notexture_near - - 2.1cm
 fr3_structure_texture_far 1.8cm 1.6cm 1.3cm
 fr3_structure_texture_near 1.6cm 1.8cm 1.5cm
 fr3_nostructure_notexture_near - -
 fr3_teddy - - 4.9cm
 fr3_sitting_xyz 2.1cm 1.7cm
 fr3_walking_xyz 2.8cm 2.4cm
 fr3_sitting_halfsphere 1.7cm 1.9cm
 fr3_sitting_static 1.3cm 0.9cm
 fr3_walking_static 5.2cm 3.9cm
 fr3_walking_rpy 42.0cm 33.7cm
 fr3_sitting_rpy 2.7cm 4.1cm
 fr3_walking_halfsphere 25.6cm 18.2cm
TABLE III: Comparison of ATE RMSE on all of the scenes in the TUM RGB-D benchmark.

Vii-a Qualitative Evaluation

We first evaluate our system with some challenging datasets captured by ourselves, which may contain complex loops with fast motion and are very long.

Loop Closure and Low-frame-Rate Sequences. Figure 7 shows an indoor example “Cubes” where the scale is large and there are complex loops. The number of frames is 14,817. As can be seen, our method faithfully detect and close the loops, achieving a drift-free 3D reconstruction result, as shown in Figure 7. Our system also can handle low-frame-rate sequences. We extract every third frame from “Cubes” sequence to constitute a new sequence. Figure 8 (a) shows the reconstruction result by our system, which is comparable to the original one. The reconstructions of Kintinuous and ElasticFusion are shown in Figures 8 (b) and (c), both of which have serious drift. Please refer to our supplementary video for more examples and comparison results.

Time Limitation. Our system can produce drift-free 3D reconstruction without time limitation in a moderate scale scene since the number of keyframes is not always increased in this case. Figure 9 shows another indoor example where the camera capture 20,862 frames in total. Our system can process all data and produce drift-free reconstruction.

Relocalization. For some extremely challenging cases, the tracking may be lost. In our system, if the tracking is poor or even lost, the depth map will be not integrated. The camera can be relocalized when the camera moves back to a previously visited position. Please refer to our supplementary video to watch the result and comparison to other systems.

Vii-B Quantitative Evaluation of Trajectory Accuracy

We use the RGB-D benchmark of Sturm et al. [41] to evaluate our system and make comparisons with other state-of-the-art systems, i.e. DVO-SLAM [12], RGBD-SLAM [45], MRSMap [46], Kintinuous [16], ElasticFusion [7], BundleFusion [10]. We test all scenes in the RGB-D benchmark of Sturm et al. [41]. Table III shows the measured absolute trajectory error (ATE). For other methods, we directly use the reported ATE from their papers: “-” indicates tracking failure, and the blank indicates not reported. Since our system uses keyframes, we compute the RMSE of keyframes for our method. For more fair comparison, we also compute ATE for all frames. Specifically, we output the camera pose when a frame is processed, which will not be further refined by BA. In contrast, the camera poses of keyframes are refined by BA, so their error is further minimized. As can be seen, our system achieves quite comparable results with the state-of-the-art methods. Compared to ElasticFusion [7] which tested on all of the static scenes in the RGB-D benchmark of Sturm et al. [41], our method can track successfully in more scenes, which demonstrate the robustness of our keyframe-based tracking.

Vii-C Quantitative Evaluation of Surface Accuracy

We perform surface reconstruction accuracy on the synthetic ICL-NUIM dataset [47], which provides the synthetic 3D model with ground truth camera poses. We select three living room scenes (including synthetic noise) to evaluate our approach. The measured ATE RMSE are listed in Table IV 111For “kt0” sequence, because 30.5% frames are lost for our method, we only use the successfully recovered cameras poses to compute ATE RMSE., and the surfce reconstruction accuracy results are shown in Table V. For these three scenes, some frames are quite textureless which make tracking very challenging. Especially, our method only perform low-resolution RGB-D alignment and may have problem if the scene is extremely textureless and there are not sufficient features can be matched. Especially, in “kt0” sequence, the camera poses of 30.5% frames are not recovered due to this reason. Due to imperfect camera parameters in this dataset, the surface accuracy of our method is slightly worse than ElasticFusion and BundleFusion. Nevertheless, the surface accuracy of reconstruction results by using keyframe-based fusion and every frame fusion are quite comparable, which demonstrate the effectiveness of our keyframe-based fusion method.

Seq. kt0 kt1 kt2
Ours (all frames) 11.9cm 2.4cm 4.2cm
Ours (key frames) 1.8cm 1.6cm 3.2cm
Kintinuous 7.2cm 0.5cm 1.0cm
ElasticFusion 0.9cm 0.9cm 1.4cm
DVO-SLAM 10.4cm 2.9cm 19.1cm
RGB-D SLAM 2.6cm 0.8cm 1.8cm
MRSMap 20.4cm 22.8cm 18.9cm
BundleFusion 0.6cm 0.4cm 0.6cm
TABLE IV: Comparison of ATE RMSE on the synthetic ICL-NUIM dataset.
Seq. kt0 kt1 kt2
Our keyframe-based fusion 0.9cm 1.1cm 1.6cm
Our every frame fusion 0.8cm 1.3cm 1.8cm
Kintinuous 1.1cm 0.8cm 0.9cm
ElasticFusion 0.7cm 0.7cm 0.8cm
DVO-SLAM 3.2cm 6.1cm 11.9cm
RGB-D SLAM 4.4cm 3.2cm 3.1cm
MRSMap 6.1cm 14.0cm 9.8cm
BundleFusion 0.5cm 0.6cm 0.7cm
TABLE V: Comparison of surface accuracy on the synthetic ICL-NUIM dataset.

Viii Discussions and Conclusions

In this paper, we have presented a novel keyframe-based dense SLAM approach which is not only robust to fast motion, but also can recover from tracking failure, handle loop closure and adjust the dense surface online to achieve drift-free 3D reconstruction even on a laptop. In order to achieve this goal, we first contributed a keyframe-based tracking approach which combines color and geometry information to make the tracking as robust as possible. Secondly, we proposed a novel incremental BA which makes maximal use of intermediate computation to save computation and adaptively update necessary keyframes for map refinement. Finally, we proposed a keyframe-based dense mapping method which can adjust the dense surface online by a few de-integration and integration operations. The depths of non-keyframes are fused into keyframes as much as possible to reduce redundancy. With this representation, our system not only can adjust the dense surface online but also can operate for extended periods of time in a moderate size scene.

Our system still has some limitations. If the scene is fully planar and extremely textureless, our system may fail. In addition, our system still has difficulties in handling serious motion blur. In future work, we would like to include inertial measurements to further increase robustness.

Acknowledgment

The authors would like to thank Bangbang Yang, Weijian Xie and Shangjin Zhai for their kind help in making experimental results and comparisons.

References

  • [1] G. Klein and D. W. Murray, “Parallel tracking and mapping for small AR workspaces,” in 6th IEEE/ACM International Symposium on Mixed and Augmented Reality, 2007, pp. 225–234.
  • [2] J. Engel, T. Schöps, and D. Cremers, “LSD-SLAM: Large-scale direct monocular SLAM,” in 13th European Conference on Computer Vision, Part II.   Springer, 2014, pp. 834–849.
  • [3] R. Mur-Artal, J. Montiel, and J. D. Tardos, “ORB-SLAM: a versatile and accurate monocular SLAM system,” IEEE Transactions on Robotics, vol. 31, no. 5, pp. 1147–1163, 2015.
  • [4] R. A. Newcombe, S. Izadi, O. Hilliges, D. Molyneaux, D. Kim, A. J. Davison, P. Kohli, J. Shotton, S. Hodges, and A. W. Fitzgibbon, “Kinectfusion: Real-time dense surface mapping and tracking,” in 10th IEEE International Symposium on Mixed and Augmented Reality, 2011, pp. 127–136.
  • [5] M. Nießner, M. Zollhöfer, S. Izadi, and M. Stamminger, “Real-time 3D reconstruction at scale using voxel hashing,” ACM Trans. Graph., vol. 32, no. 6, pp. 169:1–169:11, 2013.
  • [6] T. Whelan, S. Leutenegger, R. F. Salas-Moreno, B. Glocker, and A. J. Davison, “Elasticfusion: Dense SLAM without A pose graph,” in Robotics: Science and Systems XI, Sapienza University of Rome, Rome, Italy, July 13-17, 2015, 2015.
  • [7] T. Whelan, R. F. Salas-Moreno, B. Glocker, A. J. Davison, and S. Leutenegger, “Elasticfusion: Real-time dense SLAM and light source estimation,” I. J. Robotics Res., vol. 35, no. 14, pp. 1697–1716, 2016.
  • [8] O. Kahler, V. A. Prisacariu, C. Y. Ren, X. Sun, P. H. S. Torr, and D. W. Murray, “Very High Frame Rate Volumetric Integration of Depth Images on Mobile Device,” IEEE Transactions on Visualization and Computer Graphics (Proceedings of ISMAR 2015), vol. 22, no. 11, 2015.
  • [9] T. Whelan, M. Kaess, H. Johannsson, M. F. Fallon, J. J. Leonard, and J. McDonald, “Real-time large-scale dense RGB-D SLAM with volumetric fusion,” I. J. Robotics Res., vol. 34, no. 4-5, pp. 598–626, 2015.
  • [10] A. Dai, M. Nießner, M. Zollhöfer, S. Izadi, and C. Theobalt, “Bundlefusion: Real-time globally consistent 3D reconstruction using on-the-fly surface reintegration,” ACM Trans. Graph., vol. 36, no. 3, pp. 24:1–24:18, 2017.
  • [11] R. Maier, R. Schaller, and D. Cremers, “Efficient online surface correction for real-time large-scale 3D reconstruction,” in BMVC, 2017, pp. 1–12.
  • [12] C. Kerl, J. Sturm, and D. Cremers, “Dense visual SLAM for RGB-D cameras,” in IEEE/RSJ International Conference on Intelligent Robots and Systems, 2013, pp. 2100–2106.
  • [13] A. S. Huang, A. Bachrach, P. Henry, M. Krainin, D. Maturana, D. Fox, and N. Roy, “Visual odometry and mapping for autonomous flight using an RGB-D camera,” in The 15th International Symposium on Robotics Research, 2011, pp. 235–252.
  • [14] F. Endres, J. Hess, J. Sturm, D. Cremers, and W. Burgard, “3-D mapping with an RGB-D camera,” IEEE Transactions on Robotics, vol. 30, no. 1, pp. 177–187, 2014.
  • [15] P. J. Besl and N. D. McKay, “A method for registration of 3-D shapes,” IEEE Trans. Pattern Anal. Mach. Intell., vol. 14, no. 2, pp. 239–256, 1992.
  • [16] T. Whelan, J. McDonald, M. Kaess, M. Fallon, H. Johannsson, and J. Leonard, “Kintinuous: Spatially extended KinectFusion,” in RSS Workshop on RGB-D: Advanced Reasoning with Depth Cameras, Sydney, Australia, Jul 2012.
  • [17] M. Zeng, F. Zhao, J. Zheng, and X. Liu, “Octree-based fusion for realtime 3D reconstruction,” Graphical Models, vol. 75, no. 3, pp. 126–136, 2013.
  • [18] H. Liu, G. Zhang, and H. Bao, “Robust keyframe-based monocular SLAM for augmented reality,” in IEEE International Symposium on Mixed and Augmented Reality, 2016.
  • [19] R. A. Newcombe, S. Lovegrove, and A. J. Davison, “DTAM: dense tracking and mapping in real-time,” in IEEE International Conference on Computer Vision, 2011, pp. 2320–2327.
  • [20] V. Pradeep, C. Rhemann, S. Izadi, C. Zach, M. Bleyer, and S. Bathiche, “Monofusion: Real-time 3D reconstruction of small scenes with a single web camera,” in IEEE International Symposium on Mixed and Augmented Reality, 2013, pp. 83–88.
  • [21] T. Schöps, T. Sattler, C. Häne, and M. Pollefeys, “3D modeling on the go: Interactive 3D reconstruction of large-scale scenes on mobile devices,” in 2015 International Conference on 3D Vision, 2015, pp. 291–299.
  • [22] P. Ondruska, P. Kohli, and S. Izadi, “Mobilefusion: Real-time volumetric surface reconstruction and dense tracking on mobile phones,” IEEE Trans. Vis. Comput. Graph., vol. 21, no. 11, pp. 1251–1258, 2015.
  • [23] Q. Zhou, S. Miller, and V. Koltun, “Elastic fragments for dense scene reconstruction,” in IEEE International Conference on Computer Vision, ICCV 2013, Sydney, Australia, December 1-8, 2013, 2013, pp. 473–480.
  • [24] K. Wang, G. Zhang, and H. Bao, “Robust 3D reconstruction with an RGB-D camera,” IEEE Trans. Image Processing, vol. 23, no. 11, pp. 4893–4906, 2014.
  • [25] S. Choi, Q. Zhou, and V. Koltun, “Robust reconstruction of indoor scenes,” in

    IEEE Conference on Computer Vision and Pattern Recognition

    , 2015, pp. 5556–5565.
  • [26] B. Triggs, P. F. McLauchlan, R. I. Hartley, and A. W. Fitzgibbon, “Bundle adjustment - a modern synthesis.” in Workshop on Vision Algorithms, 1999, pp. 298–372.
  • [27] E. Olson, J. J. Leonard, and S. J. Teller, “Fast iterative alignment of pose graphs with poor initial estimates,” in Proceedings of IEEE International Conference on Robotics and Automation, 2006, pp. 2262–2269.
  • [28] H. Strasdat, J. M. M. Montiel, and A. J. Davison, “Scale drift-aware large scale monocular SLAM,” in Robotics: Science and Systems VI, 2010.
  • [29] R. Kümmerle, G. Grisetti, H. Strasdat, K. Konolige, and W. Burgard, “go: A general framework for graph optimization,” in IEEE International Conference on Robotics and Automation, 2011, pp. 3607–3613.
  • [30] M. Kaess, A. Ranganathan, and F. Dellaert, “iSAM: Incremental smoothing and mapping,” IEEE Transactions on Robotics, vol. 24, no. 6, pp. 1365–1378, 2008.
  • [31] M. Kaess, H. Johannsson, R. Roberts, V. Ila, J. J. Leonard, and F. Dellaert, “iSAM2: Incremental smoothing and mapping using the bayes tree,” The International Journal of Robotics Research, vol. 31, no. 2, pp. 216–235, 2012.
  • [32] V. Ila, L. Polok, M. Solony, and P. Svoboda, “SLAM++ -a highly efficient and temporally scalable incremental slam framework,” The International Journal of Robotics Research, vol. 36, no. 2, pp. 210–230, 2017.
  • [33] V. Ila, L. Polok, M. Solony, and K. Istenic, “Fast incremental bundle adjustment with covariance recovery,” in International Conference on 3D Vision, 2017, pp. 4321–4330.
  • [34] E. Rublee, V. Rabaud, K. Konolige, and G. Bradski, “ORB: an efficient alternative to SIFT or SURF,” in IEEE International Conference on Computer Vision.   IEEE, 2011, pp. 2564–2571.
  • [35] D. Gálvez-López and J. D. Tardós, “Bags of binary words for fast place recognition in image sequences,” IEEE Transactions on Robotics, vol. 28, no. 5, pp. 1188–1197, 2012.
  • [36] G. Klein and D. W. Murray, “Improving the agility of keyframe-based SLAM,” in 10th European Conference on Computer Vision, Part II.   Springer, 2008, pp. 802–815.
  • [37] G. Vogiatzis and C. Hernández, “Video-based, real-time multi-view stereo,” Image Vision Comput., vol. 29, no. 7, pp. 434–441, 2011.
  • [38] C. Forster, M. Pizzoli, and D. Scaramuzza, “SVO: Fast semi-direct monocular visual odometry,” in IEEE International Conference on Robotics and Automation.   IEEE, 2014, pp. 15–22.
  • [39] M. Pizzoli, C. Forster, and D. Scaramuzza, “REMODE: probabilistic, monocular dense reconstruction in real time,” in 2014 IEEE International Conference on Robotics and Automation, ICRA 2014, Hong Kong, China, May 31 - June 7, 2014, 2014, pp. 2609–2616.
  • [40] J. Civera, A. J. Davison, and J. M. Montiel, “Inverse depth parametrization for monocular SLAM,” IEEE Transactions on Robotics, vol. 24, no. 5, pp. 932–945, 2008.
  • [41] J. Sturm, N. Engelhard, F. Endres, W. Burgard, and D. Cremers, “A benchmark for the evaluation of RGB-D SLAM systems,” in IEEE/RSJ International Conference on Intelligent Robot Systems, Oct. 2012, pp. 573–580.
  • [42] R. Hartley and A. Zisserman, Multiple view geometry in computer vision.   Cambridge university press, 2004.
  • [43] Y. Jeong, D. Nister, D. Steedly, R. Szeliski, and I.-S. Kweon, “Pushing the envelope of modern methods for bundle adjustment,” IEEE transactions on pattern analysis and machine intelligence, vol. 34, no. 8, pp. 1605–1617, 2012.
  • [44] M. Kaess, H. Johannsson, R. Roberts, V. Ila, J. J. Leonard, and F. Dellaert, “iSAM2: Incremental smoothing and mapping using the bayes tree,” International Journal of Robotics Research, vol. 31, no. 2, pp. 216–235, 2012.
  • [45] F. Endres, J. Hess, N. Engelhard, J. Sturm, D. Cremers, and W. Burgard, “An evaluation of the RGB-D SLAM system,” in IEEE International Conference on Robotics and Automation, ICRA 2012, 14-18 May, 2012, St. Paul, Minnesota, USA, 2012, pp. 1691–1696.
  • [46] J. Stückler and S. Behnke, “Multi-resolution surfel maps for efficient dense 3D modeling and tracking,” J. Visual Communication and Image Representation, vol. 25, no. 1, pp. 137–147, 2014.
  • [47] A. Handa, T. Whelan, J. McDonald, and A. J. Davison, “A benchmark for RGB-D visual odometry, 3D reconstruction and SLAM,” in 2014 IEEE International Conference on Robotics and Automation, ICRA 2014, Hong Kong, China, May 31 - June 7, 2014, 2014, pp. 1524–1531.