GOFusion: Real-Time Gaussian-Occupancy Submap Fusion for Fisher-Informed Autonomous Robot Navigation

Introduction

Autonomous robots need maps that support safe motion, reliable localization, and visual understanding in unknown environments. Occupancy maps [1, 2, 3] distinguish between free, occupied, and unknown space so that planners can check collisions, extract frontiers [4], and generate paths in large environments [5]. Such maps, however, encode geometry alone and discard appearance, whereas advanced tasks such as inspection and human-robot interaction require detailed scene appearance.

Radiance field map representations address this limitation, either by implicitly encoding the scene in a neural network [6] or by explicitly optimizing Gaussian primitives via 3D Gaussian Splatting (3DGS) [7]. While the former relies on dense per-ray sampling of an implicit field and therefore remains costly to train and query, 3DGS supports efficient rendering

via rasterization of an explicit set of primitives and is therefore better suited to online mapping. However, vanilla 3DGS maps describe only observed surfaces and do not distinguish free space from potentially occupied space, which is unsafe for robot navigation.

In principle, combining occupancy and Gaussian maps yields a complementary hybrid representation, in which an occupancy layer supports free-space reasoning, completeness assessment, and planning, while a Gaussian layer provides high-fidelity appearance. However, existing systems realize only half of this potential. GSFusion [9] and GPS-SLAM [10] exploit this coupling in one direction, predominantly using the geometric map to improve the reconstruction quality and efficiency rather than to support robot localization and navigation. Therefore, a hybrid representation that directly supports navigation remains an open challenge.

To address this challenge, we propose GOFusion, a real-time hybrid Gaussian-and-occupancy mapping system for autonomous robot navigation. GOFusion is built directly on a real-time visual-inertial SLAM system, OKVIS2-X [11], and inherits its state estimates and occupancy submaps. However, unlike previous reconstruction-oriented methods, we close the loop between the two map layers. While the occupancy submaps anchor and initialize the Gaussians, photometric optimization of 3DGS, in turn, refines the camera poses, thereby reducing pose jitter and improving map consistency. Our submap-local design keeps online optimization scalable, since trainable states are maintained only for active submaps. Beyond geometry and appearance, we further accumulate Fisher information from the Gaussian primitives to identify poorly-constrained map regions, providing an information-theoretic heuristic for trajectory planning that enables the robot to actively complete its own map. Figure 1 presents the performance of our method compared to various baselines.

E-mail addresses: {first.secondname}@tum.de

To our knowledge, GOFusion is the first hybrid Gaussian-occupancy mapping system that supports real-time 3D navigation outdoors from cameras and an IMU alone. The contributions of this paper are:

1. A submap-based 3D Gaussian representation for large-scale high-fidelity mapping that supports appearancedependent tasks such as inspection and teleoperation alongside navigation, where SLAM pose-graph updates, including loop closures, also directly update both the occupancy and Gaussian layers.

2. A rasterizer-integrated online Fisher approximation that maintains a diagonal, accumulated Fisher information over all Gaussians at negligible cost. Serving as an information heuristic for robot exploration, it highlights another key methodological advantage of Gaussian mapping in robotics.

3. A real-time navigation framework that integrates visual-inertial SLAM with our hybrid map, deployable either fully onboard or split across onboard and offboard compute for resource-limited platforms.

4. Real-world UAV experiments demonstrate GOFusion’s online capabilities and how Fisher information can be used in Gaussian pruning and next-best-view selection.

Related Work

Volumetric Mapping for Robot Navigation

Volumetric representations have dominated robot mapping for decades. Occupancy maps [1] explicitly distinguish free, occupied, and unknown space, supporting collision checking, frontier extraction [4], and navigation under partial observation [12]. Truncated signed distance function (TSDF)- and signed distance field (SDF)-based systems such as [13, 14] instead target continuous surface reconstruction. They encode distance to the nearest observed surface, so unobserved volume is not separated from free space by the representation itself and must be handled by convention. Octree frameworks such as [3] improve scalability through hierarchical subdivision. These methods scale in space but not in time, since a globally parameterized map must be re-optimized whenever loop closure revises past poses.

Submap-based SLAM resolves this issue by integrating measurements into local maps, whose poses are frequently updated during graph optimization, improving global map consistency across all maps. This concept lends itself to exploration in large environments, where local submaps enable efficient updates while still supporting global planning [5]. OKVIS2-X [11] follows this direction for multi-sensor state estimation with occupancy submapping and submap alignment. Because pose corrections act at the submap level, the occupancy map remains directly available for planning throughout.

These advantages, however, concern geometry alone. As occupancy quantifies uncertainty about space, not appearance, a surface can be reliable for collision avoidance yet unusable for inspection or human-robot collaboration.

Gaussian Mapping for Robot Navigation

