DKB-SLAM: Dynamic RGB-D Visual SLAM with Efficient Keyframe Selection and Local Bundle Adjustment

Abstract

Reliable navigation for mobile robots in dynamic, human-populated environments remains a significant challenge, as moving objects often cause localization drift and map corruption. While Simultaneous Localization and Mapping (SLAM) techniques excel in static settings, issues like keyframe redundancy and optimization inefficiencies further hinder their practical deployment on robotic platforms. To address these challenges, we propose DKB-SLAM, a real-time RGB-D visual SLAM system specifically designed to enhance robotic autonomy in complex dynamic scenes. DKB-SLAM integrates optical flow with Gaussian-based depth distribution analysis within YOLO detection frames to efficiently filter dynamic points, crucial for maintaining accurate pose estimates for the robot. An adaptive keyframe selection strategy balances map density and information integrity using a sliding window, considering the robot’s motion dynamics through parallax, visibility, and matching quality. Furthermore, a heterogeneously weighted local bundle adjustment (BA) method leverages map point geometry, assigning higher weights to stable edge points to refine the robot’s trajectory. Evaluations on the TUM RGB-D benchmark and, crucially, on a mobile robot platform in real-world dynamic scenarios, demonstrate that DKB-SLAM outperforms state-of-the-art methods, providing a robust and efficient solution for high-precision robot localization and mapping in dynamic environments.

1. Introduction

Simultaneous Localization and Mapping (SLAM) is a fundamental technology for mobile robot autonomy, enabling core capabilities such as autonomous navigation, interaction, and exploration. It is widely applied in service robotics, warehouse logistics, autonomous driving, and immersive technologies like augmented reality (AR) and virtual reality (VR). Visual SLAM, which utilizes data from cameras, has gained prominence due to its low cost, rich environmental information, and effectiveness in complex, unstructured environments where other sensors might fail.

In recent years, many remarkable visual SLAM algorithms have emerged [1,2,3,4,5,6,7,8,9], setting milestones in accuracy and robustness. However, a core assumption in most of these systems is a static world. This assumption severely limits their real-world applicability, particularly for robots operating in human-centric environments like homes, hospitals, or public spaces. The presence of moving people, vehicles, or other objects violates this static-world assumption, leading to incorrect feature matching, which in turn causes significant drift in the robot’s estimated trajectory and corruption of the environmental map.

To address the challenges of visual SLAM in dynamic scenes, researchers have focused on two main approaches—geometry-based methods [10,11,12,13] and semantic-based methods [14,15,16,17,18]. Although geometry-based methods perform well in low-dynamic environments, they can struggle with complex dynamic objects and scenes, leading to misjudgments or incorrect rejections. In contrast, semantic analysis-based dynamic point recognition methods perform well in both low- and high-dynamic environments but are computationally expensive, making real-time implementation on resource-constrained robotic platforms challenging, a gap that remains in recent works such as [18].

In a complete SLAM system, keyframe selection plays a crucial role in balancing computational load and mapping accuracy. Traditional methods often rely on static rules, such as fixed-distance or viewing-angle thresholds [1,3,4,5]. These approaches lack adaptability to a robot’s varying motion dynamics; for instance, they may generate redundant keyframes when the robot is stationary or moving slowly, and too few when it is turning or accelerating quickly. While more intelligent strategies exist [19], they often fall short in complex dynamic environments, negatively impacting the robot’s localization accuracy.

Local optimization is another key factor for improving accuracy and robustness in SLAM systems. Traditional approaches, such as [1], typically use a single-weighted strategy, treating all map points equally. Other methods [4,20,21] use sliding-window optimization. While strategies like ICE-BA [22] improve efficiency, they often fail to fully exploit the rich geometric structure of the environment. For a robot navigating a structured indoor space, distinguishing between geometrically stable features (like corners and edges) and less informative ones (like large, textureless planes) can significantly improve optimization. Optimizing all map points equally incurs high computational costs and can lead to suboptimal results.

To address these robotics-centric challenges, we propose DKB-SLAM, a real-time RGB-D visual SLAM system tailored for robust robot navigation in complex environments. The system enables accurate localization in both dynamic and static scenes through efficient keyframe selection and geometry-aware local BA optimization. In summary, the main contributions of this article, framed from a robotics application perspective, are as follows:

• A Novel Hybrid Dynamic Feature Filtering Mechanism: We propose a lightweight yet robust pipeline that enables a robot to navigate reliably amidst dynamic obstacles. The system uses YOLO to quickly identify potential moving objects and then applies a combination of optical flow and statistical depth analysis. This hybrid approach efficiently removes unstable feature points caused by motion while preserving the static background, achieving a superior balance between localization accuracy and the real-time performance required for robotic platforms.
• An Adaptive, Multi-Criteria Keyframe Selection Strategy: To handle a robot’s varied motion patterns, we introduce a sophisticated keyframe selection strategy that holistically evaluates frame quality based on the robot’s motion history. It goes beyond simple parallax to incorporate map point visibility and matching quality, ensuring that selected keyframes are information-rich and geometrically stable. This prevents map degradation and improves tracking robustness, whether the robot is moving quickly, slowly, or turning.
• A Geometry-Aware Local Bundle Adjustment (BA) Scheme: We enhance the backend optimization to better leverage the structure of typical robotic operating environments. The method classifies map points as ‘planar’ or ‘edge’ categories and assigns higher weights to the more geometrically informative edge points. This geometry-aware approach improves the robot’s pose accuracy and stability, especially in structured indoor settings, by prioritizing more reliable environmental constraints.
• An Integrated and Robust RGB-D SLAM System for Robotic Applications: We integrate these modules into a coherent system, DKB-SLAM, designed for practical robotic use. The synergy between dynamic object handling, intelligent keyframe selection, and refined optimization results in superior accuracy and robustness. We validate this performance extensively on the public TUM RGB-D benchmark and, critically, on a mobile robot platform operating in challenging real-world, high-dynamic scenarios.

The remainder of the paper is structured as follows: Section 2 reviews related research, Section 3 presents an overview of the proposed method, Section 4 experimentally validates the method and compares it with state-of-the-art approaches, and Section 5 concludes the paper and outlines future research directions.

2. Related Works

2.1. Visual SLAM in Dynamic Environments

Traditional visual SLAM performs exceptionally well in static environments, but its reliance on the assumption of a static environment makes it vulnerable to dynamic elements, which can severely impact the system’s robustness and accuracy, limiting its practical application. To address the challenges posed by dynamic scenes, researchers have developed various strategies to improve the adaptability of visual SLAM systems. These approaches primarily include geometry-based dynamic point detection, dynamic object recognition combined with semantic analysis, and motion estimation of dynamic objects using clustering techniques.

(1)

Methods based on geometric information

Geometry-based methods primarily identify dynamic objects by analyzing the geometric features or motion consistency of rigid targets. These approaches allow the system to classify feature points that fail to adhere to rigid motion constraints as dynamic points and subsequently remove them. Yang et al. [10] introduced a dynamic point detection method that initially filters dynamic points using geometric constraints, then refines the filtering process through matrix calculations, and ultimately confirms the dynamic points with the polar constraint method. CoSLAM [11] detects dynamic points by examining the triangular consistency of map points. Kim et al. [12] proposed a visual odometry approach for dynamic scenes using background models. This method estimates a non-parametric background model from depth data, extracts the static parts of the scene, and employs an energy-based visual odometry technique to estimate camera motion. Hu et al. [23] applied a multi-view geometry approach to detect dynamic points, combined with an ant colony strategy, which selectively traverses dynamic point groups with a higher probability, thus improving detection efficiency.

(2)

Methods based on semantic analysis

Combining semantic analysis with geometric methods is another widely used approach to address dynamic scenes. DynaSLAM [14] effectively reduced the impact of dynamic elements on the SLAM system by integrating Mask R-CNN [24] for semantic segmentation with multi-view geometry. Other methods, such as [15,16,17,25], also incorporate semantic segmentation modules to identify and remove dynamic objects, thus enhancing the system’s performance in complex environments. Zhang et al. [26] employed the YOLO [27] object detection method to extract semantic information of dynamic objects in the scene, then eliminated dynamic points based on this information, improving the system’s accuracy.

(3)

Methods based on clustering

