CityGaussianV2: Efficient and Geometrically Accurate Reconstruction for Large-Scale Scenes

## Abstract

Abstract Recently, 3D Gaussian Splatting (3DGS) has revolutionized radiance field reconstruction, manifesting efficient and high-fidelity novel view synthesis. However, accurately representing surfaces, especially in large and complex scenarios, remains a significant challenge due to the unstructured nature of 3DGS. In this paper, we present CityGaussianV2, a novel approach for large-scale scene reconstruction that addresses critical challenges related to geometric accuracy and efficiency. Building on the favorable generalization capabilities of 2D Gaussian Splatting (2DGS), we address its convergence and scalability issues. Specifically, we implement a decomposed-gradient-based densification and depth regression technique to eliminate blurry artifacts and accelerate convergence. To scale up, we introduce an elongation filter that mitigates Gaussian count explosion caused by 2DGS degeneration. Furthermore, we optimize the CityGaussian pipeline for parallel training, achieving up to 10 × \times × compression, at least 25% savings in training time, and a 50% decrease in memory usage. We also established standard geometry benchmarks under large-scale scenes. Experimental results demonstrate that our method strikes a promising balance between visual quality, geometric accuracy, as well as storage and training costs. The project page is available at https://dekuliutesla.github.io/CityGaussianV2/ .

## 1 Introduction

3D scene reconstruction is a long-standing topic in computer vision and graphics, with its core pursuit of photo-realistic rendering and accurate geometry reconstruction. Beyond
Neural Radiance Fields (NeRF) (Mildenhall et al., ), 3D Gaussian Splatting (3DGS) (Kerbl et al., ) has become the predominant technique in this area due to its superiority in training convergence and rendering efficiency. 3DGS represents the scene with a set of discrete Gaussian ellipsoids and renders with a highly optimized rasterizer. However, such primitives take an unordered structure and do not correspond well to the actual surface of the scene. This limitation impairs its synthesis quality at extrapolated views and hinders its downstream application in editing, animation, and relighting (Guédon & Lepetit, ). Recently, many excellent works (Guédon & Lepetit, ; Huang et al., ; Yu et al., ) have been proposed to address this issue. Despite their great success in single objects or small scenes, devils emerge when applying them directly to complex, large-scale scenes.

On the one hand, existing methods face significant challenges related to scalability and generalization ability. For example, SuGaR (Guédon & Lepetit, ) binds meshes with Gaussians for refinement. However, in large-scale and complex scenarios, meshes can become extensive and finely detailed, resulting in substantial memory demands and capacity limitations. GOF (Yu et al., ) struggles with large, over-blurred Gaussians. These Gaussians not only severely deteriorate its rendering and geometry quality, but also generate a shell-like mesh that is non-trivial to remove, as validated in Fig. 7 and Fig. 8 in Appendix. While 2DGS (Huang et al., ) exhibits better generalization ability, as shown in Tab. 1, its convergence is hindered by the blurred Gaussians illustrated in part (b) of Fig. 1. Additionally, when scaling up through parallel training, it suffers from a Gaussian count explosion, as depicted in Fig. 3. Another challenge lies in the evaluation protocol: due to insufficient observations in boundary regions, geometry estimation becomes error-prone and unstable in these areas. As a result, the metrics can significantly fluctuate and underestimate actual performance (Xiong et al., ), making it difficult to objectively evaluate and compare algorithms.

On the other hand, achieving efficient parallel training and compression is critical to realizing geometrically accurate reconstruction of large-scale scenes. As shown in Tab. 2, the total number of Gaussians can increase to 19.3 million during parallel training, resulting in a storage requirement of 4.6 GB and a memory cost of 31.5 GB, while rendering speed drops below 25 FPS. Additionally,
existing VastGaussian (Lin et al., ) costs nearly 3 hours for training, and CityGaussian Liu et al. () consumes 4 hours to finish both training and compression. For reconstruction on low-end devices or under strict time constraints, these training costs and rendering speeds are unacceptable. Therefore, there is an urgent need for an economical parallel training and compression strategy.

In response to these challenges, we introduce CityGaussianV2, a geometrically accurate yet efficient strategy for large-scale scene reconstruction. We take 2DGS as primitive due to its favorable generalization capabilities. To accelerate reconstruction, we employ depth regression guided by Depth-Anything V2 (Yang et al., ) and Decomposed-Gradient-based Densification (DGD). As shown in part (b) of Fig. 1 and Tab. 2, DGD effectively eliminates blurred surfels, crucial for performance improvement. To address scalability, we introduce an Elongation Filter to mitigate the Gaussian count explosion problem associated with 2DGS degeneration during parallel training. To reduce the burden of single GPU, we conduct parallel training based on CityGaussian’s block partitioning strategy. And we streamline the process by omitting time-consuming post-pruning and distillation steps of CityGaussian. Instead, we implement spherical harmonics of degree 2 from scratch and integrate contribution-based pruning into per-block fine-tuning. As demonstrated in part (c) of Fig. 1, it scales up the surface quality of complex structures while significantly reducing training costs. Furthermore, our contribution-based vectree quantization enables a tenfold reduction in storage requirements for large-scale 2DGS. For evaluation, we introduce TnT-style (Knapitsch et al., ) protocol along with a visibility-based crop volume estimation strategy, which can efficiently exclude underobserved regions and bring stable and consistent assessment.

In summary, our contributions are four-fold:

- •
A novel optimization strategy for 2DGS, that accelerates its convergence under large-scale scenes and enables it to be scaled up to high capacity (Sec. 3.2).
- •
A highly optimized parallel training pipeline that significantly reduces training costs and storage requirements while enabling real-time rendering performance (Sec. 3.3).
- •
A TnT-style standardized evaluation protocol tailored for large, unbounded scenes, establishing a geometric benchmark for large-scale scene reconstruction (Sec. 4).
- •
To the best of our knowledge, our CityGaussianV2 is among the first to implement the Gaussian radiance field in large-scale surface reconstruction. Experimental results confirm our state-of-the-art performance in both geometric quality and efficiency.

## 2 Related Works

### 2.1 Novel View Synthesis

Novel view synthesis aims at generating new images from previously unseen viewpoints using images captured from various source viewpoints around a 3D scene. These new renderings are primarily based on the reconstructed 3D representation of the scene. One of the most seminal contributions to this field is Neural Radiance Fields (NeRF) (Mildenhall et al., ), which implicitly models target scenes using multi-layer perceptions (MLPs). Following this, MipNeRF (Barron et al., ; ) addresses objectionable aliasing artifacts by introducing anti-aliased conical frustum-based rendering. Deng et al. (); Wei et al. (); Xu et al. () apply depth supervision from point cloud to accelerate model convergence. Algorithms represented by InstantNGP (Müller et al., ) speeds up the training and rendering of NeRF by leveraging simplified data structures, including multi-resolution hash encoding grid and octrees (Zhang et al., ; Wang et al., ; Yu et al., ). The recently emerging 3D Gaussian Splatting (Kerbl et al., ) overcomes NeRF’s drawbacks in training efficiency and rendering speed. Follow-up works further improve upon 3DGS in anti-aliasing Yu et al. (), storage cost Fan et al. (); Zhang et al. (); Navaneet et al. (); Morgenstern et al. (), and high-texture area underfitting Bulò et al. (); Zhang et al. (). These remarkable works have provided valuable insights into the design of our algorithm.