A more recent line of work in mapping replaces volumetric structures with explicit, editable, prunable, and rigidly transformable Gaussian primitives. Moreover, they are also differentiable under a fast rasterizer. Supervision is derived directly from image intensities, so every pixel contributes a residual [7]. Dense visual SLAM systems exploit this to jointly optimize camera poses and Gaussian primitives [15, 16], or to embed Gaussians in online pipelines through selective primitive updates, conventional frontends, and RGB-D alignment [17, 18, 19]. Others pair Gaussian maps with dedicated planners or semantic objectives for closed-loop navigation [20, 21]. Hybrid systems go one step further: previous work [9, 10] use TSDF geometry to guide Gaussian insertion and suppress redundant primitives, although the geometry serves reconstruction rather than a trajectory planner.

At the robot scale, Gaussian SLAM faces two further obstacles. A single global Gaussian map carries optimizer states, gradients, and rendering buffers that grow with scene size, and, once built, cannot easily adopt pose corrections. LoopSplat [22] addresses the second by organizing Gaussians into submaps that loop closure can rigidly transform, while Disk-ChunGS [23] addresses the first with disk-backed chunking. Neither, however, maintains an occupancy representation for downstream robotic tasks.

Uncertainty-Aware Mapping for Robot Navigation

Mapping to support real-world robot navigation, however, requires more than geometry and appearance, since the robot must also decide where to go next. Frontier-based exploration [4, 5] exposes unknown regions, but is blind to observed regions where the appearance model remains poorly constrained. Neural and Gaussian methods therefore study uncertainty-aware view selection, using Fisher information [24] or related visibility and information-gain signals [25, 26] to improve reconstruction quality. A second line keeps uncertainty inside the estimator, reweighting tracking, registration, and loop constraints [27].

Closest to our setting, $\mu$SLAM [28] maintains a per-primitive confidence and plans on an occupancy grid projected from its Gaussian field. Its uncertainty never enters the planner, and the projected grid supports no planning beyond the ground plane. None of these systems, however, couples map uncertainty with the free-space reasoning required for real-time robot exploration. This motivates GOFusion’s unified hybrid map representation that keeps Gaussian optimization local to the active submap while exposing a per-primitive uncertainty for downstream decisions.

Method

Throughout this paper, we denote the world frame and the local frame of a local-occupancy map $O_m$ by $\mathcal{F}_W$ and $\mathcal{F}_{O_m}$, respectively, and a transformation $T_{AB} \in SE(3)$ represents the rigid transform from $\mathcal{F}_B$ to $\mathcal{F}_A$. ${}^{A}p$ denotes a point $p$ in its reference frame $\mathcal{F}_A$.

Targeting real-world robot navigation, we build GOFusion on top of the real-time visual-inertial SLAM system, OKVIS2-X [11]. Our mapping system takes as input its $M$ local-occupancy maps $\mathcal{O} = \{O_m\}_{m=1}^{M}$ with their corresponding pose estimates $T_{WO_m}$, together with rectified RGB and depth images, as illustrated in Figure 2. Here, $\mathcal{F}_{O_m}$ coincides with the pose of the anchoring keyframe of the local-occupancy map. Loop-closure correction and local map alignment run in parallel, keeping the local-occupancy maps consistent at runtime.

Hybrid Occupancy-Gaussian Mapping

In GOFusion, we define the complete map as a collection of hybrid submaps as:

where we introduce the submap frame $\mathcal{F}_{S_m} \equiv\mathcal{F}_{O_m}$, the origin for both, the local-occupancy map $O_m$ as well as corresponding Gaussian primitives $G_m$. Additionally, the matrix $\hat{H}_m$ stores their accumulated Fisher approximation (see Sec. III-D).

We parameterize the $i$-th Gaussian primitive $g_i \in G_m$ as

where $\mu_i \in\mathbb{R}^{3}$ and $q_i \in\mathbb{R}^{4}$ denote the center and the rotation quaternion of the Gaussian primitive in the local frame $\mathcal{F}_{S_m}$. $s_i \in\mathbb{R}^{3}$ and $\omega_i$ represent the log-scales and the opacity logit, while $f_i^{\mathrm{dc}} \in\mathbb{R}^{3}$ and $f_i^{\mathrm{rest}} \in\mathbb{R}^{45}$ are the degree-3 spherical-harmonic color coefficients as in [7].

Our submap-local parameterization applies loop-closure correction or 3DGS pose refinement (see Sec. III-C) directly to the submap poses $T_{W S_m}$, leaving the Gaussian parameters untouched. These pose updates propagate to the local-occupancy map and its Gaussian primitives without re-optimization. For instance, the center ${}^{S_m}\mu_i$ of the $i$-th Gaussian primitive maps to the world frame as ${}^{W}\mu_i = T_{W S_m}{}^{S_m}\mu_i$. Thus, 3DGS optimization remains local to the active submap, keeping only one submap in a trainable state and limiting GPU memory usage as the scene grows.

Occupancy-Guided Gaussian Initialization