Clustering methods are crucial for motion estimation of dynamic objects. DRE-SLAM [28] combines the K-means clustering algorithm applied to depth images with multi-view geometric constraints to identify dynamic objects. Furthermore, ClusterSLAM [29] and ClusterVO [30] unify the clustering and estimation of both static and dynamic objects by analyzing 3D motion consistency among landmarks extracted from the same rigid body, thereby enhancing the performance of SLAM systems in dynamic environments. SAD-SLAM [31] improves the dynamic point removal process by classifying feature points and applying different processing techniques based on the type of feature points.

2.2. Keyframe Selection

Keyframe selection plays a central role in SLAM systems and has garnered significant attention in recent years. As a representative frame within the environment, a keyframe contains valuable pose and environmental information. By choosing keyframes with notable changes or distinctive features, the SLAM system ensures that map key points are evenly distributed and thoroughly covered. This approach reduces redundant data, enhances map accuracy and consistency, and prevents error accumulation due to repeated or similar frames. Dong et al.’s experiments [32,33] demonstrate that the proper selection of keyframes not only impacts positioning accuracy and map quality but is also directly linked to the system’s computational efficiency and real-time performance. Consequently, effective keyframe selection has become a key focus of current research.

(1)

Motion-based methods

Traditional keyframe selection methods are typically based on fixed time or spatial intervals. For instance, Refs. [3,7,34] all adopt strategies that select keyframes at regular time or location intervals. While these methods are simple to implement, they often result in keyframes that carry less information, lack flexibility, and offer lower quality. To enhance keyframe quality, VINS-Mono employs a selection criterion based on disparity and tracking quality. When the average disparity between the current and previous frames exceeds a threshold or when the number of tracked feature points falls below a certain limit, the current frame is selected as a keyframe. Lin et al. [4] select keyframes based on camera perspective changes. When the camera moves quickly, more keyframes are selected, and fewer keyframes are selected when the camera moves slowly. Experimental results show that this approach significantly reduces the number of required keyframes while maintaining accuracy. ORB-SLAM2 [1] utilizes a hybrid method for keyframe selection, setting the current frame as a keyframe when one of the following conditions is met: (1) more than 20 frames have passed since the last global relocalization, (2) local map construction is idle, or more than 20 frames have passed since the last keyframe insertion, (3) fewer than 50 map points are tracked in the current frame, or (4) the current frame tracks less than 90% of the map points in the reference keyframe. This strategy enables ORB-SLAM2 to maintain robust performance while ensuring high accuracy.

(2)

Appearance-based methods

Appearance-based keyframe selection methods typically evaluate images based on features such as grayscale, texture, and shape. Engel et al. [35] introduced an innovative keyframe selection approach that first selects a broad set of candidate keyframes based on criteria such as (1) significant changes in viewing angle, (2) substantial camera translation, and (3) notable variations in exposure time. The candidate set is then narrowed down, with the remaining keyframes selected as the final set. Additionally, Refs. [36,37] employed appearance-based pixel-level image or patch matching techniques, while [38] utilized a hybrid approach combining both feature and appearance strategies. These methods enhance the accuracy and robustness of keyframe selection by fully leveraging the appearance information within the images.

2.3. Backend Optimization

(1)

Filter-based methods

The filtering-based backend method has been widely utilized in early SLAM systems [39,40,41,42,43,44]. This method typically relies on recursive state estimation, assuming Markov properties, where the system’s current state depends solely on its previous state. This assumption simplifies the state estimation process, enabling the filtering method to achieve high computational efficiency in practical applications.

(2)

Optimization-based methods

Compared to the filtering method, the backend method based on nonlinear optimization performs global optimization by considering the relationships between global states, thereby enhancing the overall consistency and accuracy of the system. In recent years, optimization-based backends have been widely adopted in numerous SLAM systems [2,5,20,45]. One of the leading methods in the current field of visual SLAM, ORB-SLAM3, employs an efficient backend optimization strategy. ORB-SLAM3 utilizes factor graphs to represent the constraint relationships between keyframes and map points. To balance real-time performance with accuracy, ORB-SLAM3 introduces a hierarchical optimization strategy, which includes two stages—local BA and global BA. Local BA optimizes only the keyframes and associated map points within the current window, ensuring optimization efficiency and suitability for real-time applications. In contrast, global BA optimizes all keyframes and map points in the entire map, thereby enhancing global consistency and map accuracy. This hierarchical strategy allows ORB-SLAM3 to achieve high mapping accuracy while maintaining real-time performance.

2.4. Summary

While current visual SLAM methods have made significant progress in dynamic scene processing, keyframe selection, and backend optimization, they still exhibit several limitations, which can be summarized as follows:

• Dynamic point recognition methods based on geometry or clustering perform well in low-dynamic environments, but they may lead to misidentifications when dealing with complex dynamic objects and scenes. On the other hand, dynamic point recognition methods based on semantic analysis exhibit strong performance in both low- and high-dynamic scenes; however, they face challenges in real-time execution on devices with limited computational resources.
• Keyframe selection methods based on fixed time or spatial intervals lack flexibility and are susceptible to redundancy or the loss of critical information. Several methods, including those based on motion, deep learning, and appearance, have been proposed to address these issues. Among them, methods utilizing parallax and tracking quality can significantly improve selection accuracy, while deep learning-based methods excel at handling complex features, although they often suffer from poor real-time performance. While appearance-based methods can enhance accuracy in specific situations, they are highly sensitive to external factors such as lighting changes.
• While filtering-based methods offer high computational efficiency, their application in SLAM problems is limited by their nonlinear nature, which can lead to errors, and their recursive characteristics may cause local error accumulation. Optimization-based methods, on the other hand, provide more accurate state estimations. However, due to resource limitations, current optimization techniques often trade off some accuracy and landmarks to prioritize real-time performance. Additionally, effectively utilizing environmental information to further enhance optimization remains a critical challenge that requires urgent attention.

To address the challenges discussed above, we propose a comprehensive visual SLAM system: DKB-SLAM. Building upon ideas from [46,47], this system filters dynamic points by combining optical flow with feature point depth Gaussian analysis. It employs a keyframe selection strategy that considers parallax, visibility, and matching quality, and introduces a heterogeneous weighting technique for local BA, which discretizes the weighting of feature point geometric properties. These innovations effectively resolve the identified limitations, enabling DKB-SLAM to deliver exceptional robustness, accuracy, and real-time performance in complex dynamic scenes, demonstrating its superior capabilities.

3. System Overview

The DKB-SLAM system proposed in this paper is an enhancement of ORB-SLAM3, with the overall framework shown in Figure 1. The system operates with four main threads—object detection, tracking, local mapping, and loop closing. First, the system captures RGB-D frames through the camera and extracts ORB feature points. Next, feature points from the YOLOv5 detection bounding boxes are processed to eliminate dynamic points that do not meet the criteria. The remaining feature points are then used for tracking local maps and selecting keyframes. After the tracking thread processes the keyframe, the local mapping thread refines the map points and optimizes the map structure. To ensure map accuracy and consistency, the system eliminates accumulated errors via loop closure detection and global BA.

3.1. Dynamic Point Recognition and Elimination

The presence of dynamic objects in real environments often leads to trajectory drift in SLAM systems. While semantic analysis has been proven effective in mitigating the impact of dynamic objects in most experiments, it is challenging to maintain real-time performance. To address this, we propose a method that identifies dynamic feature points using optical flow and depth Gaussian analysis. This approach effectively eliminates the influence of dynamic objects while preserving real-time performance.

(1)

Optical flow

Optical flow is a technique for estimating object or feature point motion by calculating pixel displacement between consecutive frames. It can be used to identify dynamic points. The proposed strategy applies optical flow only to preprocess feature points within the YOLO detection bounding boxes. This localized approach significantly reduces computational load and enhances the algorithm’s real-time processing capability.

During SLAM system operation, the images captured by the camera change over time. Therefore, the image can be treated as a function of time, i.e., I(t). A pixel at time t, located at (x,y), has a grayscale value of I(x,y,t). The principle is illustrated in Figure 2.

Based on the theory of the optical flow method, the following core assumptions are made:

• Constant brightness: The brightness of a given pixel remains unchanged between two consecutive frames.
• Small motion: Pixels move a small distance between two consecutive frames.
• Spatial consistency: Pixels within a local region exhibit similar motion patterns.

When the above assumption 1 is satisfied, the following holds true:

$$I(x,y,t)=I(x+dx,y+dy,t+dt)$$

(1)

Perform a first-order Taylor expansion on the right side of the above equation:

$$\begin{array}{cc}\hfill I(x+dx,y+dy,t+dt)& \hfill \\ \hfill & \approx I(x,y,t)+{\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }x}}dx+{\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }y}}dy+{\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }t}}dt\hfill \end{array}$$

(2)

Based on the assumption of grayscale invariance, the grayscale at the next moment is equal to that of the previous moment; thus, the following equation holds:

$${\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }x}}{\displaystyle \frac{dx}{dt}}+{\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }y}}{\displaystyle \frac{dy}{dt}}=-{\displaystyle \frac{\mathsf{\partial }I}{\mathsf{\partial }t}}$$

(3)

In the above formula, $dx/dt$ and $dy/dt$ represent the velocities of the pixel on the x and y axes, respectively, and $\mathsf{\partial }I/\mathsf{\partial }x$ and $\mathsf{\partial }I/\mathsf{\partial }y$ represent the gradient of the point in the x and y directions, respectively. $\mathsf{\partial }I/\mathsf{\partial }x$ and $\mathsf{\partial }I/\mathsf{\partial }y$ are denoted as $I_x$ and $I_y$, respectively, and $dx/dt$ and $dy/dt$ are denoted as u and v, respectively. Therefore, Equation (3) can be written in matrix form:

$$\left[\begin{array}{cc}{I}_x& I_y\end{array}\right]\left[\begin{array}{c}u\\ v\end{array}\right]=-I_t$$

(4)

At least two equations are required to solve for these two unknowns, u and v. Therefore, according to the above assumptions 2 and 3, we assume that the pixels within a $k\times k$ window surrounding a pixel have the same motion state as the pixel. From this, we can construct $k^2$ equations, as follows:

$${\left[\begin{array}{cc}{I}_x& I_y\end{array}\right]}_k\left[\begin{array}{c}u\\ v\end{array}\right]=-I_{tk}\begin{array}{cc},& \end{array}k=1,2,\dots n^2$$

(5)

$$\left.\mathbf{A}=\left[\begin{array}{c}{[I_x,I_y]}_1\\ ⋮\\ {[I_x,I_y]}_k\end{array}\right.\right],\mathbf{b}=\left[\begin{array}{c}{I}_{t1}\\ ⋮\\ I_{tk}\end{array}\right]$$

(6)

$$A\left[\begin{array}{c}u\\ v\end{array}\right]=-b$$

(7)

By solving the least squares problem, we obtain the following:

$${\left.\left[\begin{array}{c}u\\ v\end{array}\right.\right]}^{*}=-{\left(A^{T}A\right)}^{-1}{A}^{T}b$$

(8)

Based on the velocity of the pixel along the x-axis and y-axis, we can infer the pixel position at different times and compute the displacement of the same feature point between consecutive frames using Equation (9):

$$\mathrm{distance}=\sqrt{{(x_{\mathrm{cur}}-x_{\mathrm{pre}})}^2+{(y_{\mathrm{cur}}-y_{\mathrm{pre}})}^2}$$

(9)

If the distance exceeds the displacement threshold $d_{th}=1$, the feature point is classified as a dynamic feature point; otherwise, it is further evaluated using deep Gaussian distribution analysis. The selection of $d_{th}=1$ is a common empirical value in motion analysis applications utilizing optical flow [48]. This threshold is established on the principle that, for typical camera frame rates, the displacement of static background points between consecutive frames, after initial ego-motion compensation, results in sub-pixel shifts. A displacement exceeding one full pixel is therefore a strong indicator of independent object motion. This value provides a balance between sensitivity to detect slow-moving objects and robustness against image noise or minor feature tracking jitter. It serves as an efficient first-pass filter before the more computationally intensive depth analysis.

(2)

Gaussian-based Depth Distribution Analysis

In Simultaneous Localization and Mapping (SLAM), the depth values of feature points in static scenes typically follow a Gaussian distribution centered around their mean [46]. Leveraging this property, we propose a method to statistically analyze the depth distribution of feature points using a Gaussian distribution to differentiate static and dynamic points. By modeling depth values within a Gaussian framework, points with significant deviations from the expected distribution are identified as dynamic. To enhance the real-time performance of the DKB-SLAM system, we restrict this analysis to feature points within YOLOv5 bounding boxes, which are pre-identified as potential dynamic regions, thereby reducing computational overhead while maintaining accuracy in dynamic point filtering.

Firstly, the mean depth value of the feature points within the bounding box is calculated as $\mu$ using Equation (10):

$$\mu ={\displaystyle \frac{1}{N}}\sum _{i=1}^N{d}_i$$

(10)

where $d_i$ represents the depth value of the i-th feature point, and N denotes the total number of feature points. Next, the standard deviation $\sigma$ is calculated to measure the dispersion of the depth values of the feature points, reflecting the width of the data distribution in terms of depth, as shown in Equation (11):

$$\sigma =\sqrt{{\displaystyle \frac{1}{N}}\sum _{i=1}^N{(d_i-\mu )}^2}$$

(11)

Calculate the standard deviation of the depth values for feature points that are greater than ${\sigma }_h$, and the standard deviation for those smaller than ${\sigma }_l$. Then, compute the ratio of these two standard deviations $s={\displaystyle \frac{{\sigma }_{\mathrm{h}}}{{\sigma }_l}}$, which can be used to dynamically adjust the threshold to better adapt to the depth distribution characteristics in different scenarios. It is assumed that the depth distribution of static feature points follows a Gaussian distribution, meaning that the depth values of most static feature points should be close to $\mu$, and points with larger deviations may represent dynamic points or noise. For each feature point, the normalized deviation of its depth value from the mean is calculated as in Equation (12):

$$t{h}_i={\displaystyle \frac{d_i-\mu }{\sigma }}$$

(12)

$t{h}_i$ indicates the degree of deviation of $d_i$ with respect to $\mu$, normalized by the standard deviation $\sigma$. A dynamic threshold $\delta$ is set to determine whether the key point is dynamic. If $t{h}_i^2>\delta$, then $d_i$ is considered a dynamic feature point. $\delta$ is defined as follows, and its selection is grounded in statistical principles derived from the chi-squared (${\chi }^2$) distribution. Since the normalized deviation $t{h}_i$ of static points is assumed to follow a standard normal distribution, its square, $t{h}_i^2$, follows a ${\chi }^2$ distribution with one degree of freedom. Thus, the threshold $\delta$ acts as a critical value for a statistical test. The value $s={\sigma }_h/{\sigma }_l$ serves as a heuristic to assess the modality of the depth distribution. When $s<8$, the distribution is likely unimodal, and a threshold of $\delta =2.8$ is used, which approximates a 90% confidence interval. This provides a robust filter for clear outliers. When $s\ge 8$, the distribution is likely multi-modal (e.g., a dynamic object in front of a static background), indicating that the single Gaussian model is a poor fit. In this case, a much stricter threshold of $\delta =9.0$ is applied, corresponding to a confidence interval of over 99.7%. This conservative choice ensures that only extreme outliers are classified as dynamic, preventing the erroneous removal of static background points. This adaptive strategy, originally proposed in [46], provides a statistically justified method for dynamic point filtering.