### 2.2 Surface Reconstruction with Gaussians

Extracting accurate surfaces from unordered and discrete 3DGS is a challenging while intriguing task. A handful of algorithms have been developed to extract unambiguous surfaces and regularize smoothness and outliers. Pioneering SuGaR (Guédon & Lepetit, ) pretrain 3DGS and bind it with extracted mesh for fine-tuning. It then relies on Poisson reconstruction algorithm for fast mesh extraction. Recent GSDF (Yu et al., ) and NeuSG (Chen et al., ) optimize 3DGS together with a signed distance function to generate accurate surfaces. 2DGS (Huang et al., ) and concurrent GaussianSurfels (Dai et al., ) collapse one dimension of 3D Gaussian primitives to avoid ambiguous depth estimation. The normals derived from rendering and depth map are also aligned to ensure a smooth surface. TrimGS (Fan et al., ) further provides a novel per-Gaussian contribution definition to remove inaccurate geometry. As a post-processing technique, GS2Mesh (Wolf et al., ) uses a pre-trained stereo-matching model to export mesh from 3DGS directly. GOF (Yu et al., ) focuses on unbounded scene. It leverages ray-tracing-based volume rendering to obtain contiguous opacity distribution within the scene. Instead of 2DGS’s TSDF-based marching-cube strategy, GOF gets SDF from the opacity field and use marching tetrahedra to extract mesh. RaDeGS (Zhang et al., ) novelly define the ray intersection with Gaussian and correspondingly derive curved surface and depth distribution. Though these algorithms have been proven to be successful on small scenes or single objects, the challenges behind scaling up, including performance degradation, densification stability, and training cost, remain unexplored. We hope our analysis and design can provide more insights into the community.

### 2.3 Large-Scale Scene Reconstruction

Over the past few decades, 3D reconstruction from large image collections has gained considerable attention and made significant strides. Modern algorithms (Tancik et al., ; Turki et al., ; Xiangli et al., ; Xu et al., ; Zhang et al., ; Li et al., ) are largely based on NeRF (Mildenhall et al., ). However, the substantial time required for training and rendering has hindered NeRF-based methods for long time. The recent rise of 3DGS, exemplified by VastGaussian (Lin et al., ), represents a paradigm shift in large-scale scene reconstruction. Subsequent developments like HierarchicalGS (Kerbl et al., ) and OctreeGS (Ren et al., ) have introduced Level-of-Detail (LoD) techniques, enabling efficient rendering of scenes at various scales. CityGS (Liu et al., ) presents a comprehensive pipeline that encompasses parallel training, compression, and LoD-based fast rendering. And DoGaussian (Chen & Lee, ) applies Alternating Direction Methods of Multipliers (ADMM) to train 3DGS distributedly. Meanwhile, GrendelGS (Zhao et al., ) facilitates communication between blocks on different GPUs, and FlashGS (Feng et al., ) significantly reduces VRAM costs for large-scale training and rendering through a highly optimized renderer. Despite these advances, the issue of geometry accuracy has been largely overlooked due to the lack of reliable benchmarks. Our work addresses this gap, proposing a reliable benchmark along with a novel algorithm for both economical training, high fidelity, and accurate geometry.

## 3 Method

Figure: Figure 2: Illustration of our optimization mechanism. We densify Gaussians exclusively according to the gradient of SSIM loss. This helps remove large and blurry Gaussians and accelerate convergence. Meanwhile, we disable the densification of Gaussians with extreme elongation to avoid the Gaussian count explosion shown in Fig. 3. We also supervise the rendered depth with that predicted by Depth Anything V2 (Yang et al., ). This helps improve both rendering and geometry quality.
Refer to caption: x2.png

### 3.1 Preliminary

3D Gaussian Splatting (Kerbl et al., ) represents 3D scene with a set of ellipsoids described by 3D Gaussian distribution, i.e. $\mathbf{G}_{\mathbf{N}}=\left\{G_{n}|n=1,...,N\right\}$. Each Gaussian contains learnable properties including central point $\bm{\mu}_{\bm{n}}\in\mathbb{R}^{3\times 1}$, covariance $\mathbf{\Sigma}_{\bm{n}}\in\mathbb{R}^{3\times 3}$, opacity $\sigma_{n}\in\left[0,1\right]$, spherical harmonics (SH) features $\bm{f}_{\bm{n}}\in\mathbb{R}^{3\times 16}$ for view-dependent rendering. The covariance matrix is further decomposed to scaling matrix $\mathbf{R}_{\bm{n}}$ and rotation matrix $\mathbf{S}_{\bm{n}}$, i.e. $\mathbf{\Sigma}_{\bm{n}}=\mathbf{R}_{\bm{n}}\mathbf{S}_{\bm{n}}{\mathbf{S}_{
\bm{n}}}^{T}{\mathbf{R}_{\bm{n}}}^{T}$. For a certain pixel $p$, the color $\bm{c}_{p}$ is derived through alpha blending:

$$ $\displaystyle\bm{c}_{p}$ $\displaystyle=\sum_{i\in\gamma\left(p\right)}{\bm{c}_{i}\alpha_{i}\prod_{j=1}^ {i-1}{\left(1-\alpha_{j}\right)}},$ (1) $\displaystyle\alpha_{i}$ $\displaystyle=\sigma_{i}\cdot\exp\left(-\frac{1}{2}\left(\bm{x}-\bm{\mu}_{i} \right)^{T}\mathbf{\Sigma}_{i}^{-1}\left(\bm{x}-\bm{\mu}_{i}\right)\right),$ $$

where $\gamma\left(p\right)$ denotes Gaussians located on ray crossing pixel $p$, and $\bm{x}$ is the corresponding query point. The loss $\mathcal{L}$ that supervises 3DGS’s optimization is the weighted sum of two parts, L1 loss $\mathcal{L}_{1}$ and D-SSIM loss $\mathcal{L}_{\mathrm{SSIM}}$. 3DGS prevents under or over-reconstruction through heuristic adaptive density control, which is guided by view-space position gradient, i.e. $\nabla_{densify}=\partial\mathcal{L}/\partial\bm{\mu}_{n}$. The Gaussians with a gradient larger than a certain threshold would be cloned or split. For more details, we refer the readers to the original paper of 3DGS (Kerbl et al., ).

CityGaussian (Liu et al., ) aims to scale up 3DGS to large-scale scenes. As shown in Fig. 4, it first pre-trains a coarse model on full training data with the schedule of 3DGS. After that, it divides Gaussian primitives and training data into non-overlapping blocks and conducts parallel tuning. Following this, it adopts the approach from LightGaussian (Fan et al., ), applying an additional 30,000 iterations for pruning and 10,000 iterations for distillation. Pruning removes redundant Gaussians based on their rendering importance, while the distillation reduces the spherical harmonic (SH) degree from 3 to 2. It then conducts vectree quantization for storage compression.

