High-Precision Visual SLAM for Dynamic Scenes Using Semantic–Geometric Feature Filtering and NeRF Maps

Abstract

Dynamic environments pose significant challenges for visual SLAM, including feature ambiguity, weak textures, and map inconsistencies caused by moving objects. We present a robust SLAM framework integrating image enhancement, a mixed-precision quantized feature detection network, semantic-driven dynamic feature filtering, and NeRF-based static scene reconstruction. The system reliably extracts features under challenging conditions, removes dynamic points using instance segmentation combined with polar geometric constraints, and reconstructs static scenes with enhanced structural fidelity. Extensive experiments on TUM RGB-D, BONN RGB-D, and a custom dataset demonstrate notable improvements in the RMSE, mean, median, and standard deviation. Compared with ORB-SLAM3, our method achieves an average RMSE reduction of 93.4%, demonstrating substantial improvement, and relative to other state-of-the-art dynamic SLAM systems, it improves the average RMSE by 49.6% on TUM and 23.1% on BONN, highlighting its high accuracy, robustness, and adaptability in complex and highly dynamic environments.

1. Introduction

In order to autonomously complete complex tasks in unknown environments, robots need to have an accurate perception of their own state and effective cognition of the surrounding environment. Visual sensors, as a key tool for information acquisition, make Simultaneous Localization and Mapping (SLAM) based on image information one of the core directions of research, and the related technology is called visual SLAM. Among many application scenarios, visual SLAM in indoor environments is highly valued for its wide range of applications in the fields of intelligent robotics, Augmented Reality (AR), indoor navigation and security monitoring, etc., and has received a great deal of attention due to its wide application value [1]. Compared with outdoor environments, indoor scenes tend to be more complex in structure, sparse in texture information, and usually do not have access to auxiliary information from global navigation satellite systems (e.g., GPS or BDS [2]), which puts more stringent requirements on the system’s sensor robustness and algorithmic accuracy. In recent years, benefiting from the rapid development of computer vision and deep learning, a number of high-performance vision SLAM systems such as SVO [3], LSD-SLAM [4], VINS-Fusion [5], and the ORB-SLAM series [6,7,8] have been introduced. Among them, ORB-SLAM3 [8], as one of the most representative feature point methods, is widely recognized as representative of current systems with excellent accuracy and robustness due to its excellent performance in multi-sensor fusion and scene adaptation. However, mainstream visual SLAM methods generally rely on static scene assumptions, which significantly limits their ability to adapt to dynamic environments in the real world, and becomes a key bottleneck that restricts their practical deployment and generalization.

Most other mature vision SLAM schemes deal with dynamic anomalies based on the Random Sampling Consistency Algorithm (RANSAC) [9]. SVO combines the photometric error minimization of the direct method of image blocks with RANSAC to improve the adaptability to dynamic regions, and VINS-Fusion filters out false matches in dynamic scenes by estimating the essentiality matrix via the RANSAC + five-point method. The ORB-SLAM family computes the single responsiveness matrix or the basis matrix, and combines RANSAC to accurately reject abnormal feature points. However, the robustness of RANSAC still has limitations in dynamic feature-intensive scenarios: when the proportion of outlier points is too high, its model fitting ability decreases rapidly [10], which, in turn, affects the tracking stability and map accuracy of the SLAM system. To break through this limitation, some works have started to introduce deep learning methods for explicit modeling of dynamic regions.

Dynamic SLAM methods based on target detection or semantic segmentation (e.g., Detect-SLAM [11], DynaSLAM [12]) improve robustness by recognizing and rejecting dynamic targets, but are prone to misclassifying potentially dynamic objects such as stationary pedestrians or parked vehicles as moving regions, leading to over-filtering of information. In contrast, motion-consistent segmentation methods based on optical flow or scene flow (e.g., STDyn-SLAM [13], DytanVO [14]) can achieve pixel-level dynamic detection; however, they are prone to be limited by the accuracy of the optical flow and perform inconsistently in low-texture, illumination-varying, or slow-motion scenes. In addition, the uncertainty of deep learning methods may also lead to erroneous deletion of valuable information, which makes some dynamic SLAM systems perform poorly in static environments.

Therefore, more accurate detection algorithms and more reasonable processing strategies are urgently needed for dynamic targets. Instance segmentation allows for fine segmentation and instance-level labeling of independent objects in an image, providing a stronger a priori information for modeling potentially dynamic regions. Traditional geometric methods detect dynamic regions using inter-frame consistency, but they often fail under low-texture or changing lighting conditions, increasing uncertainty in tracking and dynamic segmentation. Instance segmentation provides prior information for feature selection, which can be combined with geometric constraints. To address these issues, this paper proposes a visual SLAM framework with image enhancement that handles both potential and explicit dynamic objects. The main contributions are as follows:

(1)

We introduce image enhancement in the front-end to balance grayscale distribution and replace traditional ORB features with a mixed-precision quantized feature detection network. This improves robustness and matching accuracy in low-texture, low-light, and jittery environments.

(2)

Using YOLO to extract prior information of dynamic objects and polar geometry, we propose a dynamic feature filtering method. It combines instance segmentation masks with geometric constraints to improve SLAM localization accuracy.

(3)

To improve map detail and scene integrity, we introduce a NeRF module to model the static scene after removing dynamic objects. This enhances the structural restoration and geometric consistency of the maps.

(4)

We evaluated our system on TUM RGB-D, BONN RGB-D, and a home-made dataset. Compared to ORB-SLAM3, it achieves higher localization accuracy in dynamic scenes and outperforms other state-of-the-art dynamic SLAM methods in terms of robustness.

The rest of the paper is organized as follows: Section 2 introduces related research, Section 3 details the theoretical foundation of the proposed framework, Section 4 demonstrates the experimental design and performance evaluation of dynamic SLAM, and Section 5 summarizes the main conclusions of this study.

2. Related Work

To cope with the SLAM problem in dynamic environments, several studies have used geometric information as a basis for detecting and eliminating the interference of dynamic objects by utilizing spatial geometric constraints between features. COEB-SLAM [15] combines target detection and polar geometry. It first marks dynamic regions by detection, then removes dynamic points through spatial consistency checks. Image blurring is also used as a cue. StaticFusion [16] recognizes dynamic objects by clustering depth maps and calculating dynamic probabilities for each cluster based on camera motion. Trifocal SLAM [17] introduces three-view coplanarity constraints. By using three consecutive frames, it achieves more reliable motion consistency and overcomes the limits of traditional binocular geometry in dynamic scenes. CoSLAM [18] identifies dynamic points by computing the matching relationship between images and then triangulating them. DynaVINS [19] uses a keyframe-based global optimization method. It estimates camera position with IMU and applies multiple constraint assumptions to reduce the effect of dynamic objects on loop detection. PPS-SLAM [20] combines optical flow and polar geometry to detect dynamic regions and retain useful static parts for tracking. It also applies probabilistic cross-frame propagation to reduce the impact of missing semantic information.

Among many geometric methods, although most SLAM systems mainly rely on point features, line features and planar features are also gradually introduced into dynamic visual SLAM, e.g., PL-SLAM [21] performs well in the case of sparse or uneven distribution of point features, but it relies only on the RANSAC method, with a limited effect when processing dynamic objects. Joan et al. [22] proposed an RGB-D based MSC-VO algorithm that integrates point and line features. It leverages geometric constraints and a Manhattan coordinate system to optimize camera pose using both Manhattan axes and reprojection errors. Yuan et al. [23] proposed PLDS-SLAM, which achieves the separation of dynamic and static objects by proposing a geometric constraint method for line segment matching combined with an epipolar constraint method for feature points. DynPL-SLAM [24] introduces a dynamic feature detector that integrates point and line features to handle highly dynamic objects. It also incorporates a new spatial line residual error into pose optimization and applies a histogram-based regional similarity model for keyframe selection and loop detection.

In recent years, deep learning methods such as target detection, target tracking, and feature extraction networks have been widely applied to visual SLAM. These methods effectively improve the robustness and accuracy of the system in localization and image building by providing rich semantic information. Typical representatives include YOLO [25], Siamese network [26], and SuperPoint [27]. Visual semantic-based SLAM methods in static scenes, such as SLAM++ [28], QuadricSLAM [29] have shown good results. In dynamic scenes, semantic information can also provide valuable a priori information for SLAM. DYO-SLAM [30] estimates target parameters by combining clustering, weighted PCA, and minimum bounding rectangles. It further designs a multimodal data association strategy that fuses appearance, semantic, and spatial information to improve tracking robustness in complex dynamic scenes. SP-VSLAM [31] uses the SuperPoint network for feature extraction and binary descriptors. With non-maximum suppression, it ensures uniform feature detection and builds robust feature associations. PLD-SLAM [32] utilizes MobileNet [33] with clustering algorithms for object recognition, followed by the use of epipolar geometric relations to enhance the spatial structure information of the feature points, and deep consistency checking to ensure the consistency of the feature points across different viewpoints. DDN-SLAM [34] addresses dynamic interference by segmenting feature points with semantic features and a hybrid Gaussian model. It further applies sparse point cloud sampling with background restoration and builds maps using NeRF. MVS-SLAM [35] uses YOLOv7 [36] to obtain a priori semantic information to eliminate dynamic features. DGM-VINS [37] uses dyadic geometry and DBSCAN [38] clustering to detect dynamic feature points.