$$\delta =\left\{\begin{array}{cc}2.8\hfill & \mathrm{s}<8\hfill \\ 9.0\hfill & \mathrm{s}\ge 8\hfill \end{array}\right.$$

(13)

In summary, we propose a dynamic feature point recognition method that combines the optical flow method and depth Gaussian analysis, which effectively addresses the drift problem in SLAM systems operating in dynamic environments. The optical flow method quickly identifies moving feature points by calculating the motion trajectories of pixels in consecutive frames, while depth Gaussian analysis accurately classifies the depths of the feature points based on the statistical properties of static point depths, thereby improving the detection accuracy of dynamic points. The combination of these two methods not only meets the real-time requirements of SLAM systems but also effectively suppresses the interference of dynamic objects on localization and map building, providing a robust and efficient solution for SLAM in dynamic scenes. Compared to traditional geometry-based methods like the short-term motion consistency check, which primarily relies on epipolar constraints, our hybrid approach offers distinct advantages. The motion consistency check identifies dynamic points as outliers to the fundamental matrix estimated between two views. However, this method can fail when dynamic objects move parallel to the camera’s epipolar lines or when motion is too erratic for reliable geometric model fitting. Furthermore, in scenes dominated by dynamic elements, the estimation process itself can be compromised. Our method, by contrast, leverages two complementary cues: pixel-level motion vectors from optical flow and a statistical model of depth distribution from Gaussian analysis. This dual-modality approach makes it more robust to varied motion patterns and less susceptible to the geometric degeneracies that can affect consistency checks. For instance, an object moving directly towards the camera might satisfy epipolar constraints but would be immediately flagged by our depth distribution analysis, showcasing the enhanced robustness of our method in complex, real-world scenarios.

3.2. Keyframe Selection Based on Parallax, Visibility, and Match Quality

In visual SLAM systems, keyframe selection plays a crucial role in the overall performance of the system. Proper keyframe selection not only reduces the storage and computational overhead caused by redundant frames but also ensures geometric consistency between keyframes, thereby improving localization accuracy and map construction quality. However, traditional keyframe selection methods often rely on simple threshold-based criteria, which are challenging to adapt to complex and dynamic motion scenarios. This is especially true in fast-moving or slow-moving scenes, where the system tends to select too many or too few keyframes, thus compromising robustness and efficiency. To address this issue, we propose a novel keyframe selection method, as illustrated in Figure 3. This method integrates several factors, including the spatial distribution of map points, parallax variations, angular differences, and the quality of image grid matches, ensuring that the system maintains high-accuracy tracking performance across various environments.

(1)

Parallax-based current frame preprocessing

When evaluating the motion change between the current frame and the previous keyframe to select an appropriate keyframe, the pose estimate of the current frame must be updated, and the rotational and translational parallax between the two frames must be calculated. To quantify the rotational change between the two frames, the rotation matrices $R_{\mathrm{current}}$ and $R_{\mathrm{last}}$ of the current frame and the previous keyframe are extracted, and the rotational difference matrix $\Delta R$ between the two frames is computed using Equation (14):

$$\Delta R=R_{\mathrm{last}}^{\top }{R}_{\mathrm{current}}$$

(14)

In the above equation, $R_{last}^T$ represents the transpose of the rotation matrix of the previous keyframe. The rotational angle difference $\Delta \theta$ is then computed from the trace of the rotational difference matrix, as shown in Equation (15):

$$\Delta \theta =arccos\left({\displaystyle \frac{\mathrm{trace}(\Delta R)-1}{2}}\right)\times {\displaystyle \frac{180}{\pi }}$$

(15)

$\mathrm{trace}\left(\Delta R\right)$ in the above equation is the trace of $\Delta R$. Extract the current frame and the translation vector ${\mathbf{t}}_{\mathrm{current}}$ and the translation vector ${\mathbf{t}}_{\mathrm{last}}$ of the previous keyframe, and compute the translation difference $\Delta t$ between them using Equation (16):

$$\Delta t=∥{\mathbf{t}}_{\mathrm{current}}-{\mathbf{t}}_{\mathrm{last}}∥$$

(16)

In order to avoid misjudgments caused by parallax variation in a single frame, we introduce a sliding window mechanism to smooth out the parallax variation. A sliding window of size $N=10$ is defined to store the rotation angle variance $\Delta \theta$ and translation variance $\Delta t$ from the last N frames. This value is inspired by the motion-based keyframe selection principles in robust systems like VINS-Mono [4], which require a balance between smoothing noisy motion estimates and reacting promptly to actual changes in trajectory. A 10-frame window is large enough to filter high-frequency jitter but small enough to adapt quickly to significant shifts in motion, such as the transition from straight-line movement to a sharp turn, thereby ensuring both stability and responsiveness. The historical average rotation angle variance $\overline{\Delta \theta }$ and historical average translation variance $\overline{\Delta t}$ are then computed from the parallax values within the sliding window, as detailed in Equations (17) and (18):

$$\overline{\Delta \theta }={\displaystyle \frac{1}{N}}\sum _{k=1}^N\Delta {\theta }_k$$

(17)

$$\overline{\Delta t}={\displaystyle \frac{1}{N}}\sum _{k=1}^N\Delta t_k$$

(18)

The sliding window mechanism effectively smooths out abrupt parallax changes and prevents misjudgments caused by abnormal parallax in a single frame. Additionally, we adaptively adjust the thresholds based on the historical average parallax values to ensure the algorithm’s adaptability and robustness under different motion states. First, the weights $w_{\theta }$ and $w_t$ for rotation and translation are calculated based on the historical average parallax values using Equations (19) and (20):

$$w_{\theta }={\displaystyle \frac{\overline{\Delta \theta }}{\overline{\Delta \theta }+\overline{\Delta t}+ϵ}}$$

(19)

$$w_t={\displaystyle \frac{\overline{\Delta t}}{\overline{\Delta \theta }+\overline{\Delta t}+ϵ}}$$

(20)

where $ϵ=1\times {10}^{-5}$ is introduced to prevent the denominator from being zero. These weights dynamically adjust the keyframe selection criteria based on the nature of the robot’s motion. For example, during a pure rotation (turning on the spot), $\overline{\Delta t}$ will be small, causing $w_{\theta }$ to approach 1 and $w_t$ to approach 0. This makes the system highly sensitive to rotational changes while being robust to minor translational jitter, appropriately triggering a new keyframe. Conversely, during straight-line motion, $w_t$ will dominate, making the system sensitive to the translational distance covered. This adaptive weighting scheme ensures that keyframes are inserted based on the most significant component of the robot’s motion, improving the robustness and efficiency of the selection process. Second, a logarithmic function is used to nonlinearly scale the rotational and translational components. The application of the logarithmic function helps to smooth out the effects of rotation and translation on the thresholds, preventing extreme values from dominating the results and improving numerical stability. The nonlinearly processed $M_{\theta }$ and $M_t$ are defined as follows in Equations (21) and (22):

$$M_{\theta }=\log (1+w_{\theta }·\overline{\Delta \theta })$$

(21)

$$M_t=\log (1+w_t·\overline{\Delta t})$$

(22)

After completing the nonlinear scaling of the parallax components, the total mapping value M and the normalization factor F are calculated using Equations (23) and (24):

$$M=M_{\theta }+M_t$$

(23)

$$F={\displaystyle \frac{M}{\log (1+w_{\theta }·{\Theta }_{max})+\log (1+w_t·t_{max})}}$$

(24)

where ${\Theta }_{max}$ and $t_{max}$ denote the assumed maximum rotation and translation values, respectively. By introducing these maximum values, the maximum rotation angle and translation between keyframes are limited. In most vision systems, the field of view is usually constrained, with wide-angle lenses typically not exceeding 90°. A rotation change of more than 45° between two frames results in insufficient overlap between the front and back frames, which affects the effectiveness of the keyframes. We, therefore, set ${\Theta }_{max}={45}^{°}$ and $t_{max}=10$, following validation in VINS-Mono [4]. F ensures that the total mapping values are scaled uniformly, facilitating the subsequent threshold calculation. The ratio of the total mapping value and the normalization factor is used to calculate the final parallax adaptive threshold T via Equation (25):

$$T=T_{max}-F·(T_{max}-T_{min})$$

(25)

where $T_{min}=10$ and $T_{max}=30$ represent the minimum and maximum values of the adaptive thresholds, respectively, to avoid too few keyframes in fast-motion scenes or excessive keyframe generation in slow-motion scenes. When the rotation or translation is large, F increases, leading to a decrease in T, which makes keyframe selection easier. Conversely, in low-motion situations, T increases, reducing keyframe generation. If $\Delta \theta +\Delta t<T$, the current frame is not used as a keyframe.

This adaptive threshold mechanism allows the algorithm to dynamically adjust the keyframe selection criteria according to the current motion state, enhancing its adaptability and robustness in different scenarios.

(2)

Keyframe judgment based on visibility and match quality

In order to ensure the rationality of keyframe selection, DKB-SLAM must evaluate the geometric consistency and matching quality of the current frame after parallax filtering.

First, iterate through all the map points and calculate the Euclidean distance between each pair of map points. Let there be two map points, $P_i=(x_i,y_i,z_i)$ and $P_j=(x_j,y_j,z_j)$, whose Euclidean distance is denoted as in Equation (26):

$$d(P_i,P_j)=\sqrt{{(x_i-x_j)}^2+{(y_i-y_j)}^2+{(z_i-z_j)}^2}$$

(26)

For each map point ${\mathbf{P}}_i$, find the five nearest neighbors and compute the vector ${\mathbf{V}}_k$ of these neighbors relative to the current map point (where k = 1, 2, …, 5), as shown in Equation (27):

$${\mathbf{V}}_k={\mathbf{P}}_k-{\mathbf{P}}_i$$

(27)

The cross products of all pairwise combinations of the five vectors are computed and summed to obtain the cumulative vector ${\mathbf{S}}_i$ (Equation (28)). Subsequently, its magnitude $∥{\mathbf{S}}_i∥$ (Equation (29)) and the unit normal vector ${\mathbf{N}}_i$ (Equation (30)) are calculated as follows:

$${\mathbf{S}}_i=\sum _{k=1}^4\sum _{t=k+1}^5({\mathbf{V}}_k\times {\mathbf{V}}_t)$$

(28)

$$\Vert {\mathbf{S}}_i\Vert =\sqrt{S_{i_x}^2+S_{i_y}^2+S_{i_z}^2}$$

(29)

$${\mathbf{N}}_i={\displaystyle \frac{{\mathbf{S}}_i}{\Vert {\mathbf{S}}_i\Vert }}$$

(30)

The unit normal vector ${\mathbf{N}}_i$ reflects the orientation of the local geometric structure around the map point ${\mathbf{P}}_i$. The visibility of a map point can be further assessed by analyzing the relationship between the unit normal vector and the direction of the camera’s line of sight. Specifically, the angle between the normal vector ${\mathbf{N}}_i$ and the camera’s line-of-sight direction ${\mathbf{C}}_i$ must be calculated for each map point. The principle is shown in Figure 4.

The angle ${\theta }_i$ is calculated as shown in Equation (31):

$${\theta }_i=arccos\left({\displaystyle \frac{{\mathbf{N}}_i·{\mathbf{C}}_i}{∥{\mathbf{N}}_i∥∥{\mathbf{C}}_i∥}}\right)\times {\displaystyle \frac{180}{\pi }}$$

(31)

where ${\mathbf{N}}_i·{\mathbf{C}}_i$ denotes the dot product of vectors and $∥{\mathbf{C}}_i∥$, $∥{\mathbf{N}}_i∥$ are the norms of the vectors.

Assign map points to different visibility levels based on the angle of clip A in order to evaluate their visibility status in the current frame. Set every 10 degrees as a standard, as defined in Equation (32):

$$V_i=\left\{\begin{array}{c}1,0<{\theta }_i\le 10°\hfill \\ 2,10°<{\theta }_i\le 20°\hfill \\ 3,20°<{\theta }_i\le 30°\hfill \\ 4,{\theta }_i>30°\hfill \end{array}\right.$$

(32)

where $V_i$ denotes the visibility level of the map point ${\mathbf{P}}_i$. By comparing the visibility levels of the matching points in the current frame and the previous keyframe, the number of matching points with inconsistent visibility levels, denoted as $n_{\mathrm{diff}}$, is counted. At the same time, we adopt an adaptive threshold $thres$ to dynamically adjust the judgment criteria for matching points with inconsistent visibility levels. $thres$ is defined as follows in Equation (33):

$$\begin{array}{c}thres=(\theta -\beta -\alpha )·S+S\end{array}$$

(33)

S in the above equation is the similarity metric used to evaluate the similarity between the current frame and the previous keyframe, which is defined as follows in Equation (34):

$$S={\displaystyle \frac{n_{\mathrm{diff}}·n_{\mathrm{matches}}}{r}}+{\displaystyle \frac{n_{\mathrm{diff}}·m}{C}}$$

(34)

In the calculation of S, $n_{\mathrm{matches}}$ denotes the number of successful matches, r is the number of matched points in the reference frame and the previous keyframe, and m and C represent the total number of points in the current frame and the reference frame, respectively. The similarity metric S combines the visibility consistency between the current frame and the previous keyframe, along with the ratio of the number of matched points. The first term ${\displaystyle \frac{n_{\mathrm{diff}}·n_{\mathrm{matches}}}{r}}$ measures the impact of visibility-inconsistent matching points relative to the number of historical matches, while the second term ${\displaystyle \frac{n_{\mathrm{diff}}·m}{C}}$ evaluates the impact of visibility-inconsistent matching points relative to the number of historical map points. In addition, $\theta$ in the $thres$ calculus is used to measure the reduction in the number of current matches relative to the number of historical matches, which is defined as follows in Equation (35):

$$\theta =1-{\displaystyle \frac{n_{\mathrm{matches}}}{r}}$$

(35)

On the other hand, $\alpha$ represents the proportionally adjusted value of a match with an inconsistent visibility class, which is defined as follows in Equation (36):

$$\alpha ={\displaystyle \frac{n_{\mathrm{diff}}}{n_{\mathrm{matches}}}}-0.5$$

(36)

The scale was adjusted to be centered on 0 by subtracting 0.5, with positive values indicating a higher proportion of visibility-inconsistent match points, and negative values indicating the opposite. Finally, $\beta$ denotes the change in the proportion of visibility-inconsistent match points between the current frame and the reference frame, further reflecting the change in matching quality. It is defined as follows in Equation (37):

$$\beta ={\displaystyle \frac{n_{\mathrm{diff}}}{n_{\mathrm{matches}}}}-{\displaystyle \frac{n_{\mathrm{diffr}}}{r}}$$

(37)

where $n_{\mathrm{diffr}}$ denotes the number of matching points with inconsistent visibility levels in the reference frame and the previous keyframe. If $\beta$ is positive, it means that the proportion of match points with visibility-inconsistent in the current frame increases; otherwise, it has decreased.

The adaptive thresholding criterion described above only models the number of changes in the current frame compared to the previous keyframe. Therefore, as these changes increase, the probability of a positive response to this criterion for selecting keyframes also increases. The number of changes must be controlled because if there are too many changes, this frame will not align with the previous keyframe. Thus, in order to select keyframes with a uniform distribution of valid points for creating a dense and accurate point cloud, another parallel criterion is employed.

The current frame image plane is divided into a 3 × 3 grid to construct the grid matrix $\mathbf{G}\in {\mathbb{R}}^{3\times 3}$. For each pair of matching points, the value in $\mathbf{G}$ is incremented by 1 based on the grid position $(i,j)$ where its pixel coordinate $(u,v)$ is located. The equilibrium of center of gravity ($ECOG$) is then computed by analyzing the distribution of matching points in $\mathbf{G}$, as shown in Equation (38):

$$ECOG={\displaystyle \frac{D_{\max 2}·G_{\max 2}}{2·\sqrt{2}·G_{\max }}}$$

(38)

where $G_{\max }$ is the largest value in $\mathbf{G}$, denoting the maximum number of matching points in the grid where it is located, and $G_{\max 2}$ is the second largest value in $\mathbf{G}$. $D_{\max 2}$ denotes the Euclidean distance between the centroids of these two grids. $ECOG$ reflects the spatial distribution of the matching points. A high value of $ECOG$ indicates that the matching points are mainly concentrated in grid regions that are far apart; conversely, a low value of $ECOG$ indicates that the matching points are concentrated in grid regions that are closer together, meaning that the distribution of matching points is more centralized. The threshold $E_{th}$ of $ECOG$ can be obtained by computing the center of gravity of the matrix, defined as follows in Equations (39)–(41):

$$\mathrm{centroidRow}={\displaystyle \frac{{\displaystyle \sum _{j=0}^2}{G}_{2,j}-{\displaystyle \sum _{j=0}^2}{G}_{0,j}}{{\displaystyle \sum _{i=0}^2}{\displaystyle \sum _{j=0}^2}{G}_{i,j}}}$$

(39)

$$\mathrm{centroidCol}={\displaystyle \frac{{\displaystyle \sum _{i=0}^2}{G}_{i,2}-{\displaystyle \sum _{i=0}^2}{G}_{i,0}}{{\displaystyle \sum _{i=0}^2}{\displaystyle \sum _{j=0}^2}{G}_{i,j}}}$$

(40)

$$E_{th}=\sqrt{{\left(\mathrm{centroidRow}\right)}^2+{\left(\mathrm{centroidCol}\right)}^2}$$

(41)

In the above equation, ${\displaystyle \sum _{j=0}^2}{G}_{2,j}$ represents the total number of matching points in all grids in the third row, ${\displaystyle \sum _{j=0}^2}{G}_{0,j}$ represents the total number of matching points in all grids in the first row, ${\displaystyle \sum _{i=0}^2}{G}_{i,2}$ represents the total number of matching points in all grids in the third column, ${\displaystyle \sum _{i=0}^2}{G}_{i,0}$ represents the total number of matching points in all grids in the first column, and ${\displaystyle \sum _{i=0}^2}{\displaystyle \sum _{j=0}^2}{G}_{i,j}$ represents the total number of matching points in all grids. $E_{th}$ denotes the overall offset of the center of gravity of the matching points with respect to the center of the image.

By introducing a keyframe selection method based on parallax, geometric consistency, and matching quality assessment, we effectively enhance the robustness and accuracy of the visual SLAM system in complex scenes. This method not only adaptively adjusts the keyframe selection criteria to reduce the computational and storage overhead of redundant frames, but also further ensures the system’s efficiency and accuracy by optimizing the spatial distribution of map points and improving matching quality.

3.3. Local Bundle Adjustment Optimization with Heterogeneous Weighting of Map Point Geometry

In SLAM systems, the geometric distribution characteristics of map points directly impact the accuracy and efficiency of system optimization. Based on geometric characteristics, map points can be classified into planar points and edge points. We explore classification and differential weighting methods for different types of map points, and elaborate on the classification of planar points and edge points, as well as their applications in local BA.

During the optimization process, geometric consistency between observations and map points is a key factor in ensuring the reliability of the optimization. Therefore, observations and map points that do not satisfy geometric consistency must be filtered out before local bundle adjustment.

The pose of the keyframes is represented by the SE(3) transformation ${\mathbf{T}}_{cw}^i$. First, the map point ${\mathbf{P}}_j$ is transformed into the camera coordinate system (Equation (42)), and the projected position of ${\mathbf{P}}_j$ on the image plane is computed as ${\mathbf{p}}_{\mathrm{proj}}$ (Equation (43)):

$${\mathbf{P}}_c={\mathbf{T}}_{cw}^i·{\mathbf{P}}_j$$

(42)

$${\mathbf{p}}_{\mathrm{proj}}=\pi \left({\mathbf{P}}_c\right)$$

(43)

$\pi (·)$ in the above equation denotes the projection function. Next, the reprojection error $e_{\mathrm{reproj}}$ is computed as the Euclidean distance between the observed feature point ${\mathbf{p}}_{\mathrm{obs}}$ and the projected location ${\mathbf{p}}_{\mathrm{proj}}$, as shown in Equation (44):

$$e_{\mathrm{reproj}}=\Vert {\mathbf{p}}_{\mathrm{obs}}-{\mathbf{p}}_{\mathrm{proj}}\Vert$$

(44)

The reprojection error primarily arises from observation noise, which is assumed to follow a Gaussian distribution. Therefore, the square of the reprojection error, ${e_{\mathrm{reproj}}}^2$, follows a chi-square distribution with 2 degrees of freedom. According to statistical theory, with a 95% confidence level (as applied in ORB-SLAM3), the critical value of the chi-square distribution is approximately 5.991. Therefore, the threshold for the reprojection error is set to ${\theta }_{\mathrm{reproj}}=\sqrt{5.991}=2.45$. If the reprojection error $e_{\mathrm{reproj}}$ of an observation exceeds a preset threshold ${\theta }_{\mathrm{reproj}}$, the geometric consistency between the observation and the map point is considered unsatisfactory, and the observation is excluded to prevent its negative impact on the optimization results.

To further enhance the effectiveness of the optimization, we classify map points based on their observed spatial distribution across multiple keyframes. Specifically, map points are categorized as planar points and edge points, which exhibit different geometric properties and optimization values. Edge points are typically distributed in multiple directions, effectively capturing detailed changes in the environment and providing additional information to support the optimization of camera pose and map point positions. In contrast, planar points are primarily concentrated within the same plane and contain relatively limited geometric information. This can lead to an over-reliance on planar constraints during the optimization process, thereby restricting the accuracy and robustness of the optimization. Therefore, appropriately increasing the weight of edge points in the optimization allows the optimizer to better leverage their rich geometric information, enhancing the system’s resilience to noise and outliers, accelerating optimization convergence, and improving map accuracy and consistency.

For each map point, collect the positions of all its observed keyframes $\left\{{\mathbf{C}}_i\right\}$ in the world coordinate system. Then, compute the mean position $\mu$ (Equation (45)) and the covariance matrix $\Sigma$ (Equation (46)) of these positions:

$$\mu ={\displaystyle \frac{1}{N}}\sum _{i=1}^N{\mathbf{C}}_i$$

(45)

$$\Sigma ={\displaystyle \frac{1}{N}}\sum _{i=1}^N({\mathbf{C}}_i-\mu ){({\mathbf{C}}_i-\mu )}^{\top }$$

(46)

where N is the number of observed keyframes for the map points. Eigenvalue decomposition is used to determine the eigenvalues of $\Sigma$, denoted as ${\lambda }_1\ge {\lambda }_2\ge {\lambda }_3$. The minimum eigenvalue, ${\lambda }_3$, reflects the geometric distribution dimension of the map points in the least significant direction. The values of ${\lambda }_3$ for all map points are statistically analyzed to compute their mean $\overline{{\lambda }_3}$ and standard deviation ${\sigma }_{{\lambda }_3}$. Adaptive thresholds are then set as defined in Equation (47):

$${\theta }_{\mathrm{planar}}=\overline{{\lambda }_3}+{\sigma }_{{\lambda }_3}$$

(47)

Map points are classified as planar if ${\lambda }_3<{\theta }_{\mathrm{planar}}$; otherwise, they are classified as edge points. After classification, differential weighting is applied to enhance optimization performance. In Local BA, map points are assigned different weights w depending on whether they are planar or edge points, with edge points typically receiving a larger w. By introducing w to weight the error, the optimizer places greater emphasis on edge points, where geometric information is more significant, thereby improving the overall effectiveness of the optimization. The optimization cost function is given by Equation (48):

$$E=\sum _{i=1}^{N_p}w\left(p_i\right)·{\Vert z_i-h\left(p_i\right)\Vert }^2$$

(48)

where $N_p$ is the total number of map points, $p_i$ represents the ith map point, $z_i$ is the observed value of $p_i$ (i.e., its pixel coordinates), and $h\left(p_i\right)$ denotes the coordinates of $p_i$ projected onto the image plane. $w\left(p_i\right)$ is the weight of the ith map point, which is used to adjust its contribution to the optimization. If the map point is an edge point, $w\left(p_i\right)=1.5$; otherwise, $w\left(p_i\right)=1$. The selection of 1.5 as the weight for edge points is based on the sensitivity analysis presented in

Table 1. Sensitivity analysis of edge point weights on translational RMSE for DKB-SLAM. The analysis across multiple dynamic TUM RGB-D sequences shows that, while the optimal weight varies slightly, a weight of 1.5 consistently yields near-optimal and robustly low errors, making it a suitable general choice. The bold values indicate the lowest RMSE for each sequence.

Sequence	Edge Point Weight (w)
	1.1	1.2	1.3	1.4	1.5	1.6	1.7	1.8	1.9
walk-rpy	0.0360	0.0342	0.0315	0.0301	0.0293	0.0302	0.0321	0.0348	0.0365
walk-static	0.0072	0.0069	0.0065	0.0058	0.0059	0.0063	0.0066	0.0070	0.0073
walk-xyz	0.0138	0.0135	0.0128	0.0123	0.0120	0.0124	0.0129	0.0136	0.0140
sitting-static	0.0065	0.0062	0.0058	0.0056	0.0053	0.0057	0.0060	0.0063	0.0066

. While the optimal value varies slightly per sequence, the analysis demonstrates that a weight of 1.5 provides a robustly strong performance across multiple dynamic scenarios, making it an effective general-purpose choice.

By introducing discretized weighting, the optimizer can more effectively utilize information from edge points, thereby enhancing the system’s robustness to noise and outliers, accelerating optimization convergence, and improving the accuracy of the final localization.

4. Experimental Validation

In this section, we present a comprehensive experimental evaluation of the DKB-SLAM system. First, DKB-SLAM is validated using the TUM RGB-D dataset to assess its performance on standard benchmarks. To evaluate the effectiveness of each module, we perform ablation studies, analyzing the contribution of each component to the overall system performance. Next, we test DKB-SLAM in real-world scenarios to assess its adaptability to real environments. Finally, we measure the average time consumption of each module, demonstrating the real-time efficiency of DKB-SLAM. All experiments were conducted on computers equipped with an AMD Ryzen 9 7945HX CPU, an NVIDIA GeForce RTX 4060 GPU, and 48 GB of RAM.

4.1. Evaluation on the TUM RGB-D Dataset

The TUM dataset is a standardized dataset developed by the Technical University of Munich and is widely used for evaluating and testing visual SLAM algorithms. Among them, the TUM RGB-D dataset covers a diverse range of environments, making it highly valuable for benchmarking. To assess the accuracy and robustness of DKB-SLAM in both static and dynamic scenes, we use three types of TUM RGB-D datasets—static, low-dynamic, and high-dynamic. Each dataset is used to evaluate the system’s performance, and the experimental results are compared and analyzed against other state-of-the-art SLAM systems. Additionally, the impact of each module on DKB-SLAM’s performance is verified through ablation studies, further clarifying the role of its key components. The comparison algorithm, MSSD-SLAM, is run in RGB-D+IMU mode, while the other algorithms are run in RGB-D mode.

To quantitatively assess the global consistency of SLAM system trajectories, we utilize the absolute trajectory error (APE) to evaluate both translational and rotational errors as indicators of the global consistency of DKB-SLAM. The root-mean-square error (RMSE) and the mean error of the translational and rotational APEs are computed using the evo tool, where smaller values indicate better system performance.

Table 2. RMSE and mean translational APE for the TUM RGB-D static dataset.

Sequence	ORB-SLAM3		DKB-SLAM-BA		DKB-SLAM-KF		DKB-SLAM-BA-KF
	RMSE (m)	Mean (m)	RMSE (m)	Mean (m)	RMSE (m)	Mean (m)	RMSE (m)	Mean (m)
fr1/360	0.1315	0.1185	0.0947	0.0880	0.1172	0.1046	0.0865	0.0772
fr1/room	0.0823	0.0728	0.0664	0.0580	0.0568	0.0492	0.0522	0.0462
fr2/large_no_loop	0.2928	0.2638	0.1695	0.1588	0.2238	0.2047	0.1064	0.0940
fr2/large_with_loop	0.1841	0.1724	0.0884	0.0796	0.0929	0.0834	0.0833	0.0738
fr2/pioneer_360	0.0968	0.0831	0.0872	0.0666	0.0867	0.0744	0.0832	0.0719

and

Table 3. RMSE and mean rotation APE under the TUM RGB-D static dataset.

Sequence	ORB-SLAM3		DKB-SLAM-BA		DKB-SLAM-KF		DKB-SLAM-BA-KF
	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)
fr1/360	0.2494	0.2401	0.2051	0.1922	0.2921	0.2858	0.1940	0.1893
fr1/room	0.0997	0.0898	0.0839	0.0766	0.0681	0.0638	0.0686	0.0588
fr2/large_no_loop	0.2533	0.2399	0.2443	0.2424	0.2037	0.1905	0.1276	0.1236
fr2/large_with_loop	0.1346	0.1310	0.0852	0.0839	0.0851	0.0836	0.0711	0.0690
fr2/pioneer_360	0.1079	0.0961	0.0868	0.0799	0.0878	0.0832	0.0887	0.0846

list the test results of ORB-SLAM3 and the three improved algorithms (DKB-SLAM-BA, DKB-SLAM-KF, DKB-SLAM-BA-KF) across five static test sequences. DKB-SLAM-BA is a SLAM system that incorporates a heterogeneous weighting local BA optimization module based on ORB-SLAM3. DKB-SLAM-KF is a SLAM system that employs an improved keyframe selection strategy, while DKB-SLAM-BA-KF combines both the heterogeneous weighting local BA optimization and improved keyframe selection modules. Bold entries indicate the best-performing results in each dataset. RMSE stands for root mean square error, and ‘mean’ refers to the average error.

The data in the table shows that DKB-SLAM-BA-KF achieves the lowest error values in most datasets, demonstrating the superiority of its comprehensive optimization module. In scenarios with a large number of edge points, DKB-SLAM-BA tends to perform better than DKB-SLAM-KF. This is because edge points provide more reliable data to the back-end local BA optimization module, which significantly improves localization accuracy. For test scenes with a large number of planar points, such as fr1/room and fr2/pioneer_360, the keyframe selection strategy of DKB-SLAM-KF proves more advantageous, allowing it to outperform DKB-SLAM-BA in these datasets. However, overall, the errors of both DKB-SLAM-BA and DKB-SLAM-KF are lower than those of ORB-SLAM3, significantly improving localization accuracy.

Table 4. RMSE of the Translational APE under the TUM RGB-D dynamic dataset.

Sequence	ORB-SLAM3	MSSD-SLAM	DRG-SLAM	Crowd-SLAM	SG-SLAM	DS-SLAM	DKB-SLAM-DR	DKB-SLAM-KF-DR	DKB-SLAM-BA-DR	DKB-SLAM
	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)	RMSE (m)