2D Gaussian Splatting (Huang et al., ) addresses surface estimation ambiguity of 3DGS by collapsing 3D ellipsoid volumes into a set of 2D oriented Gaussian disks, known as surfels. Its covariance is characterized by two tangential vectors $\bm{t}_{n,u}$ and $\bm{t}_{n,v}$ and a scaling vector $\mathbf{S}_{\bm{n}}=\left(s_{n,u},s_{n,v}\right)$. In addition,2DGS incorporates depth distortion regularization and applies surface smoothness loss $\mathcal{L}_{\mathrm{Normal}}$ to align the surfel normals with those estimated from the depth map. These enhancements lead to superior results in geometry reconstruction and novel view synthesis.

### 3.2 Optimization Mechanism

This section elaborates on the proposed optimization mechanism for convergence acceleration and stable training. As illustrated in Fig. 2, the mechanism comprises three components: Depth Supervision, Elongation Filter, and Decomposed-Gradient-based Densification (DGD).

As depicted in Fig. 2, 2D Gaussians are projected into screen space at the given camera pose and rendered by a tailored rasterizer. The derived outputs are used for loss calculation. GS algorithm necessitates iterative optimization to disambiguate monocular cues from each view, ultimately converging to a coherent 3D geometry. To encourage convergence, we incorporate depth prior as an auxiliary guidance for geometry optimization. Following the practice in Kerbl et al. (), we utilize Depth-Anything-V2 to estimate the inverse depth and align it to the dataset’s scale, which we denote as $D_{k}$. Suppose $\hat{D}_{k}$ denotes the predicted inverse depth. The associated loss function is defined as $\mathcal{L}_{\mathrm{Depth}}=|\hat{D}_{k}-D_{k}|$. As the training progresses, we decrease the loss weight $\alpha$ exponentially to suppress the adverse effect of imperfect depth estimation gradually.

Figure: Figure 3: Illustration of the motivation and effectiveness of our Elongation Filter. We take the reconstruction of Rubble (Turki et al., ) scene as an example. On the left, we highlight the collection of Gaussian primitives with high gradient or extreme elongation. There is a significant overlap between two collections. By restricting densification of these sand-like points, we prevent out-of-memory (OOM) errors caused by an explosion in Gaussian count, enabling a steady count evolution analogous to CityGaussian (Liu et al., ) in parallel tuning, as depicted on the right.
Refer to caption: x3.png

As discussed in Sec. 1, the critical obstacle to scaling up 2DGS is the excessive proliferation of certain primitives during the parallel tuning stage. Typically, a 2D Gaussian can collapse to a very small point when projected from a distance, especially those exhibiting extreme elongation (Huang et al., ). With high opacity, the movement of these minuscule points can cause significant pixel changes in complex scenes, leading to pronounced position gradients. As evidenced in the left portion of Fig. 3, these tiny, sand-like projected points contribute substantially to points with high gradients. And they belong to those with extreme elongation. Moreover, some points project smaller than one pixel, resulting in their covariance being replaced by a fixed value through the antialiased low-pass filter. Consequently, these points cannot properly adjust their scaling and rotation with valid gradients. In block-wise parallel tuning, the views assigned to each block are much less than the total. These distant views are therefore frequently observed, causing the gradients of degenerated points to accumulate rapidly. These points consequently trigger exponential increases in Gaussian count and ultimately lead to out-of-memory errors, as demonstrated in the right portion of Fig. 3.

In light of this observation, we implement a straightforward yet effective Elongation Filter to address this problem. Before densification, we assess the elongation rate of each surfel, defined as $\eta_{n}=\min(s_{n,u},s_{n,v})/\max(s_{n,u},s_{n,v})$. Surfels with $\eta_{n}$ below a certain threshold are excluded from the cloning and splitting process. As shown in the right portion of Fig. 3, this filter mitigates out-of-memory errors and facilitates a more steady Gaussian count evolution. Furthermore, experimental results in Tab. 2 demonstrate that it does not compromise performance at the pretraining stage.

Naive 2DGS also suffers from suboptimal optimization when migrated to large-scale scenes. We empirically found that 2DGS is more susceptible to blurry reconstruction than 3DGS at the early training stage, as shown in Fig. 10 of the Appendix. As indicated by Wang et al. (); Zhang et al. (); Shi et al. (), in contrast to SSIM loss, the L1 RGB loss is insensitive to blurriness and does not prioritize preserving structural integrity. Tab. 6 of the Appendix further ablates on the gradient source of adaptive density control, validating that participation of its gradient is the most critical for sub-optimal results. To alleviate this problem, we prioritize the gradient from SSIM loss and introduce a Decomposed-Gradient-based Densification (DGD) strategy. Specifically, the gradient for densification is reformulated as:

$$ $\nabla_{densify}=\max\left(\omega\times\frac{|\nabla\mathcal{L}|_{avg}}{| \nabla\mathcal{L}_{\mathrm{SSIM}}|_{avg}},1\right)\times\nabla\mathcal{L}_{ \mathrm{SSIM}},$ (2) $$

where $\nabla\mathcal{L}_{\mathrm{SSIM}}$ is scaled according to the average gradient norm of the total loss to align automatically with the original gradient threshold for densification, with $\omega$ representing a constant weight.

### 3.3 Parallel Training Pipeline

Figure: Figure 4: Illustration of pipeline modification. The pipeline of CityGS (Liu et al., ) (dashed boxes and arrows) is compared with ours. We successfully removed time-consuming post-pruning and distillation, while enabling storage compression for 2DGS.
Refer to caption: x4.png

As discussed in Sec. 1, the post-pruning and distillation of CityGaussian are time-consuming. And a significant memory overhead is introduced during parallel tuning. Considering these issues, we propose a novel pipeline, as shown in Fig. 4. To bypass the distillation step, we use an SH degree of 2 from the start, reducing the SH feature dimension from 48 to 27. This results in considerable memory and storage savings throughout the whole pipeline. To eliminate the need for post-pruning, we incorporate trimming during block-wise tuning. Specifically, we define the single-view contribution of each Gaussian following Fan et al. ():

$$ $\mathbf{C}_{n,k}=\frac{1}{|\mathbb{P}_{k}|}\sum_{p\in\mathbb{P}_{k}}{\left( \alpha_{n}\right)}^{\gamma}\left(\prod_{j=1}^{n\left(p\right)-1}{\left(1- \alpha_{j}\right)}\right)^{\left(1-\gamma\right)},$ (3) $$

where $\mathbb{P}_{k}$ is the 2D projected region of $n$-th Gaussian under $k$-th view. $n(p)$ denotes its depth sorted order on ray crossing pixel $p$. $\gamma$ is set as the default value of 0.5. Suppose that the images assigned to $m$-th block using CityGS (Liu et al., )’s strategy is $\mathbb{V}_{m}$, then
the average contribution is:

$$ $\mathbf{C}_{n}=\frac{1}{|\mathbb{V}_{m}|}\sum_{k\in\mathbb{V}_{m}}{\mathbf{C}_ {n,k}}.$ (4) $$