To improve the efficiency of 3DGS initialization, we adopt the quadtree image decomposition from [9] and extend it with a dual-threshold criterion. A tree node is subdivided either when its interior contrast is high or when the contrast against its surrounding band is high, capturing boundaries that the interior test alone would miss. As shown in Figure 3, our dual-threshold criterion produces additional finer subdivisions around image structures that are not split by the original criterion. Further, using summed-area tables enables $O(1)$ rectangle-sum queries, avoiding repeated pixel scans during quadtree segmentation and significantly reducing computation time.

This approach results in a set of leaf nodes $\Psi$, where each element $\psi_i = (u_i, d_i)$ with pixel center $u_i$ and depth $d_i$ proposes at most one Gaussian primitive via back-projection:

which uses the camera pose estimate $T_{W C_t}$ at time $t$ to express the current camera pose in the submap frame:

Out of these Gaussian primitive proposals, GOFusion accepts only candidates whose occupancy voxel in the current active local-occupancy map $O_m$ has integration weight one:

where $w_{O_m}(\cdot)$ returns the weight of the voxel corresponding to ${}^{S_m}\mu_i$, restricting insertion to newly observed occupied voxels and avoiding redundant primitives. The accepted proposal is initialized as a flattened anisotropic 3D Gaussian to fit the surface geometry. Its local $z$-axis is aligned with the depth normal and scaled to $\exp(s_{i,z}) = 5 \times10^{-6}\,\mathrm{m}$, while the in-plane scales follow the quadtree footprint.

Joint Gaussian-Pose Refinement

During online mapping, GOFusion optimizes the Gaussian parameters while keeping the camera poses from [11] fixed during each mapping optimization. Joint Gaussian-pose refinement is performed at the final global 3DGS optimization stage as in [9]. All Gaussian submaps are then transformed into the world frame and merged into $\mathcal{G}$. At refinement iteration $k$, the merged Gaussian map is rendered as

where $\mathcal{R}(\cdot)$ is the differentiable Gaussian rasterization and $K$ is the camera intrinsics. The pose prior $\bar{T}_{C_tW} = T_{W C_t}^{-1}$ is held fixed during optimization, while the left perturbation $\Delta T_t^k$, initialized with $\Delta T_t^0 = I_4$, is refined jointly with the Gaussian parameters. We implement our CUDA rasterizer following prior work [16].

The $L_1$ photometric loss

forms the basis of our mapping objective, which we can optionally extend with depth and normal supervision as

where $\lambda_D = 0.1$ and $\lambda_N = 0.15$ are the empirically chosen weights. The depth and normal terms are

where $\Omega_{D,t}$ and $\Omega_{N,t}$ are the valid pixel sets for depth and normal supervision. $d_u$ and $\mathbf{n}_u$ denote the input depth and its derived unit normal, and $\hat{d}_u$, $\hat{\mathbf{n}}_u$ the rendered depth and composited normal. The accumulated pixel opacity $\hat{\alpha}_u$ from the current rendering is detached in the normal loss.

Following the pose optimization strategy in [16], we obtain the pose increment $\delta\xi_t \in\mathbb{R}^6$ by backpropagating $\mathcal{L}_{\mathrm{map},t}$ through $\mathcal{R}(\cdot)$ and update the perturbation as in [11].

The joint Gaussian-pose optimization keeps residual pose errors out of the Gaussian parameters. As a final step, we merge all submaps and refine the Gaussian parameters together with per-keyframe pose increments over the global map.

Rasterized Gaussian-Map Fisher Approximation

During 3DGS optimization in Sec. III-C, we accumulate a per-primitive image sensitivity, which measures how strongly the rendered mapping views constrain that primitive. Under homoscedastic Gaussian noise, this sensitivity equals the per-primitive Fisher information up to the noise scale [24, 30]. We use it as an uncertainty measure over the Gaussian map.

However, computing the Fisher matrix across the full primitive state $\mathbf{g}_i \in\mathbb{R}^{59}$ in (2) is prohibitive in both memory and computation at map scale. We therefore use a diagonal approximation and restrict the parameter set of the $i$-th Gaussian primitive to

where $\bar{\alpha}_i = (1 + \exp(-\omega_i))^{-1}$ is the per-primitive opacity obtained by applying the sigmoid function to the opacity logit $\omega_i$, as in 3DGS [7].

For Gaussian primitive $i$, we obtain the diagonal Fisher matrix entries by summing the diagonal Gauss-Newton contributions over RGB channel indices $c \in\{1,2,3\}$ and pixels $u \in\hat{I}_t$ of each rendered image view $v \in\mathcal{V}$ as

which reduces to an elementwise square of $\mathbf{J}$. In (11), we use the standard front-to-back alpha compositing of Gaussian splatting,