walk-rpy	0.1533	0.0328	0.0424	–	0.0367	0.4462	0.0386	0.0322	0.0386	0.0293
walk-half	0.3265	0.0173	0.0258	0.0539	0.0203	0.0315	0.0196	0.0176	0.0236	0.0155
walk-static	0.0237	0.0179	0.0111	0.0071	0.0078	0.0070	0.0109	0.0061	0.0064	0.0061
walk-xyz	0.2801	0.0136	0.0217	0.0165	0.0154	0.0323	0.0144	0.0144	0.0139	0.0125
sitting-half	0.0221	0.0354	0.0734	0.0247	0.0209	0.0151	0.0240	0.0216	0.0185	0.0176
sitting-static	0.0074	0.0066	0.0072	0.0132	0.0077	0.0116	0.0065	0.0062	0.0057	0.0055

and

Table 5. RMSE and the mean rotated APE under the TUM RGB-D dynamic dataset.

Sequence	ORB-SLAM3		Crowd-SLAM		SG-SLAM		DKB-SLAM-DR		DKB-SLAM-KF-DR		DKB-SLAM-BA-DR		DKB-SLAM
	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)	RMSE (°)	Mean (°)
walk-rpy	2.5574	2.5574	–	–	0.0982	0.0972	0.1007	0.0998	0.0931	0.0922	0.1144	0.1138	0.0934	0.0929
walk-half	1.1078	1.0991	0.0345	0.0334	0.0235	0.0216	0.0226	0.0212	0.0260	0.0235	0.0337	0.0314	0.0152	0.0137
walk-static	0.4913	0.4908	0.1612	0.1612	0.2682	0.2682	0.2087	0.2086	0.1505	0.1505	0.1246	0.1246	0.1167	0.1166
walk-xyz	1.3309	1.3198	0.0202	0.0191	0.0146	0.0120	0.0180	0.0617	0.0184	0.0170	0.0152	0.0130	0.0144	0.0127
sitting-half	0.0269	0.0254	0.0671	0.0666	0.0282	0.0276	0.0287	0.0269	0.0225	0.0204	0.0187	0.0171	0.0152	0.0135
sitting-static	0.1055	0.1054	0.1019	0.1019	0.1366	0.1366	0.0796	0.0795	0.0893	0.0893	0.0912	0.0911	0.0918	0.0917