This contribution is evaluated at the start of training and at predefined epoch intervals. Our approach differs from Fan et al. () in that we use a percentile-based threshold to determine which points to discard. The points with contributions equal to or lower than this bound, including those redundant and never-observed points, will be automatically removed. Tab. 2 validates that our pipeline saves 50% storage and 40% memory, while decreasing time cost and slightly improving performance.

After merging the Gaussians across different blocks, we implement vectree quantization on 2DGS. We first evaluate each point’s contribution across all training data. The least important Gaussians undergo aggressive vector quantization on the SHs. The remaining critical SHs, along with other attributes representing Gaussian shape, rotation, and opacity, are stored in float16 format.

## 4 Geometric evaluation protocols

Figure: Figure 5: Illustration of the evaluation process.
Refer to caption: x5.png

The evaluation protocol for rendering quality is well-established and transferable. We adhere to standard practices by measuring SSIM, PSNR, and LPIPS between renderings and groundtruth. However, there is still no universally accepted protocol for assessing geometric accuracy in large-scale scene reconstruction. Recently, GauU-Scene (Xiong et al., ) introduced the first benchmark, but its evaluation protocol overlooks boundary effects, leading to unreliable assessments. For instance, as indicated in its own paper (Xiong et al., ), such a protocol significantly underestimates the geometric accuracy of SuGaR, which demonstrates promising performance in mesh visualization. Moreover, GauU-Scene does not align the surface points extraction process across methods, leading to unfair comparison. In particular, NeRF-based methods extract points from depth maps, while 3DGS utilizes Gaussian means. To address these issues, we draw lessons from the evaluation protocol of the Tanks and Temple (TnT) dataset (Knapitsch et al., ), which includes point cloud alignment, resampling, volume-bound cropping, and F1 score measurement. For all the compared methods, we first extract mesh and then sample points from the surface. Though TnT’s strategy of sampling vertices and face centers is fast, it would underestimate the effect of mistakenly posing large triangles. Therefore, we sample same number of points evenly on the surface.

To further deal with the challenge of boundary effect, an appropriate estimation of the crop volume is necessary. The core here is to check the visible frequency of each point and estimate a bound that can exclude rarely observed points. For efficiency, we take a workaround that formulates points as Gaussian primitives and checks their visibility using a well-optimized GS rasterizer. As illustrated in Fig. 5, we begin by initializing a 3DGS field with the ground-truth point cloud, then traverse all training views to rasterize and count visible frequency through the output visible mask. If the frequency of $j$-th point $\tau_{j}$ is below a predefined threshold, it will be excluded. The remaining points are then used to compute the alpha shape in the ground plane as well as the minimum and maximum heights. This process can be completed within 1 minute. Compared to the crop volume estimated on all points, ours reduces the error bar length of the F1 score from 0.1 to 0.003, enabling a stable, consistent, and reliable evaluation of the model’s actual performance.

Aside from automatic crop volume estimation, we also downsample the ground-truth point cloud to accelerate the evaluation process under such large-scale scenes. The downsampling voxel size is set to 0.35m. The distance threshold of $\tau$ varies from 0.3m to 0.6m, according to statistics of nearest-neighbor distances in the downsampled ground-truth point clouds.

## 5 Experiments

### 5.1 Experimental Setup

Figure: Figure 6: Qualitative comparison of surface reconstruction quality. Here “Russian“ and “Modern“ denote the Russian Building and Modern Building scene of GauU-Scene, respectively. And “Aerial“ denotes aerial view of MatrixCity. The messy results of GOF are mainly attributed to the near-ground shell-like mesh. Due to the page limit, we leave further qualitative comparison with GOF and visualization at street view in the Appendix.
Refer to caption: x6.png

Datasets. We require datasets with accurate ground-truth point clouds. Therefore, we utilize the realistic dataset GauU-Scene (Xiong et al., ) and the synthetic dataset MatrixCity (Li et al., ). From GauU-Scene, we selected the Residence, Russian Building, and Modern Building scenes. For MatrixCity, we conduct experiments on its aerial view and street view version respectively. Each scene comprises over 4,000 training images and more than 450 test images, presenting significant challenges. These five scenes span areas ranging from 0.3 km^2 to 2.7 km^2. For aerial views, we follow Kerbl et al. () to downsample the longer side of images to 1,600 pixels. For street views, we retain the original 1,000 × 1,000 resolution. To generate the initial sparse point cloud, we employ COLMAP (Schönberger & Frahm, ; Schönberger et al., ) along with the provided poses. Ground-truth point clouds are exclusively utilized for geometry evaluation.

Implementation Details. Our experiments are conducted on 8 A100 GPUs. We set the gradient scaling factor $\omega$ to 0.9 and the pruning ratio to 0.025. For depth distortion loss, we empirically find it harmful to performance, and thus set its weight to default value 0. The weight for $\mathcal{L}_{\mathrm{Depth}}$ is exponentially decayed from 0.5 to 0.0025 during both the pretraining and fine-tuning stages. $\mathcal{L}_{\mathrm{Normal}}$ is activated after 7,000 iterations in pretraining and from the beginning in the parallel tuning. Besides, we found that the original normal supervision was overly aggressive for complex scene reconstruction. Consequently, the weight for $\mathcal{L}_{\mathrm{Normal}}$ is reduced to 0.0125, one-fourth of its original value. We adhere to the default settings in CityGaussian (Liu et al., ) for the learning rate and densification schedule. To be specific, it applies lower learning rates during tuning compared to pertaining, and the street view is trained with a significantly lower learning rate and longer densification interval due to its extreme view sparsity (Zhou et al., ). Due to page limitations, additional details, including parameters for block partition and quantization, are provided in the Appendix.

For depth rendering, we utilize median depth for improved geometry accuracy, and for mesh extraction, we employ 2DGS’s TSDF-based algorithm with a voxel size of 1m and SDF truncation of 4m. Additionally, GauU-Scene applies depth truncation of 250m, while MatrixCity uses 500m.

Baselines. We compare our method against state-of-the-art Gaussian Splatting methods for surface reconstruction, including SuGaR (Guédon & Lepetit, ), 2DGS (Huang et al., ), and GOF (Yu et al., ). Implicit NeRF-based methods such as NeuS (Wang et al., ) and Neuralangelo (Li et al., ) are also included. For a fair comparison, we follow Lin et al. (); Liu et al. () to double the total iterations; the starting iteration and interval of densification for GS-based or warm-up and annealing iteration of NeRF-based methods are likewise doubled. We observed that GOF’s mesh extraction generates an extremely high-resolution mesh exceeding 1G, significantly larger than the meshes produced by the original settings of SuGaR and 2DGS. To ensure fairness, we adjusted the mesh extraction parameters of these methods to align their resolutions. For large-scale scene reconstruction, we utilize CityGaussian (Liu et al., ) as a representative, as other concurrent aerial-view-based methods were not open-sourced at the time of submission. For its mesh extraction, we adopt 2DGS’s methodology and use median depth for TSDF integration.

### 5.2 Comparison with SOTA methods

Figure: Figure 7: Qualitative comparison of rendering quality. Here “Russian“ and “Modern“ denote the Russian Building and Modern Building scene of GauU-Scene, respectively. “Aerial“ denotes the aerial view of MatrixCity. Due to the page limit, we leave the street view in the Appendix.
Refer to caption: x7.png

