Memory-Efficient 3D LiDAR Graph SLAM for Ballast Water Tank Inspection Robots Using Robust Hierarchical Bundle Adjustment and a Kaczmarz Backend

1. Introduction

Ship ballast water tanks, double-bottom compartments, cofferdams, and similar enclosed structures are among the most demanding locations for structural inspection. They are typically dark, Global Positioning System (GPS)-denied, geometrically repetitive, and accessible only through narrow hatches or manholes. Corrosion products, deteriorated coatings, poor ventilation, limited communication, and slippery or contaminated surfaces further increase the risk and duration of manual inspection. Autonomous or remotely supervised robots can reduce human exposure while producing spatially registered point clouds, images, and condition-monitoring records for engineering assessment [1,2,3].

Reliable navigation in these environments cannot rely solely on nominal design information. Even when computer-aided design drawings and construction records are available, the as-built or in-service geometry may differ because of fabrication tolerances, welding distortion, thermal deformation, coating accumulation or loss, corrosion, repair, retrofitting, temporary equipment, and undocumented obstacles. The robot must therefore update its spatial representation from onboard observations rather than treat the design model as an exact navigation map. Three-dimensional (3D) LiDAR-based simultaneous localization and mapping (SLAM) is well suited to this task because it jointly estimates the sensor trajectory and the surrounding structural geometry [4,5].

Modern LiDAR SLAM systems commonly separate high-rate odometry or scan registration from lower-rate mapping and graph optimization. LiDAR Odometry and Mapping (LOAM) established an influential odometry-and-mapping decomposition [6], while LiDAR–inertial odometry via smoothing and mapping (LIO-SAM) incorporated inertial preintegration, keyframes, and loop-closure factors within a smoothing framework [7]. Hierarchical LiDAR bundle adjustment improves large-scale consistency by decomposing the mapping problem into local optimization windows and higher-level pose constraints [8]. Ballast water tanks, however, present failure modes that are less prominent in general environments: long planar surfaces weakly constrain motion in particular directions, repetitive stiffeners create ambiguous correspondences, narrow passages cause abrupt changes in visibility, and vibration or contact can introduce transient motion distortion. A single erroneous local registration can therefore produce a large pose update that contaminates later keyframes and global constraints.

Graph SLAM backends formulate poses and measurements as a nonlinear least-squares problem. Square Root SAM, iSAM, iSAM2, and g2o show that sparse factorization and incremental graphical inference can solve these problems efficiently [9,10,11,12]. Elimination-based solvers must nevertheless retain factorization structures. As graph connectivity and loop-closure density increase, elimination can introduce fill-in: entries that are zero in the original sparse Jacobian become nonzero in the resulting factors [13,14,15]. Reordering can reduce fill-in, but it does not eliminate the need to construct and store factorization-related data.

This memory growth is operationally significant on compact inspection robots. The NVIDIA Jetson Orin Nano Super Developer Kit, for example, provides 8 GB of low-power double data rate 5 (LPDDR5) memory and a nominal 7–25 W power range [16]. The same physical memory is shared by the operating system, robotics middleware, LiDAR packet buffers, sensor drivers, point-cloud filtering, scan registration, local-map storage, inspection perception, logging, and graphics processing unit (GPU) workloads. A backend that is practical on a workstation can therefore become the peak-memory bottleneck in a sealed, thermally constrained robotic platform.

Iterative sparse solvers provide alternatives to direct factorization. Conjugate-gradient and preconditioned conjugate-gradient (PCG) methods can be efficient when the linear system and preconditioner are favorable, whereas least-squares QR (LSQR) and least-squares minimal-residual (LSMR) methods operate directly on sparse least-squares systems [17,18,19,20]. Kaczmarz methods form a distinct row-action family in which each iteration projects the current estimate toward the hyperplane defined by a selected row [21]. Randomized row selection offers expected convergence guarantees for suitable consistent systems, and weighted or block variants extend the design space [22,23,24]. The present study does not assume that Kaczmarz is universally faster or more accurate than Cholesky, PCG, LSQR, or LSMR. Its relevance here is the row-wise access pattern: an update can be executed from a compressed sparse row (CSR) representation without explicitly forming the normal equations, a Cholesky factor, or a transpose cache.