where $\mathcal{A}_v(u)$ is the depth-ordered set of primitives contributing to pixel $u$, $a_{i,u} = \bar{\alpha}_i \Phi_i(u,\boldsymbol{\mu}_i)$ the opacity of primitive $i$ at that pixel with its projected Gaussian $\Phi_i(\cdot)$. $\tau_{i,u}$ denotes the accumulated transmittance, as in [7].

However, evaluating (11) requires the channel-wise Jacobians of every primitive contributing to a pixel. We instead reuse the rasterizer forward buffers and the existing backward pass, seeding the Fisher branch with the upstream gradient pattern $(1,1,1)$ for every rendered RGB pixel. The resulting vector-Jacobian product returns the channel-summed sensitivity of each reduced parameter directly, so that for a rendered mapping view $v$ we accumulate

with the elementwise square $(\cdot)^{\circ2}$. Summing the channels before squaring yields the exact diagonal Fisher of the channel-summed observation $\sum_c \hat{I}_{v,c}$ under homoscedastic noise up to a constant scale. We therefore use $\tilde{h}_{v,i}^m$, the $i$-th row of the Fisher matrix $\hat{\mathbf{H}}_v^m \in\mathbb{R}^{|\mathcal{G}_m|\times4}$, as a lightweight relative-sensitivity proxy of the Fisher information and evaluate it in Sec. IV-D.

Because the Gaussian parameters change during optimization, their sensitivities accumulated from earlier views become stale. We therefore smooth the Fisher information $\hat{\mathbf{H}}_v^m$ of each rendered view $v$ over a subset of its past keyframes $v' \in\mathcal{V}^{\mathrm{samp}}$ randomly sampled from all stored historical views $\mathcal{V}^{\mathrm{hist}}$ of the active submap $\mathcal{M}_m$ as

Finally, we update the accumulated Fisher approximation $\hat{\mathbf{H}}_m$ in (1) for all primitives in $\mathcal{G}_m$ as

where $\eta= 0.2$ is empirically selected in this work. New primitives enter with a zero row, and we initialize $\hat{\mathbf{H}}_m = 0$ when a Gaussian submap is created.

Fisher-Informed Gaussian Pruning and View Selection

Using the accumulated Fisher information $\hat{\mathbf{H}}_m$ in Sec. III-D, we derive a relative uncertainty score per Gaussian primitive and show that it can be used for two different objectives: at the primitive level, the score prunes persistently unconstrained primitives, while it also identifies poorly constrained regions aggregated over space, and guides next-best-view selection (see Sec. IV-D2 for more practical details).

Weakly-Constrained Gaussian Primitive Pruning

1. Weakly-Constrained Gaussian Primitive Pruning: Inspired by [30], we combine the position and opacity Fisher information as a coverage heuristic to prune weakly-constrained Gaussian primitives. Using the log-scale $s_i$ in (2) and opacity $\bar{\alpha}_i$ in (10), we define $A_i = \left(\frac{1}{3}\sum_{\ell\in\{x,y,z\}}\exp(s_{i,\ell})\right)^2$, where

$s_{i,l}$ denotes the log-scale along principal axis $l$ of Gaussian $i$. The squared mean scale $A_i$ serves as an area-averaging, view-independent supporting metric, so that $\bar{\alpha}_i A_i$ approximates the view coverage. The resulting importance score of each Gaussian primitive is

with $\beta_i = \log(1 + A_i \sum_{j \in\{x,y,z\}} \hat{H}_{i,j})$, $\gamma_i = \log(1 + \bar{\alpha}_i \hat{H}_{i,\alpha})$, and $\delta_i = \log(1 + \bar{\alpha}_i A_i)$, where $r(\cdot) \in[0,1]$ maps each term to its rank percentile among all primitives in the submap, placing the three terms on a common scale before weighting, and $\lambda_\alpha$ weights the opacity term. The logarithm keeps the terms in a numerically stable range. Here, $\beta_i$ and $\gamma_i$ reward position and opacity information, while $\delta_i$ prevents large smooth surfaces from being over-pruned.

For a target pruning ratio $\rho\in[0,1)$, we partition the merged Gaussian map with a voxel grid and remove the lowest-scoring fraction $\rho$ of primitives in each voxel by ascending score $\chi_i$, keeping at least one primitive per voxel to preserve coverage in sparse regions. We evaluate this pruning strategy in Sec. IV-D1.

Next-Best-View Selection

2) Next-Best-View Selection: To select the next-best-view for robot navigation, we use Fisher information to favor views whose rendered images are most sensitive to the least-constrained Gaussian parameters. Let $\mathcal{M}^{\mathrm{query}} \subseteq\mathcal{M}$ denote the associated submaps used to score the query view $v$, and let $\hat{H}_{i,j}$ be the entry of $\hat{H}_m$ for primitive $i$ and component $j \in\{x,y,z,\alpha\}$, with the submap index omitted for readability. We use the regularized inverse $U_{i,j} = \frac{1}{\hat{H}_{i,j}+\epsilon}$ as a relative uncertainty score, where $\epsilon= 10^{-6}$ caps the score at $1/\epsilon$ for near-zero entries. Larger $U_{i,j}$ indicates weaker accumulated image constraints.