**Table 1: Comparison with SOTA reconstruction methods. “NaN“ means no results due to NaN error, and “OOM“ denotes out-of-memory error. “FAIL“ means the method fails to extract meaningful mesh due to poor convergence. Here P and R denotes precision and recall against ground-truth point cloud, respectively. More detailed rendering metrics are included in the Appendix.**
|  | GauU-Scene | MatrixCity-Aerial | MatrixCity-Street |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | PSNR$\uparrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ | PSNR$\uparrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ | PSNR$\uparrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ |
| NeuS | 14.46 | FAIL | FAIL | FAIL | 16.76 | FAIL | FAIL | FAIL | 12.86 | FAIL | FAIL | FAIL |
| Neuralangelo | NaN | NaN | NaN | NaN | 19.22 | 0.080 | 0.083 | 0.081 | 15.48 | FAIL | FAIL | FAIL |
| SuGaR | 23.47 | 0.570 | 0.292 | 0.377 | OOM | OOM | OOM | OOM | 19.82 | 0.053 | 0.111 | 0.071 |
| GOF | 22.33 | 0.370 | 0.390 | 0.374 | 17.42 | FAIL | FAIL | FAIL | 20.32 | 0.219 | 0.473 | 0.300 |
| 2DGS | 23.93 | 0.553 | 0.446 | 0.491 | 21.35 | 0.207 | 0.390 | 0.270 | 21.50 | 0.334 | 0.659 | 0.443 |
| CityGS | 24.75 | 0.457 | 0.371 | 0.407 | 27.46 | 0.362 | 0.637 | 0.462 | 22.98 | 0.283 | 0.689 | 0.401 |
| Ours | 24.51 | 0.576 | 0.450 | 0.501 | 27.23 | 0.441 | 0.752 | 0.556 | 22.19 | 0.376 | 0.759 | 0.503 |

In this section, we compare CityGaussianV2 with state-of-the-art (SOTA) methods both quantitatively and qualitatively. As shown in Tab. 1, NeRF-based methods are more prone to failure due to the NaN outputs of the MLP or poor convergence under sparse supervision in large-scale scenes. Besides, these methods generally take over 10 hours for training. In contrast, GS-based methods finish training within several hours, while demonstrating stronger performance and generalization abilities. For GauU-Scene, our model significantly outperforms existing geometry-specialized methods in rendering quality. As visually illustrated in Fig. 7, our method accurately reconstructs details such as crowded windows and woodlands. Geometrically, our model outperforms 2DGS by 0.01 F1 score. Besides, part (b) of Fig. 1 shows that even without parallel tuning, our proposed optimization strategy enables our model to achieve significantly better performance in rendering and geometry at both 7K and 30K iterations, while 2DGS struggles to efficiently optimize large and blurry surfels. This validates our superiority in convergence speed. Compared to CityGS, our method improves the F1 score by 0.1 while maintaining a minimal gap in PSNR. As validated in Fig. 6, the meshes produced by our method are smoother and more complete.

On the challenging MatrixCity dataset, we evaluate performance from both aerial and street views. For MatrixCity-Aerial, our method achieves the best surface quality among all algorithms, with the F1 score being twice that of 2DGS and outperforming CityGaussian by a significant margin. Furthermore, both SuGaR and GOF fail to complete training or extract meaningful meshes. In the street view, CityGS and geometry-specialized methods like 2DGS significantly underperform our method in geometry. As illustrated in Fig. 9 in the Appendix, our method provides qualitatively better reconstructions of road and building surfaces, with rendering quality comparable to CityGS.

Regarding training costs, as indicated in Tab. 2, the small version of CityGaussianV2 (ours-s) reduces training time by 25% and memory usage by over 50%, while delivering superior geometric performance and on-par rendering quality with CityGS. The tiny version (ours-t) can even halve the training time. These advantages make our method particularly suitable for scenarios with varying quality and immediacy requirements.

### 5.3 Albation Studies

**Table 2: Ablation on model components. The experiments are conducted on Residence scene of GauU-Scene dataset ((Xiong et al., )). Here we take 2DGS ((Huang et al., )) as our baseline. The upper part ablates on pertaining, while the lower part ablates on fine-tuning. #GS, T, Size, Mem. are the number of Gaussians, total training time with 8 A100, memory, storage cost. The units are million, minute, Gigabytes, and Gigabytes respectively. The best performance of each part is in bold. “+“ means add components on basis of all components in the above rows. An indented line means that only the module in that line is added, while that of other indented rows are excluded. The gray row denotes modification that is aborted and not included in the following experiments.**
|  | Rendering Quality | Geometric Quality | GS Statistics |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Model | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ | #GS | T | Size | Mem. | FPS |
| Baseline | 0.637 | 21.12 | 0.401 | 0.474 | 0.362 | 0.410 | 9.54 | 78 | 2.26 | 20.8 | 28.0 |
| + Elongation Filter | 0.636 | 21.18 | 0.401 | 0.477 | 0.362 | 0.411 | 9.56 | 78 | 2.26 | 20.8 | 28.6 |
| + DGD | 0.674 | 22.24 | 0.345 | 0.480 | 0.387 | 0.429 | 9.51 | 84 | 2.25 | 20.7 | 30.3 |
| + Depth Regression | 0.674 | 22.22 | 0.345 | 0.501 | 0.390 | 0.438 | 9.67 | 89 | 2.29 | 25.3 | 29.4 |
| + Parallel Tuning | 0.742 | 23.50 | 0.237 | 0.538 | 0.419 | 0.471 | 19.3 | 195 | 4.57 | 31.5 | 21.3 |
| + Trim (Ours-b) | 0.742 | 23.57 | 0.243 | 0.534 | 0.430 | 0.477 | 8.07 | 179 | 1.90 | 19.0 | 31.3 |
| + Prune | 0.738 | 23.46 | 0.246 | 0.538 | 0.420 | 0.472 | 10.3 | 168 | 1.90 | 24.3 | 30.3 |
| + SH Degree=2 | 0.742 | 23.49 | 0.245 | 0.540 | 0.423 | 0.474 | 8.06 | 176 | 1.29 | 14.2 | 34.5 |
| + VQ (Ours-s) | 0.740 | 23.46 | 0.248 | 0.530 | 0.414 | 0.465 | 8.06 | 181 | 0.44 | 14.2 | 34.5 |
| + 7k pretrain (Ours-t) | 0.721 | 23.17 | 0.281 | 0.517 | 0.416 | 0.461 | 5.31 | 115 | 0.29 | 11.5 | 41.7 |
| + partition of 2DGS | 0.704 | 22.68 | 0.296 | 0.508 | 0.414 | 0.456 | 4.71 | 112 | 0.25 | 11.3 | 43.5 |
| CityGaussian | 0.758 | 23.75 | 0.273 | 0.519 | 0.398 | 0.450 | 10.9 | 254 | 0.60 | 31.5 | 58.8 |