Accordingly, this study develops a system-level SLAM architecture for resource-constrained marine inspection rather than a new mathematical variant of the Kaczmarz method. The architecture combines robust local hierarchical bundle adjustment (HBA), compressed local maps, row-wise global optimization, and memory-aware operating policies. An 8 GB-class edge computer is used as the deployment reference; however, the reported experiments establish architectural feasibility rather than a completed real-time Jetson implementation. The principal contributions are as follows:

• A robust local HBA frontend is developed for repetitive and locally degenerate ship-interior geometry by combining residual-adaptive weighting, pose-step clamping, damping, and soft fallback.
• A factorization-free global backend is formulated directly on the whitened sparse least-squares system and solved through CSR-based row projections without explicitly forming the approximate Hessian or a Cholesky factor.
• Local-map compression, keyframe regulation, and optimization-range control are co-designed with the numerical backend to bound the problem presented to the solver.
• The complete architecture is evaluated on NTNU Ballast Water Tank missions 1–3 using absolute and path-normalized trajectory errors.

2. Materials and Methods

2.1. System Architecture and Onboard Design Objective

The pipeline comprises six stages: (i) LiDAR acquisition and geometric feature extraction; (ii) initial LiDAR odometry; (iii) robust local HBA over overlapping windows; (iv) keyframe and local-map compression; (v) factor-graph assembly and CSR linearization; and (vi) row-wise Kaczmarz optimization under memory-aware control. The frontend produces an initial pose sequence and geometric correspondences. Consecutive scans are grouped into overlapping local windows, and their poses are refined jointly. The optimized local poses and compressed submaps then provide odometry, submap, and loop-closure constraints for the global graph. Before each global solve, the memory controller evaluates the keyframe and factor counts, the number of nonzero Jacobian entries, point-cloud storage, and current process memory. The backend subsequently executes a prescribed budget of Kaczmarz row projections. Figure 1 summarizes the complete architecture.

The design does not assume that the full physical memory of the edge computer is available to graph optimization. A safety margin must remain after accounting for the operating system, middleware, sensor and frontend buffers, inspection and perception modules, map storage, and temporary allocations. Memory efficiency is therefore treated as an end-to-end operating constraint rather than solely as a solver-level metric.

2.2. Robust Hierarchical Bundle Adjustment Frontend

2.2.1. Local Window Formulation

Let the ordered keyframe poses belong to the special Euclidean group $\mathrm{SE}\left(3\right)$:

$$\mathcal{T}=\left\{{\mathbf{T}}_1,{\mathbf{T}}_2,\dots ,{\mathbf{T}}_N\right\},{\mathbf{T}}_i\in \mathrm{SE}\left(3\right).$$

(1)

The trajectory is divided into overlapping local windows

$${\mathcal{W}}_q=\left\{i_q,i_q+1,\dots ,i_q+n_w-1\right\},$$

(2)

where $n_w$ is the local window size. The overlap preserves geometric continuity between adjacent submaps and enables constraints to propagate through the hierarchy.

For a geometric correspondence k in window ${\mathcal{W}}_q$, let ${\mathbf{r}}_k$ denote a point-to-plane, point-to-line, or feature residual, and let ${\Omega }_k$ be its information matrix. The robust local objective is

$$\underset{{\left\{{\mathbf{T}}_i\right\}}_{i\in {\mathcal{W}}_q}}{arg\; min}\sum _{k\in {\mathcal{C}}_q}{w}_k{\mathbf{r}}_k^{\top }{\Omega }_k{\mathbf{r}}_k,$$

(3)

where ${\mathcal{C}}_q$ is the correspondence set and $w_k\in [w_{min},1]$ is a dynamic reliability weight.

2.2.2. Residual-Dependent Weight Reduction

Ballast-tank scans can contain large residuals because of repeated stiffeners, partially observed surfaces, abrupt visibility changes, or motion distortion. Rejecting every large residual can also discard temporarily informative constraints. The frontend therefore reduces residual influence progressively. Let

$$s_k=\sqrt{{\mathbf{r}}_k^{\top }{\Omega }_k{\mathbf{r}}_k}$$

(4)

be the normalized residual magnitude. A robust threshold is obtained from the residual median and median absolute deviation:

$${\tau }_1=median\left(\left\{s_k\right\}\right)+\kappa MAD\left(\left\{s_k\right\}\right),{\tau }_2=\gamma {\tau }_1,\gamma >1.$$

(5)

The residual weight is defined as