Although the above dynamic SLAM system improves the accuracy and robustness to a certain extent, its feature extraction and semantic perception abilities are still limited, which makes it difficult to fully cope with the complex occlusions and changes in highly dynamic scenes. In order to further improve the perception and localization accuracy of the system in dynamic environments, this paper introduces the ZippyPoint feature network to enhance the stability of keypoint extraction and matching, and combines it with the NeRF for high-quality scene mapping, so as to improve the overall robustness and reconstruction effect of the system in dynamic scenes.

3. System Overview

In this paper, a novel SLAM system integrating semantic understanding and neural rendering is constructed on the basis of ORB-SLAM3. By introducing instance segmentation and a priori information extraction threads, as well as NeRF building threads, the recognition and rejection of dynamic objects are realized. At the same time, the system adopts ZippyPoint to replace the original feature extraction and matching method, which improves the robustness and the quality of image construction in dynamic scenes. The improved system structure is shown in Figure 1:

In the instance segmentation and semantic information extraction thread, the TensorRT inference-accelerated YOLO instance segmentation network is used to provide accurate instance-level a priori information for the tracking thread; in the tracking thread, ZippyPoint is used for feature extraction, in combination with our proposed MNN matching algorithm, which is designed to improve upon the limitations of ORB features in specific scenarios due to the scarcity of effective feature points. Subsequently, based on the extracted a priori information and polar geometry constraints, dynamic object detection is performed to reject the dynamic features in the current frame. Subsequently, the system completes the inter-frame pose estimation based on static feature points and multi-frame triangulation, and the NeRF mapping module generates a sparse pseudo-point cloud by using the key frame images and the estimated poses to further construct the training data, and then reconstructs the dense, high-fidelity 3D scene through neural rendering, which is an alternative to the traditional point cloud mapping method.

3.1. Image Enhancement Methods for Grayscale Equalization

In this section, an improved image equalization algorithm based on the spatial domain is proposed to extend the idea of traditional grayscale image equalization. The color equalization algorithm calculates the cumulative distribution function by histogram statistics of the input image I and introduces a proportional threshold to remove extreme pixels to precisely define the effective dynamic range. Subsequently, the pixel values are linearly stretched so that they are uniformly distributed over the target range to enhance the overall contrast. The stretched pixel values are calculated as follows:

$$I_s\left(x,y\right)=\mathrm{c}\mathrm{l}\mathrm{i}\mathrm{p}\left({\displaystyle \frac{I\left(x,y\right)-l_{min}}{l_{max}-l_{min}}},\mathrm{0,1}\right)$$

(1)

where $clip(,\mathrm{0,1})$ denotes restricting the value to the interval [0, 1]. To further improve the local detail performance of the image, a weighted convolution mechanism is introduced, and the weight $w(i,j)$ of the convolution kernel is jointly determined by the local contrast and the local mean:

$$w\left(i,j\right)={\displaystyle \frac{1}{1+\alpha {\left(\frac{\left|I\left(x,y\right)-{\mu }_{x,y}\right|}{{\sigma }_{x,y}}\right)}^p}}$$

(2)

This weight function is controlled by the moderating coefficient α and the exponentiation factor p. $\left|I\left(x,y\right)-{\mu }_{x,y}\right|$ denotes the absolute difference between the current pixel and its local mean, reflecting the local brightness deviation of the image. ${\sigma }_{x,y}$ reflects the local contrast of the image. However, the enhancement based on local statistical features still suffers from poor adaptation to image content and is prone to local over-enhancement or under-enhancement.

For this reason, this paper introduces a meta-heuristic optimization strategy to simulate the process of finding the optimal solution through pheromone propagation by individual butterflies in space. The weights of the convolution kernel are optimized by defining the fitness function, which is shown in Equation (3), and the process of finding the optimal solution is shown in Figure 2.

$$f(P)={\sum }_{i=-r}^r·{\sum }_{j=-r}^r·\left|p_{i,j}-{\displaystyle \frac{1}{\sqrt{i^2+j^2}}}\right|$$

(3)

The optimization process consists of a global search of the Cauchy variation [39] with local fine-tuning of the difference strategy, which gradually and iteratively updates the population and converges to the optimal solution.

After the optimization of the convolutional kernel is completed, a multi-scale strategy is introduced to improve the efficiency and enhancement effect: the image is first downsampled for initial enhancement at low resolution, then upsampled to the original size and weighted to fuse with the high-resolution results. Finally, CLAHE (see Figure 3) is combined to further enhance the local details, so that the enhanced image has a better hierarchical performance while maintaining the natural sense.

3.2. Feature Extraction and Matching