present the translation and rotation APE results of various SLAM systems across six different dynamic sequences. The ‘walking’ series in the verified sequences represents high-dynamic scenes, while the ‘sitting’ series corresponds to low-dynamic scenes. To verify the effectiveness of the algorithm combination proposed in this paper, we designed several sets of ablation experiments, including (i) DKB-SLAM-DR, with only the dynamic feature point filtering module; (ii) DKB-SLAM-KF-DR, with improved keyframe selection and dynamic feature point detection and filtering modules; (iii) DKB-SLAM-BA-DR, with heterogeneous weighting local BA optimization and the dynamic feature point filtering module; and (iv) DKB-SLAM, with comprehensive deployment of the improved keyframe selection method, heterogeneous weighting local BA optimization, and dynamic feature point filtering modules.

The experimental results show that DKB-SLAM achieves the lowest error in most sequences, demonstrating excellent performance in both translation and rotation. In the sitting_half dataset, since the experimenters are almost stationary, some ultra-low dynamic feature points are not successfully identified and filtered out, causing the RMSE of DKB-SLAM’s translation APE to be slightly worse than that of DS-SLAM. From the perspective of rotation, in the walking_rpy dataset, there are many scenes where the experimenters walk in front of the camera, resulting in a significantly higher number of planar points compared to edge points. The improved keyframe selection method has a notable effect on system performance. In comparison, DKB-SLAM’s performance is slightly worse than that of DKB-SLAM-KF-DR, but still better than that of other systems. Overall, the experimental results demonstrate that DKB-SLAM has more advantages in most datasets, proving that the various modules proposed in this paper perform excellently across different dynamic scenes.