Consequently, we use this relative uncertainty score $U_{i,j}$ to weight the single-view Fisher information $\tilde{h}^{m}_{v,i}$ in (13) across all Gaussian primitives in $\mathcal{G}_m$ for a candidate view $v$. Following [24], we scale each component of $\tilde{h}^{m}_{v,i}$ by its corresponding inverse historical information to obtain the per-primitive relative information-gain score $\Gamma_i(v)$:

where $[\cdot]_j$ selects the $j$-th component of the corresponding parameter.

Across the queried submaps $\mathcal{M}_m \in\mathcal{M}^{\mathrm{query}}$, we compute $\Gamma(v) = \operatorname{mean}_{m,i:\Gamma_i(v)\ne0} \Gamma_i(v)$, then normalize it as $\Gamma(v) \leftarrow\Gamma(v)/(1+\Gamma(v))$ to obtain the final next-best-view score. In Sec. IV-D2, we demonstrate how this score guides view selection during autonomous drone exploration to refine the Gaussian map. We adopt the submap-based drone exploration framework [5], and augment its candidate-view utility by adding the normalized Fisher score $\Gamma(v)$ as a weighted term alongside its existing occupancy information gain. The planner then favors view candidates with a higher $\Gamma(v)$ and emits a collision-free path to the robot.

Experiment and Results

Experimental Setup

We evaluate the proposed method on two public datasets and a real-world flight, comparing against state-of-the-art baselines throughout. TUM RGB-D [31] provides real-world indoor sequences with motion-capture ground-truth trajectories, while the uHumans2 [8] offers larger-scale synthetic environments with dense ground-truth geometry. The flight experiments additionally demonstrate real-time exploration of unknown, larger-scale environments, with the proposed Fisher information guiding view selection to refine the reconstruction.

All experiments run on a workstation with an Intel Core Ultra 9-285K CPU, 96 GB of RAM, and an NVIDIA RTX 4090 GPU with 48 GB of VRAM, which also serves as the ground station for the outdoor flight¹. In the real-world experiment, we used a self-built quadcopter with a MicroStrain 3DM-GX5-25 IMU, a custom stereo rig with two ZED X One GS cameras, and a Jetson Orin NX with 16 GB of unified memory, running visual-inertial SLAM alongside a PX4 flight controller.

In contrast to the public datasets, which provide low-resolution RGB and depth images at 640 $\times$ 480, our outdoor-flight experiments use 1920 $\times$ 1200 images² at 15 Hz together with IMU measurements at 200 Hz. For DiskChunGS [23], we supply depth directly to bypass its stereo-depth network without loading or executing it.

Unlike several baselines that evaluate only on valid-depth regions, we compute peak signal-to-noise ratio (PSNR), structural similarity index measure (SSIM) and learned perceptual image patch similarity (LPIPS) over the full image for all methods, since regions without depth returns are still rendered. This is why our reproduced scores for some baselines fall below the numbers reported in their papers. We further measure absolute trajectory error (ATE) RMSE, the number of Gaussian primitives, and peak GPU VRAM usage. Mapping frames per second (FPS) (Mapp. FPS) reports mapping throughput and full-system FPS (Full-FPS) the full tracking-and-mapping pipeline, both excluding the post-SLAM refinement.

Evaluation of Mapping Quality

TUM RGB-D

1) TUM RGB-D: On TUM RGB-D [31], we first evaluate reconstruction quality using ground-truth camera poses to isolate Gaussian mapping from trajectory estimation. Numbers are averaged over ten runs across all scenes in Table I. Both GOFusion configurations, with and without depth and normal supervision, take the top two places on PSNR and LPIPS at competitive mapping FPS. Although our image decomposition produces more primitives than [9], the memory footprint grows far more slowly, with 5.3 times as many primitives at 0.9 times the VRAM. The reason our SSIM falls behind [15] is likely its D-SSIM loss term and a three-times-larger primitive count. Interestingly, depth and normal supervision trade a small drop in RGB scores for better geometric consistency.¹ and map completeness. We further discuss this observation in Sec. IV-C2.

Method	PSNR ↑	SSIM ↑	LPIPS ↓	Mapp. FPS ↑	#Gauss. ($10^{6}$) ↓	VRAM (GB) ↓
GS­Fusion [9]	20.23	0.708	0.357	18.17	0.10	2.1
RTG-SLAM [17]	18.47	0.708	0.470	10.64	0.31	2.4
GPS-SLAM [10]	18.78	0.652	0.393	103.7	0.51	8.8
PhotoSLAM [18]	21.30	0.748	0.205	34.57	0.11	1.2
GS-ICP SLAM [19]	18.92	0.688	0.304	30.02	1.47	2.2
SplaTAM [15]	19.45	0.801	0.336	2.40	1.91	3.9
Ours	21.84	0.754	0.192	32.86	0.53	1.9
Ours (+D/N)	<u>21.55</u>	0.748	0.194	31.35	0.52	3.2