Zippypoint [40] is an advanced keypoint detection and description framework with an encoder of eight convolutional layers and a decoder with three output branches. It employs binary-oriented L2 normalization and a macro block-based mixed-precision quantization scheme to improve efficiency by assigning different numerical precisions to distinct network regions. However, this can cause feature discontinuities and quantization errors, limiting the performance of traditional matching methods. In this work, we modify the Zippypoint architecture (Figure 4) and propose an adaptive feature matching strategy, the MNN method, to overcome these limitations.

Feature matching calculates the similarity between different image feature descriptors by means of a distance metric, as indicated by the following equation:

$$\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}({\mathrm{D}}_0,{\mathrm{D}}_1)=(1-{\mathrm{D}}_0)\cdot {\mathrm{D}}_1^{\mathrm{\top }}+{\mathrm{D}}_0\cdot (1-{\mathrm{D}}_1{)}^{\mathrm{\top }}\left\{\begin{array}{c}{\mathrm{D}}_0\in {\mathrm{R}}^{N_0\times d}\\ {\mathrm{D}}_1\in {\mathrm{R}}^{N_1\times d}\end{array}\right.$$

(4)

D₀, D₁ are the sets of feature descriptors of the two images; N₀ and N₁ denote the number of feature points extracted from the two images; and d denotes the dimension of the descriptor. By combining the inverse values of the feature descriptors with their own inner products, the distance matrix $dist\in R^{N_0\times N_1}$ between two descriptors is obtained, where dist[i,j] denotes the distance between the i-th descriptor D₀[i] and the j-th descriptor D₁[j]. After computing the distance matrix, each descriptor selects its nearest and second-nearest neighbors. A match is accepted if the distance ratio is below threshold ${\theta }_1$ and the nearest neighbor’s distance is within threshold ${\theta }_2$. A bidirectional consistency check is then applied to enhance reliability. As shown in Section 4, this method achieves a significantly better matching performance than that of ORB-SLAM3. However, its computational cost grows with the number of features. To reduce complexity, we simplify the distance matrix calculation using squared Euclidean distance.

$${\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}}_{ij}={\sum }_{k=1}^d·({\mathrm{d}}_{0,i,k}-{\mathrm{d}}_{1,j,k}{)}^2$$

(5)

The improved distance matrix computation reduces computational overhead, where $d_{0,i,k}$and $d_{1,i,k}$ denote the k-th elements of descriptors from sets ${\mathrm{D}}_0$ and ${\mathrm{D}}_1$, respectively. Furthermore, the traditional point-wise consistency check limits efficiency. To accelerate matching, we obtain candidate pairs in batches from reverse matching results and verify bidirectional consistency using tensor-based operations.

$$G\left[i\right]=m_1\left[m_0\right]$$

(6)

where $G\left[i\right]$ represents the reverse match result from $D_0\left[i\right]$ to $D_1\left[i\right]$, a bidirectional consistency mask can be constructed based on $G\left[i\right]$ to obtain the match index of each feature, if and only if