Figure 5 and Figure 6 show the trajectories of ORB-SLAM3, DKB-SLAM-BA, DKB-SLAM-KF, and DKB-SLAM-BA-KF in some static datasets, as well as the trajectories of DKB-SLAM-DR, DKB-SLAM-KF-DR, DKB-SLAM-BA-DR, and DKB-SLAM in dynamic datasets. Figure 7 and Figure 8 present the columnar comparison results of max, min, std, median, mean, and RMSE for the above experimental results.

From the test results on the public dataset, our proposed SLAM system demonstrates excellent performance in static, low-dynamic, and high-dynamic environments. The effectiveness of the proposed keyframe selection, heterogeneously weighted local BA optimization, and dynamic feature point identification and rejection is also confirmed.

4.2. Validation on Real-World Scenarios

To fully evaluate the effectiveness of the proposed algorithm, we conducted a series of tests using datasets collected in real-world scenarios. These datasets were designed to assess the adaptability and stability of our SLAM system in various complex environments. All data were collected by a mobile cart equipped with an Intel RealSense D435i RGB-D camera and a computing unit, as shown in Figure 9. The computing unit was primarily used for storing the recorded data and was not involved in the operation of DKB-SLAM.

Since the real trajectory is not available, we can only analyze the results qualitatively. To enhance the credibility of the results, we designed two sets of experiments: ‘straight’ and ‘static’. In the ‘straight’ experiment, the cart traveled in a straight line while the experimental personnel moved intermittently. To comprehensively evaluate the system’s performance in both low-dynamic and high-dynamic scenarios, we designed the experiment so that the experimenter moved in a low-dynamic manner in the first half and in a high-dynamic manner in the second half. In the ‘static’ experiment, the cart remained stationary while the experimenter moved quickly throughout the experiment to test whether the system could maintain accurate localization in extreme dynamic scenarios. We used ORB-SLAM3 and SG-SLAM as comparison systems.