uHumans2

In extension to Sec. IV-B1, we next evaluate our method against a comparable set of baselines on uHumans2 [8] as a full-mapping system with estimated camera poses, in which SLAM also affects reconstruction quality. As shown in Table II and Figure 1, our method leads on all rendering metrics across all four sequences and achieves the lowest ATE on the three long ones. Although we generate more Gaussian primitives, our memory footprint remains lower than that of [17] and [23]. This highlights the benefit of our system design that anchors occupancy and Gaussian primitives to share submap frames. Confining the optimization to the active submap guarantees GOFusion’s scalability and enables consistent reconstruction across large environments where several baselines fail to complete sequences or suffer from trajectory drift. As observed in Sec. IV-B1, adding depth and normal supervision during 3DGS optimization does not necessarily improve rendering quality, since it regularizes the reconstruction toward geometric consistency.

Seq.	Metric	RTG-SLAM [17]	GPS-SLAM [10]	Photo-SLAM [18]	GS-ICP SLAM [19]	LoopSplat [22]	DiskChunGS [23]	Ours	Ours (+D/N)
Apart. 49.4 m	PSNR ↑	26.04	14.79	20.27	23.67	25.24	29.15	33.09	<u>31.96</u>
Apart. 49.4 m	SSIM ↑	0.894	0.284	0.730	0.816	0.828	0.866	0.942	<u>0.928</u>
Apart. 49.4 m	LPIPS ↓	0.330	0.383	0.392	0.335	0.324	0.110	0.062	<u>0.076</u>
Apart. 49.4 m	Full-FPS ↑	9.66	42.35	57.13	10.62	0.59	10.50	35.23	30.54
Apart. 49.4 m	ATE ↓	0.007	0.140	0.139	1.581	0.046	0.016	0.015	0.014
Apart. 49.4 m	#Gauss. ($10^{6}$) ↓	0.14	0.35	0.31	2.61	4.50	0.18	0.69	0.69
Apart. 49.4 m	VRAM (GB) ↓	4.5	5.4	5.2	11.9	42.8	4.9	2.4	4.2
Office 264 m	PSNR ↑	22.64	GPU OOM	14.40	GPU OOM	CPU OOM	24.49	31.14	<u>29.26</u>
Office 264 m	SSIM ↑	0.813	GPU OOM	0.589	GPU OOM	CPU OOM	0.794	0.939	<u>0.910</u>
Office 264 m	LPIPS ↓	0.421	GPU OOM	0.631	GPU OOM	CPU OOM	0.263	0.053	<u>0.076</u>
Office 264 m	Full-FPS ↑	8.30	GPU OOM	46.89	GPU OOM	CPU OOM	12.90	<u>24.60</u>	21.51
Office 264 m	ATE ↓	0.219	GPU OOM	0.236	GPU OOM	CPU OOM	3.198	0.062	0.052
Office 264 m	#Gauss. ($10^{6}$) ↓	0.42	GPU OOM	1.92	GPU OOM	CPU OOM	0.39	2.31	2.32
Office 264 m	VRAM (GB) ↓	17.5	GPU OOM	40.7	GPU OOM	CPU OOM	8.3	6.3	10.8
Subway 508.7 m	PSNR ↑	23.11	GPU OOM	diverged	GPU OOM	CPU OOM	26.11	29.99	<u>28.27</u>
Subway 508.7 m	SSIM ↑	0.782	GPU OOM	diverged	GPU OOM	CPU OOM	0.780	0.902	<u>0.859</u>
Subway 508.7 m	LPIPS ↓	0.479	GPU OOM	diverged	GPU OOM	CPU OOM	0.223	0.085	<u>0.125</u>
Subway 508.7 m	Full-FPS ↑	7.76	GPU OOM	diverged	GPU OOM	CPU OOM	12.95	11.95	11.11
Subway 508.7 m	ATE ↓	0.504	GPU OOM	diverged	GPU OOM	CPU OOM	26.717	0.180	0.180
Subway 508.7 m	#Gauss. ($10^{6}$) ↓	0.56	GPU OOM	diverged	GPU OOM	CPU OOM	1.35	3.90	3.90
Subway 508.7 m	VRAM (GB) ↓	25.8	GPU OOM	diverged	GPU OOM	CPU OOM	22.8	9.1	13.5
Neighb. 337.8 m	PSNR ↑	19.75	GPU OOM	diverged	GPU OOM	CPU OOM	20.14	25.46	<u>24.35</u>
Neighb. 337.8 m	SSIM ↑	0.710	GPU OOM	diverged	GPU OOM	CPU OOM	0.661	0.829	<u>0.781</u>
Neighb. 337.8 m	LPIPS ↓	0.533	GPU OOM	diverged	GPU OOM	CPU OOM	0.387	0.163	<u>0.209</u>
Neighb. 337.8 m	Full-FPS ↑	5.77	GPU OOM	diverged	GPU OOM	CPU OOM	12.72	7.2	6.74
Neighb. 337.8 m	ATE ↓	8.721	GPU OOM	diverged	GPU OOM	CPU OOM	5.831	0.279	0.266
Neighb. 337.8 m	#Gauss. ($10^{6}$) ↓	0.35	GPU OOM	diverged	GPU OOM	CPU OOM	0.50	1.99	2.01
Neighb. 337.8 m	VRAM (GB) ↓	16.0	GPU OOM	diverged	GPU OOM	CPU OOM	8.7	4.9	7.4