$$\left\{\begin{array}{l}G\left[i\right]=i\\ {\mathrm{m}}_1\left[{\mathrm{m}}_0\right[i\left]\right]=i\end{array}\right..$$

(7)

This indicates a bidirectional match. After testing and improvement, the MNN method (referred to as MNN2 in subsequent tests) further improved matching accuracy and speed.

3.3. Dynamic Feature Rejection

3.3.1. Dynamic Feature Filtering via Prior Information and Epipolar Constraints

Traditional dynamic feature filtering methods often rely on dynamic masks, such as removing pixels in regions labeled as highly dynamic (e.g., human bodies). Although computationally efficient, these methods can mistakenly discard static objects labeled as dynamic, such as stationary people, leading to a loss of valid features and reduced localization accuracy. To address this, we propose a dynamic feature filtering algorithm that combines prior semantic information with epipolar geometric constraints. By fusing semantic labels and geometric consistency, the method more accurately distinguishes truly dynamic objects from static background regions misclassified as dynamic. This reduces feature loss due to misclassification while maintaining efficiency, thereby improving overall localization and mapping performance. The algorithm workflow is illustrated in Figure 5.

Geometric constraints on polar geometry properties can be used to distinguish whether features are dynamic or static. In multi-view geometry, static features should satisfy the polar surface constraint, whereas dynamic features usually violate this constraint.

For point features, first, it is assumed that all feature points are static. Under this assumption, the polar planes, 3D landmark positions (by least squares solution), camera poses, or projections can be estimated. Then, the error between the estimated and actual measurements is calculated and dynamic features are detected based on a predefined threshold.

Several cases in Figure 6a set thresholds with geometric constraints for static data associations to detect dynamic features.

After the depth camera captures the k-th frame’s RGB image and corresponding depth data, the YOLO instance segmentation network generates class-specific object masks to extract semantic priors. In parallel, point features are detected in a separate thread. The segmentation-derived priors are then used to define the initial static region $R_{static}$, containing point features $P_n^k$, which are stored in array ${arr}_{point}^k$ for subsequent processing. This step helps suppress dynamic object interference in feature extraction and scene understanding. The initialization arrays are given in (8) and (9).

$${arr}_{point}^k=\left\{p_1^k,\cdots ,p_n^k,\cdots \right\};p_n^k\in R_{static}$$

(8)

The correspondence between image point features in two consecutive frames is illustrated in Figure 6b. Let $P$ be a static map point whose projections in frames $F_{k-1}$ and $F_k$ are denoted as $x_1^{k-1}$ and $x_2^k$, respectively, where $x_2^k$ is the matching point of $x_1^{k-1}$ in $F_k$.The projection of $x_1^{k-1}$ onto frame $F_k$ is denoted as ${\tilde{x}}_1^{k-1}$. Let $C_1$ and $C_2$ denote the camera optical centers. The line connecting them, which is referred to as the baseline, together with the map point $P$, defines the epipolar plane $Z.$ The epipolar plane intersects the image planes of frames $F_{k-1}$ and $F_k$at the epipolar lines $l_1^{k-1}$ and $l_2^k$, respectively. The intersection of the baseline with each image plane is called the epipole, denoted as $e_1$ and $e_2$. This geometric constraint describes the mapping from a point in one image to the corresponding baseline in the other. Let the homogeneous coordinates of $x_1^{k-1}$ and $x_2^k$ be $p_1$ and $p_2$, respectively. The mapping can be expressed using the fundamental matrix $Q$ and homogeneous coordinates as

$$p_2^{T}Q{p}_1=0$$

(9)

$$\left\{\begin{array}{c}{p}_1=[u_1,v_1,1{]}^{\mathrm{T}}\\ p_2=[u_2,v_2,1{]}^{\mathrm{T}}\end{array}\right.$$

(10)

Based on the transformation relationship between world coordinates and pixel coordinates:

$$\left\{\begin{array}{l}{p}_1=KP\\ p_2=K(RP+t)\end{array}\right.$$

(11)

where K is the internal reference matrix of the camera, obtained by couplings (10) and (11):

$$p_2^T{K}^{-T}\widehat{t}R{K}^{-1}{p}_1=0$$

(12)

where $\widehat{t}$ is the antisymmetric matrix of the translation vector $t$, such that:

$$Q=K^{-T}\widehat{t}R{K}^{-1}$$

(13)

A and B are the linear parameters of $l_2^k$ obtained by solving according to $x_1^{k-1}$ and $Q$. $d$ is the distance from $x_2^k$ to the polar line $l_2^k$, as shown in Equation (14):

$$d={\displaystyle \frac{\left|p_2^{T}Q{p}_1\right|}{\sqrt{A^2+B^2}}}$$

(14)

The value $d$ is used to verify dynamic features, where $d_{th}$ denotes the epipolar threshold parameter. Points with $d<d_{th}$ are classified as static, while those with $d>d_{th}$ are classified as dynamic. For each instance segmentation mask containing $k$ keypoints, we label the mask as dynamic if more than 60% of its points are dynamic—this threshold was determined empirically based on our test results. Finally, points within regions not classified as dynamic, $R_{dyn\_static}$, are added to the array ${arr}_{point}^k$, completing the dynamic feature filtering process based on prior information and epipolar constraints.

3.3.2. NeRF Construction Method

NeRF [41] reconstructs high-quality 3D scenes by learning from sequences of 2D images captured from multiple viewpoints. The framework of our method is shown in Figure 7. After applying the dynamic feature filtering algorithm that integrates prior information with epipolar geometric constraints, a static point set is obtained. To further lift the 2D correspondences in these images into 3D space, linear triangulation is applied to the static point pairs using the known camera poses $T_t={\left\{R|t\right\}}_j$.

$$X_i=∆(x_t,x_r;T_t,T_r)$$

(15)

Here, $T_t=\left\{R_t|t_t\right\}$ and $T_r=\left\{R_r|t_r\right\}$ denote the camera poses of the current and reference frames, respectively, and $X_i$ represents the reconstructed 3D points. To ensure triangulation accuracy and stability, reconstruction is performed only when the feature points exhibit favorable covariance. Pseudo-points failing the positive depth constraint or exhibiting large projection errors are discarded to strengthen subsequent geometric constraints. The remaining 3D points from static matches form a sparse pseudo-point cloud for the current frame. Once triangulation is completed, each keyframe $I_t$ and the corresponding camera pose $T_k$ are used as NeRF training inputs, and both the summation and supervised loss functions are constructed.

$$L_{geo}={\sum }_{i=1}^N{‖I_k\left(u_i,v_i\right)-c_i‖}^2$$

(16)

$N$ is the total number of points in the pseudo-point cloud, $I_k\left(u_i,v_i\right)$ is the color value of image $I_k$ at pixel coordinates $\left(u_i,v_i\right)$, and $c_i$ represents the color of 3D point $X_i$. This loss guides the NeRF network to emphasize key 3D geometric structures during training. Rendering colors are obtained by integrating along each ray $\gamma$ using the volume-rendering formula:

$$C\left(r\right)={\int }_{t_n}^{t_f}T\left(t\right)·\delta \left[x\left(t\right)\right]·c\left[x\left(t\right),d\right]dt$$

(17)

$x\left(t\right)=o+sd$ represents the spatial position of a sampled point along the ray, where $o$ is the camera center and $d$ is the ray direction. Here, $\delta \left[x\left(t\right)\right]$ denotes the density function, $c\left[x\left(t\right),d\right]$ the color function, and the forward transmittance $T\left(t\right)$ is defined as

$$T\left(t\right)=\mathrm{e}\mathrm{x}\mathrm{p}(-{\int }_{t_n}^t\delta \left[x\left(s\right)\right]ds)$$

(18)

The overall training objective is to minimize both the image reconstruction error and the geometric supervision loss:

$$L=L_{render+}{L}_{geo}{\lambda }_{geo}$$

(19)

where the rendering reconstruction loss is

$$L_{render}={\sum }_{r\in R}{‖I_k\left(C\left(r\right)-C_{GT}\left(r\right)\right)‖}^2$$

(20)

$C_{GT}\left(r\right)$ denotes the color corresponding to ray $r$ in the real image, while ${\lambda }_{geo}$ is the hyperparameter that regulates the geometric supervision weights.

4. Experiments

The experimental platform configuration for this paper is as follows: Ubuntu20.04, The experimental platform configuration for this paper is as follows: Ub-untu20.04, lntel(R) Core(TM) i5-12400F CPU, NVIDIA GeForce RTX 4060Ti GPU, and 8 GB of operating memory. The custom dataset was acquired using an Intel RealSense D435i depth camera (Intel Corporation, Santa Clara, CA, USA), configured at a resolution of 640 × 480, capturing RGB and depth data at 30 FPS.

4.1. Image Enhancement and Feature Extraction

Image enhancement is evaluated on blurred images from the GoPro [42] dataset (see Supplementary Materials) using the deep learning-based Zero-DCE TF [43], CLAHE, and the proposed algorithm. Feature extraction is conducted on custom weak-texture images using ORB, SuperPoint, XFeat [44], and the proposed method. The experimental results are presented in Figure 8.

In Figure 8a,b, the Zero-DCE TF algorithm improves image brightness but suffers from over-enhancement, with limited adjustment of gray values. CLAHE significantly increases image contrast and yields a more uniform grayscale distribution. In comparison, the proposed algorithm combines the strengths of both, enhancing brightness without over-enhancement and producing a more uniform grayscale distribution. The feature extraction results in Figure 8c are summarized in

Table 1. Feature extraction experimental data statistics.

Algorithm	ORB	Superpoint [27]	XFeat [44]	Improvements to Zippypoint
Extracting Points	11	302	167	228

, using a confidence threshold of 0.015 and a non-maximum suppression (NMS) window size of 3.

The experimental results show that ORB extracts fewer feature points, while SuperPoint produces more but with significant overlap. XFeat performs well in high-texture regions but is less effective in weak-texture areas. In contrast, the proposed algorithm achieves a more uniform distribution of feature points. Although its total number is lower than SuperPoint, it delivers the best overall performance, with more balanced and effective feature extraction across different regions.

4.2. Feature Point Matching

In SLAM, feature point matching is a core task that identifies identical or similar features in images captured at different times, supporting pose estimation, map updates, and loop closure detection. To evaluate the proposed algorithm, five image sets from HPatches [45], GoPro (see Supplementary Materials), and a custom dataset were tested under varying conditions: illumination change, rotation, viewpoint change, motion blur, and low-texture environments.

In the experiments, 500 feature points were extracted per image pair, and RANSAC was applied to remove false matches. To enhance matching accuracy, the non-maximum suppression (NMS) radius was set to 3, and the matching ratio threshold was set to 0.95. The results are shown in Figure 9.

The average performance of the four algorithms is summarized in

Table 2. Feature matching experimental statistics.

Image Number	Typology	Arithmetic	Correctly Matched Pairs	Matching Accuracy	Total Elapsed Time/s
1	Light change	ORB + BF	81	50.00%	0.472
		Zippypoint + BF	262	70.81%	0.296
		Zippypoint + MNN	285	77.03%	0.284
		Zippypoint + MNN2	295	83.10%	0.245
2	Rotational change	ORB + BF	157	70.40%	0.578
		Zippypoint + BF	218	70.78%	0.313
		Zippypoint + MNN	239	77.60%	0.263
		Zippypoint + MNN2	241	91.63%	0.241
3	Perspective change	ORB + BF	175	69.72%	0.837
		Zippypoint + BF	224	65.12%	0.265
		Zippypoint + MNN	241	70.06%	0.260
		Zippypoint + MNN2	255	80.95%	0.243
4	Motion blur	ORB + BF	96	42.86%	0.504
		Zippypoint + BF	172	52.44%	0.301
		Zippypoint + MNN	152	46.34%	0.281
		Zippypoint + MNN2	166	58.66%	0.256
5	Low-texture environments	ORB + BF	0	0.00%	0.719
		Zippypoint + BF	10	21.28%	0.291
		Zippypoint + MNN	10	21.28%	0.265
		Zippypoint + MNN2	10	40.00%	0.229

. The proposed method achieves matching accuracies of 83.10%, 91.63%, 80.95%, 58.66%, and 40.00%, with matching times of 0.245 s, 0.241 s, 0.243 s, 0.256 s, and 0.229 s, respectively. Its average matching accuracy of 70.87% is 52.07%, 26.32%, and 21.25% higher than the other three methods. These results demonstrate that the proposed algorithm effectively reduces localization errors and map drift in SLAM while lowering computational cost, thereby improving overall efficiency and robustness.

4.3. Posture Estimation

We test our algorithm on the publicly available TUM and BONN datasets (see Supplementary Materials). To evaluate the effectiveness of our SLAM system, we used the EVO [46] tool to measure the absolute trajectory error and compute the root mean square error (RMSE), mean error (Mean), median error (Med), and standard deviation (STD). For reliability, each sequence was tested in ten independent runs, and the median result was reported to minimize the influence of outliers. The results are presented in

Table 3. Absolute trajectory error experimental results (ATE).

TUM Datasets					BONN Datasets
Sequences	Mean	Med	Rmse	Std	Sequences	Mean	Med	Rmse	Std
s_half	0.01966	0.01779	0.02230	0.01194	ballon_tracking	0.0346	0.0305	0.0385	0.0168
s_static	0.0062	0.0055	0.0070	0.0034	ballon	0.0248	0.0228	0.0278	0.0127
w_half	0.0273	0.0237	0.0321	0.0169	crowd	0.0195	0.0166	0.0227	0.0115
w_rpy	0.0264	0.0199	0.0355	0.0237	person_tracking	0.0347	0.0333	0.0373	0.0138
w_static	0.0069	0.0063	0.0078	0.0036	static_close_far	0.0669	0.0554	0.0762	0.0366
w_xyz	0.0141	0.0126	0.0164	0.0084	synchronous	0.0181	0.0139	0.0234	0.0148

.

Figure 10 shows a comparison of APE trajectory errors for each sequence. The dashed line represents the actual trajectory, while the colored lines represent the trajectories estimated by the SLAM system. The colors indicate the magnitude of the trajectory errors, with colors ranging from blue to red, representing a distribution of errors from low to high.

We further compared the proposed improved algorithm with several state-of-the-art SLAM methods. To objectively assess performance in different dynamic scenarios, the root mean square error (RMSE) was used as a metric to quantify the overall deviation between the estimated and ground-truth trajectories. The results are presented in

Table 4. TUM dataset absolute trajectory error RMSE results.

Sequence	ORB-SLAM3 [8]	RDS-SLAM [47]	Dynamic- VINS [48]	CPRSLAM [49]	LVID-SLAM [50]	OURS
s_ halfsphere	0.1095	/	/	0.02246	/	0.0258
s_static	0.0106	0.0084	/	/	0.0086	0.0070
w_halfsphere	0.7077	0.0807	0.0608	0.0487	0.0368	0.0321
w_rpy	1.1519	0.1604	0.0629	0.0539	0.0882	0.0355
w_static	0.4094	0.0206	0.0077	0.0101	0.0083	0.0078
w_xyz	0.5854	0.0213	0.0486	0.0159	0.0164	0.0164

and

Table 5. BONN dataset absolute trajectory error RMSE results.

Sequence	ORB-SLAM3 [8]	OVD-SLAM [51]	FADM-SLAM [52]	DIO-SLAM [53]	YLS-SLAM [54]	OURS
ballon_tracking	0.0455	0.0087	0.034	0.0259	/	0.0385
ballon	0.0828	0.1091	0.055	0.0291	/	0.0278
crowd	0.6234	0.0318	0.078	0.0292	0.0362	0.0227
person_tracking	0.6226	0.0513	0.167	/	0.0267	0.0373
static_close_far	0.0839	0.0147	0.013	/	/	0.0762
synchronous	0.8793	0.0200	0.233	/	0.0327	0.0234

.

As shown in the TUM dataset results, the proposed SLAM system consistently achieved the lowest absolute trajectory error across all sequences. It also exhibited superior robustness, avoiding the sudden error spikes observed in LVID-SLAM under rpy rotation and in Dynamic-VINS under xyz vertical translation, even when facing diverse viewpoint trajectories.

According to the BONN dataset results, the proposed SLAM system delivers an outstanding performance in highly dynamic scenarios—such as crowd and synchronous sequences—achieving the lowest absolute trajectory error. For the remaining sequences, its accuracy is generally comparable to, and in some cases surpasses, that of other state-of-the-art methods.

Finally, we conducted ablation studies on three sequences to evaluate the contribution of each module. Specifically, image enhancement is denoted as A, feature extraction and matching as B, and dynamic feature rejection as C. The ablation results are summarized in

Table 6. Melting experiment results.

Sequence	None	A	B	C	A + C	B + C	ALL
w_static	0.4094	0.3463	0.3397	0.0097	0.0084	0.0081	0.0078
ballon	0.0828	0.0593	0.0672	0.0369	0.0299	0.0305	0.0278
crowd	0.6234	0.5435	0.4606	0.0253	0.0241	0.0253	0.0227

.

4.4. NeRF Mapping

This section provides a comprehensive evaluation of the proposed NeRF-based map construction method. The datasets used include the TUM high-dynamic sequences, the BONN moving-camera sequences, and a self-collected dynamic sequence. The point cloud maps without dynamic feature removal are shown in Figure 11.

The dense point clouds, octree maps, and NeRF-based maps after dynamic objectremoval are presented in Figure 12.

The dense point clouds, octree maps, and NeRF-based maps after dynamic object removal are shown in Figure 12. In the NeRF-based maps, the red lines represent the camera trajectory. For the self-collected dataset, the trajectory is unavailable due to the lack of ground-truth camera poses, and thus the red trajectory is absent.

4.5. Real-Time Experiments

To further evaluate the operational efficiency of our algorithm, we compared its real-time performance with several leading dynamic SLAM methods, focusing specifically on the average tracking time. The evaluation results are presented in

Table 7. Real-time comparison.

Arithmetic	GPU	Average Tracking Time/ms
ORB-SLAM3	RTX 4060 Ti	13–16
DS-SLAM [23]	P4000	>65
DM-SLAM [55]	GTX 1080Ti	>201
DynaSLAM [12]	Tesla M40	>300
BY-SLAM [56]	RTX 3080Ti	48.6–52.3
OURS	RTX 4060 Ti	41.9–58.4

.

5. Conclusions

In this paper, we present a highly robust visual SLAM system tailored for dynamic scenes. The proposed framework exhibits superior feature extraction and matching performance under challenging conditions, including low-texture regions, weak illumination, and viewpoint jitter. By effectively suppressing the influence of dynamic objects, our method significantly enhances both pose estimation accuracy and the structural completeness of reconstructed maps. Comprehensive evaluations on the TUM RGB-D, BONN RGB-D, and a custom dataset demonstrate substantial gains in key metrics such as RMSE, mean, median, and standard deviation. Compared to ORB-SLAM3, our approach achieves an average RMSE reduction of 93.4%, with notable improvements across all evaluated metrics. Furthermore, while other state-of-the-art dynamic SLAM systems attain average RMSE values of 0.0413 on the TUM dataset and 0.0489 on the BONN dataset, our method achieves 0.0208 and 0.0376, respectively, corresponding to accuracy improvements of 49.6% and 23.1%. These results highlight not only the enhanced precision but also the robustness and adaptability of our system in highly dynamic and complex environments.

However, our current system is primarily evaluated on indoor datasets and may not generalize well to large-scale outdoor environments or scenarios involving rapid motion. To address these limitations, future work could focus on integrating additional geometric features, such as line and planar constraints, to improve map accuracy in structured environments. Incorporating multi-sensor fusion, including LiDAR, IMU, and event cameras, would likely enhance robustness and scalability under challenging outdoor or fast-motion conditions. Furthermore, exploring advanced 3D representations, such as Gaussian or neural implicit models, could enable more detailed and efficient scene reconstruction, balancing high-fidelity mapping with real-time performance. In addition, optimizing NeRF data and developing lightweight neural representations could reduce computational and memory overhead, making high-resolution, real-time scene reconstruction more practical for large-scale or resource-constrained environments.