Figure 10 illustrates the trajectories of DKB-SLAM, SG-SLAM, and ORB-SLAM3 when running the ‘straight’ dataset, as well as their positions in the x, y, and z directions over time. As shown in the figure, DKB-SLAM maintains a nearly ideal straight trajectory throughout the experiment, with minimal interference from the experimenter’s movements. The position changes in the x, y, and z directions also exhibit a smooth trend without sudden shifts, demonstrating their excellent stability in this scenario. In contrast, SG-SLAM’s performance is more variable. Although it maintains a relatively good straight trajectory during the first half of the experiment, it struggles in the second half of the highly dynamic scene. In particular, at position 1, the trajectory of SG-SLAM is significantly disrupted and deviates due to the experimenters’ side-by-side movement in a specific direction. The position change graph further reveals violent jittering along the x and y axes at this point, highlighting SG-SLAM’s limited adaptability to highly dynamic environments. Nevertheless, SG-SLAM still demonstrates strong competitiveness in low-dynamic scenes. Since ORB-SLAM3 lacks dynamic culling capabilities, its trajectory deviates from the expected path.

Figure 11 shows the trajectories of DKB-SLAM, SG-SLAM, and ORB-SLAM3 during the static experiment, along with their positions in the x, y, and z directions over time. Notably, the trajectory of DKB-SLAM remains almost stationary at the origin, which aligns perfectly with the designed baseline trajectory and is unaffected by the experimenter’s movements. From Figure 12, it is clear that DKB-SLAM effectively eliminates dynamic points associated with the experimenter, even in both single- and multi-person fast-motion scenarios. The position change graphs in the x, y, and z directions further validate that DKB-SLAM experiences minimal fluctuations in each direction, consistently staying stable around 0. This demonstrates that DKB-SLAM remains unaffected by the experimenter in harsh experimental conditions, successfully removing any interference from dynamic features and ensuring high localization accuracy. In contrast, SG-SLAM struggles in highly dynamic scenes, with its trajectory deviating significantly from the expected path. This results in increased errors along the x, y, and z directions and severe drifting of the trajectory, highlighting SG-SLAM’s limitations in handling dynamic environments, which impacts its performance in complex settings.

4.3. Timing Analysis

In addition to localization accuracy, real-time performance is a crucial metric for evaluating a SLAM system’s practical applicability.

Table 6. Algorithm runtime comparison (s).

Systems	Average Processing Time per Frame (ms)
ORB-SLAM3	18.18
DS-SLAM	87.84
DynaSLAM	240.91
Crowd-SLAM	27.68
SG-SLAM	35.72
DKB-SLAM (Proposed)	30.97

presents a comparative analysis of the average processing time per frame for DKB-SLAM against several state-of-the-art dynamic SLAM systems. The results highlight DKB-SLAM’s computational efficiency, particularly when compared to methods reliant on heavy segmentation. Systems like DynaSLAM (240.91 ms) and DS-SLAM (87.84 ms) utilize computationally intensive, full-image semantic segmentation, leading to significant processing delays. In contrast, DKB-SLAM adopts a more streamlined two-stage approach. It first uses the efficient YOLOv5 to identify potential dynamic regions, and then applies lightweight optical flow and Gaussian distribution analysis only to feature points within these detected bounding boxes. This strategy avoids processing the entire scene, drastically reducing computational overhead and making it significantly faster than SG-SLAM (35.72 ms) and other segmentation-based methods.

Our proposed DKB-SLAM achieves an average processing time of 30.97 ms per frame. This is marginally slower than the static baseline ORB-SLAM3 (18.18 ms) and Crowd-SLAM (27.68 ms). The increased time compared to ORB-SLAM3 is the expected trade-off for adding robust dynamic object handling. Crowd-SLAM’s slight speed advantage stems from its more direct filtering strategy—it simply removes all feature points that fall within a YOLO detection box. While this approach is computationally faster, it risks discarding valuable static background points, which can lead to poorer robustness and potential tracking loss. In contrast, the marginal extra processing time of DKB-SLAM is a direct result of its more sophisticated filtering pipeline, which intelligently validates points within the bounding box to preserve stable features. This deliberate trade-off of a few milliseconds ensures higher accuracy and tracking stability. Ultimately, this performance, equivalent to processing over 32 frames per second, confirms that DKB-SLAM strikes an excellent balance between robust dynamic object handling and computational efficiency, meeting the stringent real-time requirements for practical applications.

5. Conclusions

In this paper, we propose DKB-SLAM, an RGB-D visual SLAM system designed to enhance the navigational autonomy and robustness of mobile robots in dynamic environments. By integrating a lightweight dynamic feature filtering pipeline, an adaptive keyframe selection strategy tailored for robot motion, and a geometry-aware local bundle adjustment, our system effectively mitigates localization drift caused by moving objects. The experimental results, validated on both the public TUM RGB-D benchmark and in real-world scenarios, demonstrate that DKB-SLAM achieves state-of-the-art accuracy and stability in static, low-dynamic, and extremely high-dynamic scenes. The primary advantage of our method lies in its balanced approach, achieving high accuracy in dynamic scenes without the computational burden of full semantic segmentation, making it suitable for real-time robotic applications. However, a limitation is its potential to misclassify very slow-moving or intermittently static objects, as the geometric and motion cues may not be strong enough for detection. Additionally, its performance is dependent on the initial object detection by YOLO, meaning that a failure to detect a dynamic object will result in it not being filtered.

Looking ahead, we plan to extend the system’s capabilities for more advanced robotic applications. Future work will focus on integrating the rich environmental perception of DKB-SLAM with motion planning and control modules. Furthermore, inspired by the valuable feedback from the review process, we will investigate an adaptive weighting scheme for the local BA. This future work will explore methods to dynamically adjust the weight assigned to edge points based on real-time scene characteristics, such as the level of dynamism or geometric complexity, which could potentially offer further accuracy improvements. This will enable not just robust localization, but also dynamic obstacle avoidance and safer human–robot interaction, paving the way for more intelligent and autonomous robotic systems. The source code for DKB-SLAM will be made publicly available at https://github.com/xu-no1/DKB-SLAM (accessed on 10 September 2025).