Self-Collected Outdoor Flying Data

We benchmark all methods on 16 self-collected outdoor flight sequences³ with challenging real-world illumination. Table III reports the mapping performance in two settings. In the offline setting, all methods use camera poses from our SLAM output after bundle adjustment (BA)⁴, which are held fixed as pseudo-GT poses and also fixed during global 3DGS refinement. In the online setting, we report metrics obtained with live SLAM pose estimates and incremental 3DGS optimization before and after global 3DGS refinement. SLAM runs on the resource-limited onboard platform, while the 3DGS optimization was executed on a ground station.

Setting	Method	PSNR ↑	SSIM ↑	LPIPS ↓	#Gauss. ($10^{6}$) ↓	VRAM (GB) ↓
Offline	GS­Fusion [9]	24.23	0.701	0.443	0.40	7.7
Offline	RTG-SLAM [17]	15.85	0.478	0.693	0.46	8.6
Offline	GPS-SLAM [10]	7.19	0.125	0.970	0.31	14.3
Offline	PhotoSLAM [18]	23.35	0.642	0.524	0.36	6.1
Offline	GS-ICP SLAM [19]	22.36	0.758	0.267	2.92	17.5
Offline	LoopSplat [22]	CPU OOM	CPU OOM	CPU OOM	CPU OOM	CPU OOM
Offline	DiskChunGS [23]*	23.48	0.679	0.478	1.14	17.8
Offline	Ours	26.35	0.808	0.167	3.88	9.0
Offline	Ours (+D/N)	<u>26.04</u>	<u>0.801</u>	0.186	3.89	10.4
Online	Ours¹† (pre-global)	16.35	0.486	0.611	2.44	7.1
Online	Ours²† (post-global)	24.86	0.740	0.259	2.44	7.1
Online	Ours³† (post-global)	25.03	0.782	0.157	2.44	7.1

As in the previous sections, a similar conclusion on mapping performance can be drawn from the offline evaluation, with [22] and [23] additionally failing to complete all sequences. Our offline configuration with RGB-only supervision performs best on PSNR and LPIPS, as shown in Sec. IV-B1.

For online, real-time drone navigation, our method adaptively skips frames to avoid blocking, thereby consuming fewer frames than offline baselines. Despite this, it already surpasses most offline baselines in rendering quality with global 3DGS refinement across all submaps (i.e. post-global), whereas those baselines were evaluated offline with BA-refined poses. Under identical online conditions, it also surpasses most offline baselines in memory usage with BA-refined poses. Since our incremental 3DGS optimization (i.e. pre-global) runs only on the current submap to bound computation and keep the system real-time, the rendering quality drops but still exceeds [10, 17]. This is sufficient during flight, where navigation plans on the occupancy layer and view selection relies on Fisher information rather than on rendering fidelity (see Sec. IV-D). This quality gap closes after a few passes of global optimization.

In addition, we found that a larger Gaussian count, which

• DiskChunGS [23] only completed 12 of 16 runs due to GPU OOM.

† Live results with depth and normal supervision.

¹ With live SLAM poses and real-time, incremental 3DGS refinement (pre-global).

² With live SLAM poses and global 3DGS refinement (post-global).

³ With BA-refined poses and global 3DGS refinement (post-global).

In addition, we found that a larger Gaussian count, which results from denser keyframe selection and a finer occupancy resolution (e.g., 0.1 m), does not translate into a proportional memory cost, since offline GOFusion holds roughly ten times as many primitives as [18] at less than twice its VRAM.

Ablation Studies

Submapping and Joint Optimization

We study the submap-based map representation and joint Gaussian-pose optimization on uHumans2 [8], using only RGB supervision. As shown in Table IV, partitioning the map into submaps improves every rendering metric, slightly raises full-system FPS, and reduces peak memory, since only the active submap carries training buffers. Because each submap covers a small region, its local Gaussians stay consistent with the underlying geometry, where a global pose correction is applied to all of them at once. Besides, the joint optimization yields further gains across all rendering metrics at no cost in full-system FPS, and lowers the ATE of the single map but not of the submaps, whose poses are already well constrained by loop closure and submap alignment.