In this section, we ablate each component of our model design. The upper part of Tab. 2 focuses on the optimization mechanism. As shown, restricting the densification of highly elongated Gaussians has negligible impact on pretraining performance. However, as illustrated in Fig. 3, this strategy is essential for preventing Gaussian count explosion during the fine-tuning stage. Additionally, Tab. 2 demonstrates that our Decomposed Densification Gradient (DGD) strategy significantly accelerates convergence, improving 1.0 PSNR, 0.04 SSIM, and almost 0.02 F1 score. A more detailed analysis of how gradient from different losses affects performance is included in the Appendix. The last two lines in the upper section confirm that depth supervision from Depth-Anything-V2 (Yang et al., ) enhances geometric quality considerably.

The lower part of Tab. 2 examines our pipeline design. With parallel tuning, both rendering and geometry quality show substantial improvements, validating the success of scaling up. For trimming, we use a more aggressive pruning ratio of 0.1, leading to 50% storage and memory reduction. The result also underscores the importance of trimming for real-time performance. LightGaussian’s (Fan et al., ) pruning strategy, however, falls short in preserving rendering quality. By using an SH degree of 2 from scratch, we further reduce storage and memory usage by over 25%, with marginal impact on rendering performance or geometry accuracy. And speed is improved by 4.2 FPS. Our contribution-based vectree quantization step takes several minutes for compression, but achieves a 75% reduction in storage. Additionally, by using the result from 7,000 iterations as a pre-train, the total training time decreases from 3 hours to 2 hours, with the model size shrinking to below 300 MB. This compact model is well-suited for deployment on low-end devices like smartphones or VR headsets. However, replacing the block partition with the one generated from 7,000 iterations of 2DGS results in a considerable drop in both the PSNR and F1 score. This suboptimal outcome underscores the importance of fast convergence for efficient training of tiny models.

## 6 Conclusion

In this paper, we reveal the challenges of scaling up the GS-based surface reconstruction method and establish the geometry benchmark for large-scale scenes. Our CityGaussianV2 takes 2DGS as primitives, eliminating its problem in convergence speed and scaling up capability. Despite that, we also implement parallel training and compression for 2DGS, realizing considerably lower training cost compared to CityGaussian. Experimental results on multiple challenging datasets demonstrate the efficiency, effectiveness and robustness of our method.

## Appendix A Additional Qualitative Comparison

Figure: Figure 8: Qualitative comparison of meshes generated from GOF and our CityGaussianV2.
Refer to caption: x8.png

Figure: Figure 9: Qualitative comparison of results on the street view of MatrixCity.
Refer to caption: x9.png

Figure: Figure 10: Qualitative ablation of 7K iteration results among different methods.
Refer to caption: x10.png

This section provides additional qualitative comparisons. As illustrated in Fig. 8, the mesh produced by GOF is obscured by a near-ground shell, which obstructs rendering from the test view in Fig. 6 of the main paper and is challenging to remove. However, it does successfully capture the intricate structures of buildings and landscapes. For a more thorough comparison, we opt for the interior view in Fig. 6. Notably, our CityGaussianV2 showcases qualitatively better reconstructions with more geometry details and fewer outliers.

Fig. 9 visualizes the rendering and extracted mesh of state-of-the-art methods in street view. Our method successfully scales up and the rendering quality is on par with CityGaussian. In terms of geometry, as shown in the last two rows of Fig. 9, the mesh produced by SuGaR appears messy, while GOF is obscured by near-ground shells and rendered in darkness. The road reconstructed by 2DGS is fragmented, and CityGaussian suffers from floating artifacts in the sky. In contrast, our CityGaussianV2 achieves superior quality, constructing a smoother and more complete surface for buildings and roads.

Fig. 10 compares the results at 7,000 iterations across different methods. As shown, 2DGS experiences more severe blurring compared to 3DGS, which significantly hampers its convergence speed. The flattened 3DGS, which modifies 3DGS by constraining one of its scalings to a minimal value as done in Fan et al. (), introduces similar blurring effects observed in 2DGS. This suggests that the issue may be inherent to the dimension collapse. In contrast, our DGD strategy leverages the sensitivity of SSIM loss to blurriness, eliminating blurry surfels while enabling much higher quality results at the same 7K iterations.

## Appendix B Additional Quantitative Results

**Table 3: Detailed comparison with SOTA on rendering metrics. “NaN“ here means no results due to NaN error, and “OOM“ denotes no results due to out-of-memory error. “FAIL“ means fail to extract meaningful mesh due to poor convergence.**
|  | GauU-Scene | MatrixCity-Aerial | MatrixCity-Street |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | F1$\uparrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | F1$\uparrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | F1$\uparrow$ |
| NeuS | 0.227 | 14.46 | 0.688 | FAIL | 0.476 | 16.76 | 0.691 | FAIL | 0.562 | 12.86 | 0.514 | FAIL |
| Neuralangelo | NaN | NaN | NaN | NaN | 0.535 | 19.22 | 0.594 | 0.081 | 0.592 | 15.48 | 0.547 | FAIL |
| SuGaR | 0.682 | 23.47 | 0.390 | 0.377 | OOM | OOM | OOM | OOM | 0.662 | 19.82 | 0.478 | 0.071 |
| GOF | 0.705 | 22.33 | 0.333 | 0.374 | 0.374 | 17.42 | 0.588 | FAIL | 0.703 | 20.32 | 0.440 | 0.300 |
| 2DGS | 0.756 | 23.93 | 0.232 | 0.491 | 0.632 | 21.35 | 0.562 | 0.270 | 0.723 | 21.50 | 0.477 | 0.441 |
| CityGS | 0.789 | 24.75 | 0.176 | 0.449 | 0.865 | 27.46 | 0.204 | 0.462 | 0.808 | 22.98 | 0.301 | 0.401 |
| Ours | 0.765 | 24.51 | 0.215 | 0.501 | 0.857 | 27.23 | 0.169 | 0.531 | 0.784 | 22.19 | 0.382 | 0.524 |

**Table 4: Detailed geometry metrics on GauU-Scene datasets ((Xiong et al., )). * means that the method fails to finish 60,000 iterations training and therefore reports that of 30,000 iterations. “NaN“ here means no results due to NaN error, and “FAIL“ means fail to extract meaningful mesh.**
|  | Residence | Russian Building | Modern Building |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ | P$\uparrow$ | R$\uparrow$ | F1$\uparrow$ |
| NeuS | FAIL | FAIL | FAIL | FAIL | FAIL | FAIL | FAIL | FAIL | FAIL |
| Neuralangelo | NaN | NaN | NaN | FAIL | FAIL | FAIL | NaN | NaN | NaN |
| SuGaR | 0.579 | 0.287 | 0.384 | 0.480 | 0.369 | 0.417 | 0.650 | 0.220 | 0.329 |
| GOF | 0.404 | 0.418 | 0.411 | 0.294* | 0.394* | 0.330* | 0.411 | 0.357 | 0.382 |
| 2DGS | 0.526 | 0.406 | 0.458 | 0.544 | 0.519 | 0.531 | 0.588 | 0.413 | 0.485 |
| CityGS | 0.329 | 0.289 | 0.308 | 0.459 | 0.443 | 0.451 | 0.582 | 0.381 | 0.461 |
| Ours | 0.524 | 0.421 | 0.467 | 0.560 | 0.530 | 0.544 | 0.643 | 0.398 | 0.492 |