$$w_k=\left\{\begin{array}{cc}1,\hfill & s_k\le {\tau }_1,\hfill \\ {\displaystyle \frac{{\tau }_1}{s_k}},\hfill & {\tau }_1<s_k\le {\tau }_2,\hfill \\ w_{min},\hfill & s_k>{\tau }_2.\hfill \end{array}\right.$$

(6)

Thus, nominal constraints retain full influence, intermediate residuals are smoothly down-weighted, and strong outliers retain only a small bounded influence. After linearization, the weighted local system becomes

$$\underset{\delta \xi }{min}{∥{\mathbf{W}}^{1/2}\left(\mathbf{J}\delta \xi +\mathbf{r}\right)∥}_2^2,$$

(7)

where $\delta \xi$ stacks the local pose increments.

2.2.3. Damping and Pose-Step Clamping

Repeated planar geometry can leave some motion directions weakly observable and make the local system ill-conditioned. A damped update is therefore computed as

$$\left({\mathbf{J}}^{\top }\mathbf{W}\mathbf{J}+\mu \mathbf{I}\right)\delta \xi =-{\mathbf{J}}^{\top }\mathbf{W}\mathbf{r},$$

(8)

where $\mu >0$ is increased when the objective fails to decrease or when an excessive update is detected.

For each pose increment

$$\delta {\xi }_i={\left[\begin{array}{cc}\delta {\mathbf{t}}_i^{\top }& \delta {\theta }_i^{\top }\end{array}\right]}^{\top },$$

(9)

the translational and rotational components are clamped independently:

$$\delta {\mathbf{t}}_i^c=\delta {\mathbf{t}}_{i}min\left(1,{\displaystyle \frac{t_{max}}{\parallel \delta {\mathbf{t}}_i{\parallel }_2+ϵ}}\right),$$

(10)

$$\delta {\theta }_i^c=\delta {\theta }_{i}min\left(1,{\displaystyle \frac{{\theta }_{max}}{\parallel \delta {\theta }_i{\parallel }_2+ϵ}}\right).$$

(11)

This clamping limits the influence of an unstable linearization and keeps each update within a scale compatible with physically plausible inter-frame motion.

2.2.4. Soft Fallback

A local solution is flagged as unreliable when the objective increases, the inlier ratio falls below a threshold, scan overlap becomes insufficient, or repeated clamping is required. An abrupt return to the pre-optimization pose can create a trajectory discontinuity. The soft fallback instead interpolates between the predicted pose ${\mathbf{T}}_{\mathrm{pred}}$ and the locally optimized pose ${\mathbf{T}}_{\mathrm{opt}}$:

$${\mathbf{T}}_{\mathrm{app}}={\mathbf{T}}_{\mathrm{pred}}Exp\left(\alpha Log\left({\mathbf{T}}_{\mathrm{pred}}^{-1}{\mathbf{T}}_{\mathrm{opt}}\right)\right),0\le \alpha \le 1.$$

(12)

A high-confidence solution uses $\alpha \approx 1$, whereas a low-confidence solution is applied conservatively using a smaller value of $\alpha$.

2.2.5. Local-Map Compression

After local optimization, the point clouds in window ${\mathcal{W}}_q$ are transformed into a common coordinate frame:

$${\mathcal{M}}_q=\bigcup _{i\in {\mathcal{W}}_q}{\mathbf{T}}_i{\mathcal{P}}_i,$$

(13)

where ${\mathcal{P}}_i$ is the point cloud associated with pose i. A compression operator $\mathcal{C}(·)$ produces

$${\tilde{\mathcal{M}}}_q=\mathcal{C}\left({\mathcal{M}}_q;v_q,n_{max},{\mathcal{F}}_q\right),$$

(14)

where $v_q$ is the voxel resolution, $n_{max}$ is the point cap, and ${\mathcal{F}}_q$ denotes geometry-preserving selection criteria. Broad planar regions are downsampled, whereas edges, stiffener boundaries, brackets, and other geometrically informative structures are preferentially retained.

2.3. Global Graph SLAM Formulation

Let the stacked global pose state be

$$\mathbf{x}={\left[{\xi }_1^{\top },{\xi }_2^{\top },\dots ,{\xi }_N^{\top }\right]}^{\top }.$$

(15)

For a relative-pose measurement ${\mathbf{Z}}_{ij}$ between poses ${\mathbf{T}}_i$ and ${\mathbf{T}}_j$, the residual is defined on $\mathrm{SE}\left(3\right)$ as

$${\mathbf{r}}_{ij}\left(\mathbf{x}\right)=Log\left({\mathbf{Z}}_{ij}^{-1}\left({\mathbf{T}}_i^{-1}{\mathbf{T}}_j\right)\right).$$

(16)

The nonlinear graph objective is

$$\underset{\mathbf{x}}{min}\sum _{(i,j)\in \mathcal{E}}\rho \left({\mathbf{r}}_{ij}^{\top }{\Omega }_{ij}{\mathbf{r}}_{ij}\right)+\sum _{p\in \mathcal{P}}\rho \left({\mathbf{r}}_p^{\top }{\Omega }_p{\mathbf{r}}_p\right),$$

(17)

where $\mathcal{E}$ is the set of relative-pose factors and $\mathcal{P}$ contains prior factors.

At the current estimate, each factor is linearized:

$${\mathbf{r}}_k(\mathbf{x}\oplus \Delta \mathbf{x})\approx {\mathbf{r}}_k\left(\mathbf{x}\right)+{\mathbf{J}}_k\Delta \mathbf{x}.$$

(18)

Let ${\Lambda }_k$ satisfy

$${\Lambda }_k^{\top }{\Lambda }_k={\Omega }_k.$$

(19)

With robust factor weight $w_k$, the whitened block row and right-hand side are

$${\mathbf{A}}_k=\sqrt{w_k}{\Lambda }_k{\mathbf{J}}_k,{\mathbf{b}}_k=-\sqrt{w_k}{\Lambda }_k{\mathbf{r}}_k.$$

(20)

Stacking the factor rows yields

$$\underset{\Delta \mathbf{x}}{min}{\parallel \mathbf{A}\Delta \mathbf{x}-\mathbf{b}\parallel }_2^2.$$

(21)

A conventional normal-equation backend forms

$$\mathbf{H}\Delta \mathbf{x}=\mathbf{g},\mathbf{H}={\mathbf{A}}^{\top }\mathbf{A},\mathbf{g}={\mathbf{A}}^{\top }\mathbf{b},$$

(22)

and then factorizes $\mathbf{H}$. The proposed backend instead operates directly on the rows of $\mathbf{A}$. Figure 2 traces a relative-pose factor through linearization, whitening, sparse row assembly, and a subsequent row-wise Kaczmarz update.

2.4. CSR-Based Kaczmarz Backend

Let ${\mathbf{a}}_i^{\top }$ denote row i of $\mathbf{A}$, and let $b_i$ be the corresponding right-hand-side element. Given the current increment estimate $\Delta {\mathbf{x}}^{(\ell )}$, a relaxed Kaczmarz update with a numerical safeguard is

$$\Delta {\mathbf{x}}^{(\ell +1)}=\Delta {\mathbf{x}}^{(\ell )}+\lambda {\displaystyle \frac{b_i-{\mathbf{a}}_i^{\top }\Delta {\mathbf{x}}^{(\ell )}}{\parallel {\mathbf{a}}_i{\parallel }_2^2+\eta }}{\mathbf{a}}_i,$$

(23)

where $\lambda$ is the relaxation factor and $\eta >0$ prevents excessive updates when a selected row has a very small norm.

For row-norm sampling,

$$p_i={\displaystyle \frac{\parallel {\mathbf{a}}_i{\parallel }_2^2}{{\parallel \mathbf{A}\parallel }_F^2}}.$$

(24)

When frontend confidence scores or additional robust weights are retained separately from the whitening in $\mathbf{A}$, the sampling probability can be generalized to

$$p_i={\displaystyle \frac{q_i{\parallel {\mathbf{a}}_i\parallel }_2^2}{{\sum }_j{q}_j{\parallel {\mathbf{a}}_j\parallel }_2^2}},0\le q_i\le 1.$$

(25)

This rule reduces the selection frequency of low-confidence rows while retaining their bounded contribution to the solution.

The matrix is stored in CSR arrays containing nonzero values, column indices, and row pointers. Figure 3 shows a representative Jacobian pattern, dominated by local-factor support with limited off-diagonal blocks introduced by nonlocal constraints. When row i is selected, only the entries between row_ptr[i] and row_ptr[i+1] are accessed. If $\mathcal{N}\left(i\right)$ denotes the corresponding set of nonzero columns, the sparse update is

$$\Delta x_j^{(\ell +1)}=\Delta x_j^{(\ell )}+\lambda {\displaystyle \frac{b_i-{\sum }_{h\in \mathcal{N}\left(i\right)}{a}_{ih}\Delta x_h^{(\ell )}}{{\sum }_{h\in \mathcal{N}\left(i\right)}{a}_{ih}^2+\eta }}{a}_{ij},j\in \mathcal{N}\left(i\right).$$

(26)

Following the inner row projections, the increment associated with pose i is applied on the manifold:

$${\mathbf{T}}_i^{+}={\mathbf{T}}_{i}Exp\left(\delta {\xi }_i^{\wedge }\right).$$

(27)

The linear solve terminates when either the normalized residual or the successive-increment norm satisfies

$${\displaystyle \frac{\parallel \mathbf{A}\Delta {\mathbf{x}}^{(\ell )}{-\mathbf{b}\parallel }_2}{{\parallel \mathbf{b}\parallel }_2+ϵ}}<{\epsilon }_r,\mathrm{or}{\parallel \Delta {\mathbf{x}}^{(\ell )}-\Delta {\mathbf{x}}^{(\ell -1)}\parallel }_2<{\epsilon }_x,$$

(28)

or when the prescribed row-projection budget is exhausted. Because practical SLAM systems are generally inconsistent owing to sensor noise, linearization error, and residual outliers, the row projections are used as bounded residual-reduction steps within each nonlinear iteration; they are not assumed to satisfy every factor row exactly or to recover the exact least-squares solution.

2.5. Structural Memory Model and Memory Guard

The principal solver-side storage terms are the CSR representation of $\mathbf{A}$, the vector $\mathbf{b}$, the pose increment, the row norms, and the sampling data structure. Their approximate memory requirement is

$$M_{\mathrm{CSR}}\approx nnz\left(\mathbf{A}\right)(s_{\mathrm{val}}+s_{\mathrm{col}})+(m+1)s_{\mathrm{ptr}}+m{s}_b+n{s}_x+m{s}_p,$$

(29)

where m and n are the row and column counts, and the s terms denote the bytes required by the corresponding data types.

The full-pipeline memory estimate is

$$M_{\mathrm{total}}=M_{\mathrm{system}}+M_{\mathrm{sensor}}+M_{\mathrm{frontend}}+M_{\mathrm{map}}+M_{\mathrm{graph}}+M_{\mathrm{solver}}+M_{\mathrm{margin}}.$$

(30)

The memory guard monitors keyframe count, point count, factor count, residual-row count, $nnz\left(\mathbf{A}\right)$, and process resident set size. Three operating regions are used. In the normal region, nominal keyframe and map-resolution settings are retained. In the caution region, keyframe thresholds and voxel size are increased, point caps are tightened, and weak factors are suppressed. In the critical region, new keyframes may be deferred, inactive point clouds are compressed into submaps or descriptors, and the global optimization range may be bounded or skipped.

A new keyframe is accepted when at least one of the following conditions is met:

$$\parallel {\mathbf{t}}_t-{\mathbf{t}}_{\mathrm{last}}{\parallel }_2>{\tau }_t,$$

(31)

$${∥Log\left({\mathbf{R}}_{\mathrm{last}}^{\top }{\mathbf{R}}_t\right)∥}_2>{\tau }_R,$$

(32)

or

$$overlap\left({\mathcal{P}}_t,{\tilde{\mathcal{M}}}_{\mathrm{local}}\right)<{\tau }_o.$$

(33)

The thresholds are adapted conservatively as the estimated memory margin decreases.

2.6. Experimental Data and Evaluation Protocol

Marine-domain validation used missions 1–3 from the public Norwegian University of Science and Technology (NTNU) Ballast Water Tank dataset. The inspection platform and representative field deployments are described by Dharmadhikari et al. [1], while the data analyzed here are distributed through the NTNU Autonomous Robots Laboratory dataset repository [25]. The three evaluated sequences contained 851, 1202, and 1084 point-cloud frames, with reference path lengths of 58.48, 76.52, and 103.96 m, respectively. Raw point counts were obtained from point-cloud headers and archived run logs. Intermediate quantities that were not recorded, including the exact point count after each voxel-filtering and local-map-compression stage, were not reconstructed retrospectively.

For a trajectory containing N paired positions, the translational root-mean-square error (RMSE) was computed as

$$RMSE=\sqrt{{\displaystyle \frac{1}{N}}\sum _{i=1}^N{\parallel {\mathbf{p}}_i-{\mathbf{p}}_i^{\mathrm{ref}}\parallel }_2^2}.$$

(34)

The path-normalized error was

$$e_{\mathrm{path}}=100{\displaystyle \frac{RMSE}{L_{\mathrm{ref}}}},$$

(35)

where $L_{\mathrm{ref}}$ is the reference path length. The environment-scale metric was

$$e_{\mathrm{bbox}}=100{\displaystyle \frac{RMSE}{D_{\mathrm{bbox}}}},$$

(36)

where $D_{\mathrm{bbox}}$ is the diagonal of the reference trajectory bounding box.

The archived NTNU evaluation paired trajectory samples using the index-based procedure recorded with the experiments. Final robust local bundle adjustment (BA) trajectories were evaluated after a verified similarity-transformation ($\mathrm{Sim}\left(3\right)$) alignment. The top-down panels were taken from the corresponding validated evaluation exports. Because the archive did not retain the raw trajectory coordinates or plotting scripts, the plotted trajectory region was not redrawn, smoothed, or otherwise altered. The baseline and robust values should therefore be interpreted as trajectory-level validation, not as a solver-isolated ablation performed under identical alignment conditions.

A separate controlled benchmark compared direct, Krylov, least-squares, and Kaczmarz methods on identical $(\mathbf{A},\mathbf{b})$ systems. Solver-side structural-memory estimates were kept distinct from end-to-end peak resident set size (RSS), which also includes point-cloud input/output, local maps, graph assembly, runtime libraries, and trajectory storage.

2.7. Use of Generative Artificial Intelligence in Manuscript Preparation

OpenAI ChatGPT (GPT-5.5 Pro) was used to assist with English-language revision, structural editing, reference-format consistency, and LaTeX preparation. It was not used to generate or alter experimental data. The authors reviewed all generated text and independently verified the technical statements, numerical results, citations, and figures; they take full responsibility for the published content.

3. Results

3.1. NTNU Ballast Water Tank Mission Scale

Table 1 summarizes the input scale of the three marine validation missions. Each frame contained approximately 32,800 raw LiDAR points, yielding tens of millions of points per mission.

The missions differed in path length and spatial extent but had similar per-frame LiDAR density. Absolute RMSE was therefore complemented by path- and bounding-box-normalized metrics for cross-mission comparison.

3.2. Trajectory Accuracy of the Baseline and Robust Local BA Configurations

Table 2 reports the archived trajectory-level results for the baseline and robust local BA configurations. Because the two archived states were not evaluated under identical alignment conditions, the comparison is descriptive rather than a controlled single-variable ablation.

The baseline trajectories had RMSE values of 0.211–0.292 m, whereas the robust local BA trajectories had values of 0.080–0.127 m. The descriptive reductions in the archived RMSE values were 62.1%, 61.3%, and 56.5% for missions 1, 2, and 3, respectively. Maximum errors decreased from 0.699–1.663 m to 0.163–0.184 m.

The baseline path-normalized RMSE values were 0.361%, 0.372%, and 0.281%; all were below 0.4% of the respective path length. The robust local BA values were 0.137%, 0.144%, and 0.122%. Their spread was 0.022 percentage points, indicating comparable relative accuracy across the three mission lengths.

The bounding-box-normalized RMSE showed the same trend: 2.225% to 0.843% for mission 1, 2.706% to 1.047% for mission 2, and 1.895% to 0.824% for mission 3. This metric accounts for the different spatial extents of the three trajectories.

Figure 4 shows the archived top-down trajectory comparisons. In all three missions, the robust local BA trajectory follows the stored comparison trajectory without an evident route-scale discontinuity. The color-coded point errors are spatially localized and agree qualitatively with the aggregate RMSE and maximum-error values in Table 2. Because the robust trajectories were similarity-aligned, these plots complement rather than replace the alignment-dependent quantitative evaluation.

Figure 5 summarizes the path-normalized errors for the two archived evaluation configurations.

3.3. Structural Behavior of the Kaczmarz Backend

The controlled row-access comparison showed that Kaczmarz did not yield the lowest linear residual. Its implementation nevertheless required only CSR row access, the right-hand side, the solution vector, row statistics, and sampling state. Table 3 reports a representative comparison, and Figure 6 shows the corresponding solver-side structural-memory estimates.

Direct and Krylov-family methods achieved lower residuals and, in several controlled cases, shorter runtimes. Kaczmarz should therefore not be interpreted as a universal replacement for other graph solvers. In the representative case, its structural-memory estimate was 0.075 MB, compared with 0.149 MB for LSQR with a stored transpose cache, 0.177 MB for PCG with explicit $\mathbf{H}$, and 0.346 MB for the explicit-$\mathbf{H}$ Cholesky/$\mathbf{L}\mathbf{D}{\mathbf{L}}^{\top }$ configuration.

In the memory-budgeted streaming experiment, generating one Kaczmarz row at a time reduced the estimated working set to 0.044 MB, compared with 0.061 MB for chunked rows and 0.268 MB when the full CSR matrix was retained. These values quantify a solver-level working-set trade-off; they do not predict full-pipeline peak RSS.

The broader solver-only benchmark similarly showed that LSQR/LSMR and Krylov methods were highly competitive in residual and runtime. Row-norm Kaczmarz produced a mean residual of 0.273 and a mean relative residual of 0.218, whereas the direct and Krylov-family methods produced mean residuals of approximately 0.0067 in the corresponding aggregate benchmark. The result positions Kaczmarz as a memory-aware row-action option, not as a universally superior numerical solver.

3.4. System-Level Memory Operating Points

System-level controls were evaluated separately on the Park dataset, for which the archived runs covered multiple keyframe, point-cap, and global-optimization settings. Table 4 summarizes three representative operating policies.

Peak RSS increased from 165.1 MB in the memory-priority configuration to 411.4 MB in the quality-priority configuration. The main contributors were map resolution, selected point count, keyframe density, and the permitted global-optimization range. In the balanced and quality-priority cases, the range guard skipped global BA because the pose count exceeded the configured limit, while the remaining pipeline still produced a trajectory. These cases are therefore range-controlled pipeline executions, not successful high-load global BA solves.

These results distinguish two complementary forms of memory control. The row-wise backend limits solver-side factorization storage, whereas the keyframe, map, and optimization-range policies limit the size of the problem presented to the solver. Both are required in a complete onboard architecture.

4. Discussion

4.1. Significance for Marine Inspection Robotics

The NTNU results show that trajectory error remained a small fraction of traveled distance in the ballast-tank missions. The robust local BA trajectories had path-normalized RMSE values of 0.122–0.144%. Such normalized measures are more informative than absolute RMSE alone when mission lengths differ substantially.

For ship inspection, localization quality supports more than autonomous mobility. A consistent trajectory allows observations of corrosion, coating degradation, cracks, anodes, brackets, stiffeners, and weld regions to be registered within a three-dimensional structural reference frame. It also supports comparison across inspection campaigns and between observed geometry and design information. Large local discontinuities can otherwise duplicate structures, distort clearance estimates, or associate inspection records with incorrect locations.

The robust frontend targets failure modes that are characteristic of ship interiors. Residual weighting limits the influence of ambiguous matches; damping and step clamping bound updates in locally degenerate directions; and soft fallback preserves continuity when a local window lacks sufficient geometric information. Local-map compression additionally reduces redundant samples from broad planar surfaces while retaining informative structural boundaries.

4.2. Numerical Architecture and Operating-Policy Co-Design

The principal contribution is the co-design of numerical representation, solver access, frontend stabilization, and operating policy. Replacing a Cholesky solve with Kaczmarz while retaining unlimited keyframes and uncompressed point clouds would not resolve the end-to-end memory problem. Conversely, point-cloud compression alone would not prevent factorization storage from increasing as the pose graph becomes more densely connected.

The Kaczmarz backend offers three relevant system properties. First, it operates directly on whitened Jacobian rows. Second, its update does not require explicit storage of ${\mathbf{A}}^{\top }$, $\mathbf{H}={\mathbf{A}}^{\top }\mathbf{A}$, or a Cholesky factor. Third, factor rows can be streamed, prioritized, down-weighted, clipped, or deferred. These properties support memory budgeting, incremental factor arrival, and robust row-selection policies.

The experiments also quantify the cost of this flexibility. Kaczmarz did not attain the residuals achieved by LSQR/LSMR, PCG, or direct factorization in the controlled benchmark. It is therefore most appropriate when row-level controllability and bounded structural storage are more important than obtaining the smallest linear residual in the shortest time. When sufficient memory is available, an adaptive backend may instead select LSQR, LSMR, PCG, or a direct method.

This interpretation is consistent with recent resource-aware SLAM research, which treats algorithm and hardware constraints as a coupled design problem rather than optimizing accuracy in isolation [26].

4.3. Interpretation of Onboard Feasibility

The 8 GB Jetson Orin Nano represents a relevant memory and power class for a compact marine inspection robot. The reported experiments, however, were not an end-to-end deployment under a hardware-enforced 8 GB cap. The system-level RSS values should therefore be interpreted as measured pipeline operating points and design margins, not as evidence of real-time performance on every Jetson configuration.

The distinction between solver-side structural memory and full-pipeline peak RSS is essential. Solver-side memory isolates the data structures associated with $(\mathbf{A},\mathbf{b})$ and the selected numerical method. Full-pipeline RSS also includes point-cloud loading, feature extraction, local mapping, graph construction, visualization or output buffers, memory allocators, and software libraries. Consequently, a lower solver-side estimate does not imply an equal reduction in process peak RSS when point-cloud storage dominates.

The results nevertheless support the architectural feasibility of onboard operation. The backend avoids factorization-related storage, while the surrounding policies regulate the number and size of keyframes, maps, and active factors. These mechanisms provide explicit control variables for trading trajectory quality against memory margin, runtime, power, and thermal limits.

4.4. Limitations and Future Work

Several limitations define the scope of the conclusions. First, the archived baseline and robust NTNU results were not generated under identical alignment conditions; the robust trajectories used verified $\mathrm{Sim}\left(3\right)$ alignment. Their numerical differences provide trajectory-level evidence but do not constitute a strictly controlled single-variable ablation.

Second, the trajectory results validate localization output but do not establish real-time closed-loop navigation, collision avoidance, or inspection coverage. A deployment study should additionally measure update rate, latency distribution, thermal throttling, dropped sensor packets, and mission success on the target robot.

Third, Kaczmarz can converge slowly for ill-conditioned or strongly inconsistent systems, and its residual floor can exceed that of LSQR/LSMR or well-preconditioned Krylov methods. The proposed architecture does not remove this limitation.

Fourth, some intermediate point counts and compression ratios were not retained in the archived logs. The study therefore reports raw points, selected inputs, final pose counts, solver-side structural memory, and full-pipeline RSS separately rather than estimating unrecorded quantities.

Fifth, the full-pipeline operating points were not measured under cgroup, container, or hardware-level memory enforcement. Future tests should impose reproducible 4, 8, and 16 GB limits and distinguish confirmed out-of-memory events from generic process termination.

Future work should develop adaptive solver selection based on graph topology, available memory, accuracy requirements, and time budget. LSQR or LSMR may be preferable when a low residual is required and transpose operations are affordable; PCG may be appropriate when an effective preconditioner is available; and Kaczmarz may be selected when row streaming or a strict working-set limit dominates. Factor-aligned block and mini-batch Kaczmarz variants should also be evaluated. Finally, frontend confidence weights should be logged and propagated explicitly to global row selection, and hardware-capped experiments should record GPU usage, temperature, power consumption, and mission-completion statistics.

5. Conclusions

This study presented a memory-efficient graph SLAM architecture for autonomous inspection of ballast water tanks and other resource-constrained ship interiors. The architecture combines robust local hierarchical bundle adjustment with a CSR-based Kaczmarz backend, local-map compression, keyframe regulation, and global-optimization range control.

The frontend uses residual-adaptive weighting, damping, bounded translation and rotation updates, and soft fallback to suppress local divergence in repetitive or weakly constrained geometry. The backend operates directly on whitened factor rows and avoids explicit construction of the approximate Hessian, a Cholesky factor, and a transpose cache.

On NTNU Ballast Water Tank missions 1–3, baseline path-normalized RMSE values were 0.281–0.372%. The robust local BA trajectories yielded RMSE values of 0.080, 0.110, and 0.127 m, corresponding to 0.137%, 0.144%, and 0.122% of the respective path lengths.

The solver comparisons showed that Kaczmarz was not residual- or runtime-optimal relative to LSQR/LSMR, Krylov methods, or direct factorization. Its practical value lies in row-wise controllability, factorization-free storage, and compatibility with streaming and memory-budgeted operation. The contribution is therefore a numerical-architecture and operating-policy co-design for onboard marine robotics, not a new Kaczmarz variant or a claim of universal solver superiority.