Metric	Single Map w/o. Joint Opt.	Single Map w. Joint Opt.	Multiple Submaps w/o. Joint Opt.	Multiple Submaps w. Joint Opt.
PSNR $\uparrow$	25.01	25.06	29.68	29.92
SSIM $\uparrow$	0.774	0.775	<u>0.898</u>	0.903
LPIPS $\downarrow$	0.274	0.269	<u>0.096</u>	0.091
ATE $\downarrow$	0.150	0.124	<u>0.134</u>	0.134
Full-FPS $\uparrow$	17.95	17.97	<u>19.60</u>	19.72
#Gauss. ($10^6$) $\downarrow$	0.60	<u>0.61</u>	2.23	2.22
VRAM (GB) $\downarrow$	15.7	15.7	<u>6.6</u>	5.7

Depth and Normal Supervision for 3DGS

We further investigate the impact of geometric supervision through depth and normals in (8). Figure 4 illustrates exemplary RGB renderings alongside their rendered normals from novel viewpoints on uHumans2 [8].⁵ Accordingly, depth and normal supervision consistently maintain surface geometry and substantially improve novel viewpoints, while the RGB renderings remain comparable. As discussed in [32], regularizing the 3DGS optimization toward geometric consistency prevents overfitting to the training-view appearance, which matters more for robot navigation than training-view rendering quality. However, this comes at the cost of a slight drop in rendering quality on the training views in our experiments, as shown in Table II. Consequently, the weights for depth and normal loss terms in (8) have to be carefully balanced.

Evaluation of Gaussian-Map Fisher Approximation

Pruning of Weakly-Constrained Gaussians

In this experiment, we evaluate the proposed online Gaussian-map Fisher approximation as a pruning heuristic to remove weakly constrained Gaussians (see Sec. III-E), comparing rendering quality before and after pruning on four uHumans2 sequences [8]. We evaluate our pruning heuristics against two baseline pruning scores: a random pruning strategy that replaces the entries of $\hat{\mathbf{H}}_m$ in (15) with random values from a fixed seed, and an offline score recomputed over all keyframes after merging the submaps as in [30], which serves as the reference pruning strategy.

Figure 5 shows rendering quality as a function of the pruning ratio during online Gaussian mapping. Our online Gaussian pruning using the proposed Fisher approximation achieves pruning quality comparable to the offline reference, while both clearly outperform the random baseline as pruning becomes more aggressive. Since the offline reference is only available after the session ends, our online Fisher-based heuristic offers a practical alternative for Gaussian pruning.

Next-Best-View Selection

We then show that the Gaussian-map Fisher approximation can also select the next-best-view for map refinement in a real-world autonomous flight, while the occupancy map supports collision-free path planning. To achieve the best mapping performance, the visual-inertial SLAM runs onboard, while the ground station maintains the hybrid map and evaluates candidate views off-board. Figure 6 provides a scene overview while the drone was transiting between two next-best-view candidates.

To examine how a selected view improves reconstruction, we compare maps reconstructed from observations accumulated before and after its visit, using the same fixed final estimated trajectory. Both maps are rendered from the same candidate camera pose and intrinsics.

As shown in Figure 7, the visit improved both local detail and reconstruction completeness. The displayed high-response regions in the Fisher uncertainty map also become more localized, with remaining responses concentrated around vegetation and object boundaries. These qualitative results support the ability of Fisher-informed next-best-view selection to identify informative views that improve 3DGS reconstruction quality and reduce map uncertainty.

Conclusion

We present GOFusion, a hybrid mapping method that anchors 3D Gaussians to local-occupancy submaps from visual-inertial SLAM to support real-time robot navigation. Beyond spatial awareness for path planning and high-fidelity appearance, it enables Fisher-guided Gaussian pruning and next-best-view selection. Across our extensive evaluations and a real-world autonomous flight, GOFusion achieves higher rendering quality than existing Gaussian SLAM systems with bounded GPU memory usage and successfully completes sequences that several baselines fail to complete.

However, our method still assumes accurate and robust depth estimation, requiring careful tuning of the depth and normal supervision during 3DGS optimization. To maintain the computational efficiency on resource-constrained devices, optimizing one submap at a time limits the online rendering quality where neighboring submaps overlap or are misaligned, which would become more pronounced in semi-static or dynamic environments. Future work will incorporate depth uncertainty into the mapping objective, extend the optimization across neighboring submaps, and use semantic cues to handle dynamic environments.

Acknowledgments

OpenAI Codex and ChatGPT assisted with experimental code development, experiment execution, and language polishing. The authors take full responsibility.

This work was funded by the Technical University of Munich (MIRMI Seed Fund), supported by Huawei Technologies.

The authors thank Dr. Massimiliano Maule, Hongjia Su, Dr. Xueliang Shi, Joseph Eichinger, Dr. Xueli An, and Lei Lu from Huawei Technologies for their support.