**Table 5: Detailed rendering metrics on GauU-Scene datasets ((Xiong et al., )). * means that the method fails to finish 60,000 iterations training and therefore reports that of 30,000 iterations. “NaN“ here means no results due to NaN error.**
|  | Residence | Russian Building | Modern Building |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Methods | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ | LPIPS$\downarrow$ |
| NeuS | 0.244 | 15.16 | 0.674 | 0.202 | 13.65 | 0.694 | 0.236 | 14.58 | 0.694 |
| Neuralangelo | NaN | NaN | NaN | 0.328 | 12.48 | 0.698 | NaN | NaN | NaN |
| SuGaR | 0.612 | 21.95 | 0.452 | 0.738 | 23.62 | 0.332 | 0.700 | 24.92 | 0.381 |
| GOF | 0.652 | 20.68 | 0.391 | 0.713* | 21.30* | 0.322* | 0.749 | 25.01 | 0.286 |
| 2DGS | 0.703 | 22.24 | 0.306 | 0.788 | 23.77 | 0.189 | 0.776 | 25.77 | 0.202 |
| CityGS | 0.763 | 23.59 | 0.204 | 0.808 | 24.37 | 0.163 | 0.796 | 26.29 | 0.160 |
| Ours | 0.742 | 23.57 | 0.243 | 0.784 | 24.12 | 0.196 | 0.770 | 25.84 | 0.207 |

In this section, we present additional quantitative results. Tab. 3 highlights a comprehensive comparison with state-of-the-art (SOTA) methods in rendering metrics. Notably, our approach significantly outperforms geometry-specific methods, while maintaining comparable photometric quality with CityGS. As shown in Fig. 7 of the main paper, our model can achieve qualitatively better reconstructions with more appearance detail.

Tab. 4 and Tab. 5 reports detailed performance on GauU-Scene dataset. Comparing the quality of the extracted mesh, SuGaR (Guédon & Lepetit, ) shows promising precision on the Residence and Modern Building scene, but the overall performance is severely deteriorated by insufficient recall. And GOF (Yu et al., ) fails to finish 60,000 training on the Russian Building scene due to OOM error. 2DGS (Huang et al., ) shows competitive geometric performance, substantially outperforming CityGS. However, Tab. 5 showcases that the geometry-specific methods fall short in rendering quality. In contrast, our method not only achieves SOTA surface quality, but also strikes a promising balance with rendering fidelity.

In Tab. 6, we check the influence of different losses in densification. On the one hand, Tab. 6 shows that the most critical gradient for densification is that from L1 RGB loss. Its participation has a negative impact on reconstructing appearance details (SSIM) and overall quality (PSNR). On the other hand, the influence of densification gradient from normal and depth is within the error bar (0.003 for the F1 score). Therefore, we exclusively rely on the gradient from SSIM loss in the official version of our CityGaussianV2.

**Table 6: Ablation on gradient source of densification. The experiments are conducted on the Residence scene of the GauU-Scene dataset ((Xiong et al., )). Here we take 2DGS ((Huang et al., )) with the Elongation Filter as the baseline. #GS and T are the number of Gaussians and total training time with 8 A100 respectively. The best performance of each metric column is highlighted in bold. Notably, though the densification gradients here are not automatically scaled, the numbers of Gaussians are maintained at similar levels.**
| Densification Gradient | Rendering Quality | Geometric Quality | GS Statistics |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| SSIM | RGB | NORM | DEPTH | PSNR | SSIM | LPIPS | P | R | F1 | #GS(M) | T(min) |
| ✓ | ✓ | ✓ | n/a | 0.636 | 21.18 | 0.401 | 0.464 | 0.353 | 0.401 | 9.56 | 78 |
| ✓ | ✓ |  | n/a | 0.635 | 21.13 | 0.403 | 0.463 | 0.350 | 0.399 | 9.54 | 85 |
| ✓ |  | ✓ | n/a | 0.673 | 22.21 | 0.347 | 0.466 | 0.377 | 0.417 | 9.44 | 85 |
| ✓ |  |  | n/a | 0.674 | 22.24 | 0.345 | 0.470 | 0.378 | 0.419 | 9.51 | 84 |
| ✓ |  |  |  | 0.674 | 22.22 | 0.345 | 0.490 | 0.381 | 0.429 | 9.67 | 89 |
| ✓ |  |  | ✓ | 0.674 | 22.21 | 0.347 | 0.490 | 0.380 | 0.428 | 9.43 | 90 |

## Appendix C More Implementation Details

For primitives and data partitioning, as well as parallel tuning, we follow the default parameter setting of CityGaussian (Liu et al., ) on both aerial view and street view of MatrixCity dataset. On GauU-Scene, we use SSIM threshold $\epsilon$ of 0.05 and default foreground range for contraction, i.e. the central 1/3 area of the scene. The Residence scene of GauU-Scene is divided into $4\times 2$ blocks, while Russian Building and Modern Building scenes are divided into $3\times 3$ blocks. When fine-tuning on GauU-Scene, the learning rate of position is reduced by 60%, while that of scaling is empirically reduced by 20%, as suggested in Liu et al. (). For vectree quantization, we set the codebook size to 8192 and the quantization ratio to 0.4.

## Appendix D Discussion

While our method successfully delivers favorable efficiency and accurate geometry reconstruction for large-scale scenes, we also want to discuss its limitations: First, for mesh extraction, we follow 2DGS to use a TSDF-based marching cube strategy. However, TSDF fusion struggles to balance thin structures’ quality and completeness, as figured out by Yu et al. (). Developing a strategy that leverages the properties of Gaussian primitives alongside advanced mesh extraction algorithms could help address this issue. Secondly, although our compression strategy significantly enhances rendering speed, it still lags behind CityGS. Future work should explore deeper optimizations of rasterizers, such as those proposed by Feng et al. (), or the integration of Level of Detail (LoD) techniques Kerbl et al. (); Ren et al. ().

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: How were the baseline hyper-parameters tuned? It seems to me that the OOM and convergence may be overcome by the best set of hyperparameters in few of the existing models. 

How did the authors design the new techniques? I’m curious as to what led to the decisions of such new optimization techniques that are helpful, instead of other potential choices that may be similar in results.
soundness: 2
strengths: The paper solves one of the tougher remaining challenges in 3D reconstruction with Gaussian Splatting: large scale scene reconstruction. The qualitative and quantitative results of the paper are outstanding. Compared to existing baselines, the paper demonstrates faster convergence, more accurate photo-realistic reconstruction and lower memory usage. 
Moreover, the reviewer appreciates additional contributions such as new evaluation criteria that better captures geometric details of larger scenes. The paper spends a lot of effort on being fair on evaluation. The method compares with all SotA methods that the reviewer is aware of.
summary: This paper presents CityGaussianV2, a new method for large-scale 3D scene reconstruction that builds on a variant of Gaussian Splatting, 2D Gaussian Splatting.
CityGaussianV2 introduces 3 contributions to resolve scaling problem in large scale scene reconstruction. 1) Depth supervision which uses pre-trained depth estimator to supervise inverse depth, 2) decomposed-gradient-based densification (DGD) which adaptively densifies based on SSIM, and 3) elongation filter to accelerate convergence and mitigate the Gaussian count explosion problem. 
In addition to the core technical contributions, the paper presents an optimized parallel training pipeline and new evaluation protocol for large-scale scenes that addresses the limitations of existing benchmarks by accounting for boundary effects.
weaknesses: The technical novelty of the paper seems rather weak. The paper is built on top of existing works: 2D GS, Depth anything. While the paper has demonstrated a good way to fuse these existing works in a nice scalable manner, the provided contributions seem like multiple ad-hoc solutions to circumvent an underlying core problem: solving densification in a scalable way. 

In other words, the reviewer expects solid theoretical reasoning on why their optimization techniques are justified, instead of relying on empirical demonstration of good qualitative results. Otherwise, it is hard to justify whether the contributions of the work provided by authors are coming from meta-fine tuning of the existing 3D reconstruction dataset, or whether they are actual improvements.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Please see the weaknesses.
soundness: 3
strengths: The manuscript is well-constructed, with a logical flow that enhances readability. 

The use of technical terminology is appropriate, and complex concepts are elucidated with commendable clarity. The integration of innovative techniques like DGD and the Elongation Filter is particularly noteworthy, as these elements not only speed up training convergence but also refine rendering quality, effectively mitigating the Gaussian number explosion issue often seen in 3D Gaussian Splatting of large-scale scenes.
summary: This paper presents CityGaussianV2, a novel methodology for 3D scene reconstruction tailored for large-scale urban environments. It builds on the 2D Gaussian Splatting technique by incorporating advanced features such as Decomposed-Gradient-based Densification, depth supervision, and an Elongation Filter. These enhancements collectively aim to improve geometric accuracy and reduce computational demands.
weaknesses: 1. The manuscript explores outdoor reconstruction, yet it does not fully address the incorporation of techniques for improving robustness against variable lighting conditions and viewing angles. Techniques similar to the decoupled appearance models used in GOF could potentially bolster the system's adaptability.

2. The proposed method employs an Elongation Filter to prevent excessive Gaussian numbers, but it lacks a mechanism for handling cases where splitting is necessary. Will directly limiting the Gaussian split result in some areas being under reconstruction? At the same time, why does the number of Gaussians in the method plus an Elongation Filter in Table 2 exceed the baseline? Shouldn't the filters be limited to the number of Gaussian functions?

3. There appears to be a discrepancy between the Gaussian count reported in Figure 3 and the data presented in Table 2. The number of CityGaussian is less than that of the author's method (w Elongation Filter), it is inconsistent with the results shown in Table 2. 

4. The limitations are only briefly touched upon in the appendix. A detailed examination within the main body of the paper would provide a more balanced perspective and foster a clearer understanding of the method's scope and potential constraints.

5. The metrics presented in Table 2 (e.g., number of Gaussians, processing time, memory usage) should specify the units of measurement to aid in interpretation.

---

confidence: 5
contribution: 3
initial_rating: 8
presentation: 4
questions: See above
soundness: 3
strengths: The authors address critical issues in adapting Gaussian splitting techniques in large-scale 3D reconstructions. The proposed framework addressed issues related to scalability as well as reducing the costs associated with training large-scale Gaussian splitting models. The results of the proposed model show that the method is able to scale up CityGaussian without degrading visual quality and geometric accuracy. The paper is well-written and the ideas are well explained. The experimental evaluation is complete and supports the claims in the paper. The authors also provide ablation studies to support their design choices.
summary: The authors propose an optimization framework for Gaussian splitting, to address scalability issues when reconstructing large-scale scenes. The proposed framework builds on top of CityGaussian and is named CityGaussianV2 but addresses convergence and scalability issues. They propose the use of DGB densification and depth regression to improve blurry artifacts and accelerate convergence, an elongation filter to mitigate the Gaussian count explosion in 2DGS and a parallel training technique to improve training times and memory consumption.
weaknesses: Minor weaknesses overall 
1) The novelty of the paper is limited but addresses a very important aspect of large-scale 3D reconstruction using gaussian splitting.

2) Lines 189-190 It looks like R and S symbols are flipped assuming that R is rotation and S is scaling then the decomposition of the covariance matrix makes sense. 

3) Line 352-352 How do you estimate the ground plane? Could you provide some more details about the number of points, the scale of the scene, and the hardware used so that this process can be completed in 1 minute?

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Apart from the weaknesses mentioned, there are some additional questions:
1. When running the baseline models, was the same hardware used (8 A100 GPUs)? This information should be included in the paper.
2. While the reconstruction quality surpasses CityGS, the rendering quality is slightly inferior across all datasets. What could be the potential reason for this?
soundness: 3
strengths: 1. The paper is clearly written.
2. It implements a comprehensive process for large-scale surface reconstruction, addressing issues in previous methods with thoughtful design, offering a substantial engineering contribution.
3. The paper conducts thorough ablation studies, analyzing the impact of each module on rendering, reconstruction quality, training time, storage requirements, and other factors.
4. The establishment of a large-scale geometry reconstruction benchmark is also a significant and meaningful contribution.
summary: The paper proposes a large-scale scene geometry reconstruction method based on Gaussian splatting. Specifically, it implements parallel training and compression for 2D Gaussian splatting, incorporates regression based on Depth Anything V2, and designs an Elongation Filter along with a Decomposed-Gradient-based Densification. Additionally, the paper establishes a benchmark for large-scale scene geometry reconstruction for evaluation purposes. The paper demonstrates through comparison experiments that its method achieves superior reconstruction quality on large-scale scenes.
weaknesses: 1. The method comprises multiple combined modules, some of which are known techniques or modified versions of known techniques, so overall, the novelty is somewhat limited. Moreover, the ablation results suggest that some modules have only minor impacts.
2. In the comparison experiments, the authors should also include metrics such as the number of Gaussians, training time, and memory usage for each method, in addition to rendering and reconstruction quality. For certain baseline methods like 2DGS, adjusting hyperparameters can increase the number of Gaussians to enhance the results. The authors should demonstrate that their method has advantages in rendering and reconstruction quality compared to baselines under similar training times and storage usage; otherwise, the results are not fully convincing.

Meta-review: This paper presents an optimization framework for Gaussian splatting for addressing the scalability issue in reconstructing large-scale scenes. Built upon the top of CityGaussian, it improves the convergence and scalability issues by the Decomposed-Gradient based Densification (DGD) and Elongation filter. The major strength of the paper is a careful implementation with thoughtful design for realizing the Gaussian splatting for large-scale scenes. The weakness is that the work comprises multiple combined modules that are either known or modified, thus the novelty is somewhat limited. There was an extensive discussion among reviewers and authors particularly about the novelty aspect, and it was agreed that this work is not a straightforward integration of the existing knowledge and agreed that it is a carefully designed working solution for the challenging problem of Gaussian splatting for large-scale scenes. The AC agreed with the reviewers' positive opinions and reached this recommendation.

Decision: Accept (Poster)