acceptodds
Under review as a conference paper at ICLR 2027

ccSplat for Compact and Compressed Feed-Forward 3D Gaussian Splatting

Abstract

We present ccSplat, a framework for reducing the Gaussian count and storage cost of pixel-aligned feed-forward 3D Gaussian Splatting. Dense prediction can produce over a million primitives per scene. Reducing their count requires preserving surface coverage, while coding the remaining attributes requires exploiting their redundancy. ccSplat connects these tasks through the pixel addresses of retained Gaussians. Its compaction module learns rendering importance, selects candidates under a coverage-aware count budget, and adjusts their scales with a refinement head. The backbone remains frozen. The codec uses the retained pixel grid to recover sparse locations and predict attributes, then allocates rotation precision according to decoded Gaussian shape. On nine Mip-NeRF 360 scenes with SHARP, ccSplat reduces the mean Gaussian count from 1.18M to 0.30M and mean storage from 66.06 to 2.45 MB, a 27.0× storage reduction. Source-view PSNR changes from 27.63 to 27.26 dB after compaction and compression. Additional experiments evaluate compaction on multi-view AnySplat outputs before voxel fusion.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
3D Gaussian Splatting, Feed-Forward 3D Reconstruction, Gaussian Pruning, Gaussian Compression

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_E8QwOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper presents ccSplat, a compaction and compression framework for feedforward 3DGS. It selects Gaussian primitives under a fixed budget using learned importance prediction, coverage-aware selection, and scale refinement. The retained primitives preserve their original pixel correspondence, which is then used to predict and encode Gaussian attributes from the input image and neighboring grid locations. The method is evaluated on SHARP and AnySplat for both compaction and compression.

Critical strengths

1.The method makes good use of the pixel-aligned structure of feedforward 3DGS. The retained pixel addresses are shared across attribute organization, context prediction, and position recovery. Figure 8 verifies the coding benefit of preserving the native pixel layout under identical reconstruction.

2.The experiments cover both single-view and multi-view backbones, including codec comparisons on the same compact input, RD curves, and component ablations. On SHARP, ccSplat reduces the Gaussian count by approximately 4x and the storage by 27x, with only a 0.37 dB drop in source-view PSNR.

Critical weaknesses

1.The rate-distortion benefit of the proposed selection strategy within the full compaction-compression pipeline has not been sufficiently validated. The compaction stage selects primitives based on rendering error and a Gaussian-count budget, without considering the coding cost of the retained primitives. Table 1 compares different selectors only by image quality at a budget of approximately 300K Gaussians, whereas Table 2 and Figure 4 compare codecs using only the output selected by ccSplat. Figure 8 demonstrates the coding benefit of the native pixel layout for a given Gaussian set, but does not compare different selected sets encoded with the same codec. The current results therefore support the value of preserving pixel correspondence for coding, but do not establish whether the proposed selection strategy gives a better end-to-end rate-distortion trade-off than other selectors. This makes it difficult to identify the source of the final performance gains.

2.The current experiments do not sufficiently isolate the contribution of the proposed compaction strategy. In the SHARP experiment, RAP is applied using its released importance-prediction weights with a DC-only attribute adapter, whereas ccSplat trains its importance head for the SHARP backbone. Although a selector-specific scale-refinement head is trained for RAP, its importance predictor is not retrained under the same setting. In the AnySplat experiment, ccSplat’s per-view selection before fusion is compared with the original voxel-fusion output, so both the processing pipeline and the Gaussian count differ. These results demonstrate the performance of the complete systems, but a selector comparison with matched training, input, and budget settings is still missing.

Questions for authors

1.Could the authors apply the same codec to the outputs of different compaction methods under the same backbone and Gaussian budget? For example, the ccSplat codec could be used to encode the outputs of ccSplat and RAP with refinement, with full rd curves reported for both.

2.Could the authors report per-scene storage and image-quality results? This would be particularly helpful for AnySplat, where ccSplat and LGSCV differ by only 0.06 MB and 0.08 dB in PSNR at the representative operating point.

3.Could the authors provide a compaction comparison with matched training adaptation? For example, the RAP importance predictor could be retrained or fine-tuned using the same training data and SHARP outputs as ccSplat. Each selector could then use its own scale-refinement head and be evaluated under the same budget.

2 comments
AuthorsOpenReview ↗

Response (1/2): Selector RD and RAP Adaptation

W1/Q1: Different selectors encoded with the same codec

Response: Thank you for suggesting a comparison of different selectors using the same codec. In this comparison with a common codec, ccSplat provides higher rendering quality at similar bitstream sizes. For example, at one tested operating point, ccSplat has a size of 2.096 MB and a source view PSNR of 27.129 dB against ground truth. Fine tuned RAP with its corresponding scale refinement uses 2.196 MB at 26.695 dB. Their novel view PSNR values relative to dense SHARP are 37.014 and 32.049 dB, respectively.

We have added RD curves for six selectors: Opacity, opacity-scale proxy, Vox, fine tuned RAP, fine tuned RAP with its corresponding scale refinement, and ccSplat. They use SHARP predictions with a budget of approximately 300K Gaussians and are encoded with the same codec. We report both source view quality against real ground truth and novel view fidelity relative to dense SHARP.

Even when selectors retain similar numbers of Gaussians, their compact point clouds differ in rendering quality. These differences remain after coding with the same codec, leading to similar bitstream sizes but substantially different quality. The RD comparison with a common codec measures the actual size and quality after coding these retained sets, providing empirical evidence for the tradeoff of the full pipeline.

The main curves are in Fig. 5(b) (p. 7, line 377), with the discussion in Section 4.2 (lines 358 to 365). Fig. 16 in the appendix provides the complete quality metrics (p. 23, lines 1212 to 1213). Fig. 17 reports the original five common coding configurations for all selectors (lines 1239 to 1240).


W2/Q3: RAP adaptation and corresponding scale refinement

Response: Thank you for suggesting a comparison after adapting RAP. We have fine tuned RAP's importance predictor and trained a corresponding scale refinement head for each of the public and fine tuned RAP versions. With common test inputs, cameras, and a budget of approximately 300K Gaussians, public RAP has a source view PSNR of 24.376 dB, which increases to 25.261 dB after fine tuning. Their respective scale refinement heads increase these values to 25.944 and 26.716 dB, while ccSplat has a PSNR of 27.332 dB. Table Q1 reports all four quality metrics.

Fine tuning uses outputs from frozen SHARP and data from DL3DV, Getty, OpenScene, and Tanks and Temples. The training data are exactly the same as those used to adapt ccSplat. Mip-NeRF 360 is used only for testing. The importance predictor is updated for 15,000 steps, and each scale refinement head is updated for 10,000 steps, so that both the public and fine tuned importance predictors have scale refinement heads trained for their respective selections.

Keeping both public and fine tuned results makes the gains from adaptation and their corresponding scale refinement directly comparable.

The AnySplat comparison also reports both the original voxel fusion output and the representation obtained by compacting the grids from individual views. The former contains an average of 1,109,451 Gaussians, while the latter retains at most 300K. This comparison includes changes in both the pipeline and the Gaussian count and evaluates the complete systems. Table 3 additionally reports EcoSplat, Off The Grid, and AdaptiveSplat at similar Gaussian budgets, providing a further system comparison at approximately 300K Gaussians (p. 8, line 426).

The RAP adaptation procedure is in Appendix E.1 (p. 20, lines 1063 to 1069). Quality results are also reported in Table 1 (p. 6, lines 296 to 297) and Table 10 in the appendix (p. 21, line 1080). The complete source view and novel view crop comparisons are in Fig. 14 (p. 21, lines 1114 to 1116) and Fig. 15 (p. 22, lines 1156 to 1158), respectively.

Table Q1. Source view comparison of selectors based on SHARP. Quality is measured against the input image; actual Gaussian counts are listed.

MethodGaussiansPSNR↑SSIM↑LPIPS↓DISTS↓
SHARP117964827.6310.8530.0840.038
Opacity30000021.4700.6350.2740.172
Opacity-scale proxy30000021.4200.5820.4240.188
Vox30000021.8840.6130.3420.194
RAP public30000024.3760.7360.1880.114
RAP public + refinement30000025.9440.7710.1890.099
RAP tuned30000025.2610.7820.1490.106
RAP tuned + refinement30000026.7160.8090.1520.090
ccSplat29933427.3320.8360.1130.051
AuthorsOpenReview ↗

Response (2/2): Results by Scene

Q2: Size and image quality for each scene

Response: Thank you for suggesting results for each scene. We have added the complete bitstream size and image quality results for each scene to the appendix, as the full tables are lengthy. We would be grateful if you could refer to the tables cited below for the detailed results. Table 13 compares ccSplat and LGSCV on the same AnySplat test views at their respective representative operating points (Appendix E.5, p. 24, lines 1284 to 1285).

Across the five AnySplat scenes in Table 13, ccSplat has slightly higher PSNR than LGSCV in every scene, while the tradeoff in size varies by scene. For example, the sizes for bonsai are 4.849 and 5.025 MB, respectively. For garden, they are 5.907 and 5.494 MB, with PSNR values of 19.490 and 19.459 dB.

Tables 16 and 17 in Appendix E.7 report representative operating points for all codecs on each AnySplat and SHARP scene, including size, PSNR, SSIM, and LPIPS (p. 26, line 1355, and p. 27, line 1404, respectively).

Reviewer_yDgiOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes a new approach to compacting and compressing 3D Gaussian splatting, with a focus on feed-forward 3DGS. This is impactful because feed-forward Gaussian splatting reconstructs millions of Gaussians. A compact representation is needed to allow for efficient data storage and transmission. In this work, the authors propose to exploit the pixel-aligned property of feed-forward models. This additional knowledge of the pixel-aligned representation is used to optimise the pruning and recovery strategy. Furthermore, the pixel grid and its neighbouring context are used to optimise the compression strategy. The technique is validated for both monocular and multi-view backbones, and shows improved performance for the baseline 3DGS scene.

Critical strengths
  • The technique looks promising and shows improvements for both compaction and compression, specifically for feed-forward 3D Gaussian splatting approaches.
  • Good compression and compaction of 3DGS scene data (albeit only for feed-forward in this case) is a very important and highly impactful research topic for the research community and the practical needs of industry.
  • The evaluation is conducted using different baselines for both single-camera and multi-camera backbones.
Critical weaknesses
  • The text is very hard to follow. For example, from the introduction, it is unclear whether joint compaction and compression are directly integrated into the feedforward model or are performed as a post-processing operation. Only when viewing the overview figure did it become clear that it is the latter. Furthermore, it should also be put into more context how this type of compression and compaction relates to approaches that work on vanilla Gaussian splatting. Overall, even for a semi-expert in the field, it dives right in and assumes some background in feedforward Gaussian splatting. I would advise giving more background. Especially the methodology section is a hard nut to crack. I miss a bit of the intuitive explanation of the different aspects of the method and why certain heuristics are needed to make it work. It is now described from a mathematical perspective, but it lacks the intuition that gives a reader the ‘aha’ moment.
  • As it is implemented as a post-processing step of the feedforward model, it still retains a high memory footprint during feed-forward generation of the scene.
  • Section 3.2 (Coverage-aware selection) : The coverage-aware selection uses a number of hyperparameters (see Appendix A). How were these hyperparameters chosen? What are their values? Were they tuned on a separate held-out set?
  • Section 3.3 (Compression on the retained pixel grid): This section provides too little detail to fully understand the method. Lots of terminology that is never explained or motivated (or only partly available in the appendix), e.g. among others: “The opacity stream carries opacity values and identifies the retained addresses”.
  • Experiments 4.2: There is a lack of analysis and visualizations on non-source-view renders on SHARP. Table 1, Table 2, Figure 3 and Figure 5 all appear to be analyzed on source-views. Only Figure 4 shows results for novel views in the main paper, but only for compression, not compaction. A comparison of PSNR and visual quality of ccSplat on novel views against dense SHARP and the other methods in Table 1 would be needed to assess how well ccSplat works in practice. This is partly done in Table 6 and Figure 9 in Appendix D, but visual comparisons and comparisons with the baselines in Table 1 are missing.
  • Overall, there are many heuristics and hyperparameters that are not always clearly explained. As such, I have concerns about the method's reproducibility. For example, where do the depth, opacity, scale, and coverage cues come from?
Questions for authors
  • Can you define exactly what the LightGaussian-style proxy does? Why use a proxy instead of the original method? Appendix C does not state this clearly. The results of LightGaussian in Figure 3 also look worse than expected.
  • Why are the "RAP selector" and the "RAP + selector-specific scale refinement" results not shown in Figure 3? Since they come closest to the ccSplat results, a visual comparison would be useful. Similarly, the "No refine" and "Vox" numbers are not reported in Table 1.
  • Are there different levels of compression possible? For example, if you want to target a certain loss in quality
  • Fig 1: The right image shows a comparison between dense, compact, and compact+compressed. Why are the differences between compact and compact+compressed not shown in the graphs on the left, with respect to dense?
  • Could this work also be extended to non-feedforward 3DGS in future work?
  • Could this approach be integrated directly into the feedforward model in the future as well, or is it always post-processing? Allowing for faster inference of the feedforward model and avoiding an intermediate spike in memory?
  • How does exploiting a pixel grid representation, typically used in feedforward, compare to a more generic voxel grid often used within 3DGS for compaction and compression? Aren’t there overlaps in paradigm? Could you, for example, see this as a more specific case of a camera-aligned grid?
  • Can a video be added as supplementary material to demonstrate the compression performance?
8 comments
AuthorsOpenReview ↗

Response (1/6): Workflow and Generation Memory

W1: Overall workflow and method intuition

Response: Thank you for pointing out that the overall workflow and the intuition behind the method need to be clearer. After the frozen feedforward backbone produces dense Gaussians, lightweight importance and scale refinement heads use features aligned with the input pixels, together with Gaussian attributes, to select Gaussians and adjust their scales. A separate codec then encodes the retained representation. For a new scene, backbone prediction and compaction are completed in a single forward pass. The encoder then produces a bitstream containing the information needed for decoding on the client. During training, the backbone is frozen and only the two added heads are updated.

This design uses the existing correspondence between feedforward Gaussians and source image pixels. Compared with 3DGS representations optimized for each scene, which usually require attribute reorganization, feedforward predictions already provide usable pixel indices. We preserve these indices through compaction and coding so that the compact representation remains associated with the input image and its neighborhoods.

The roles of the components follow this workflow. Selection by importance removes redundancy, the coverage aware budget allocation distributes Gaussians across image regions, and scale refinement compensates for gaps in coverage after pruning. The retained pixel addresses then provide a shared index for all attributes and connect color prediction conditioned on the image with position prediction from decoded neighbors. These explanations now precede the corresponding equations so that readers can understand the purpose of each step before its mathematical definition.

We clarify the data flow in the Introduction (p. 2, lines 67 to 81) and at the start of the method (p. 3, lines 134 to 137). The overview is in Fig. 2 (p. 3, lines 156 to 161). The component explanations are in Section 3.2 (p. 4, lines 196 to 202), Section 3.3 (p. 5, lines 226 to 239), and the paragraph on shape adaptive quantization (p. 5, lines 241 to 246).


W2: Peak memory during generation

Response: Thank you for raising the memory issue during generation. The current pipeline first generates dense candidates, so peak memory during generation is still determined by the backbone. Compaction and coding reduce the costs of storing, transmitting, and subsequently rendering the representation.

Our target application uses a server to generate the scene representation and a client to receive and render it continuously. Compaction and coding are performed on the server, and the smaller representation is transmitted to the client. Under the same rendering measurement conditions, a representation with approximately 300K Gaussians renders faster than the dense representation, reducing the cost of continuous rendering on the client.

We state the memory requirement of dense generation in the Limitations (p. 10, lines 531 to 534). Rendering times are in Table 15 in the appendix (p. 25, line 1315).

AuthorsOpenReview ↗

Response (2/6): Selection Parameters and Codec Details

W3: Hyperparameters for coverage aware selection

Response: Thank you for asking about the hyperparameter choices and reproducibility. These parameters were set based on design experience and were not tuned on a separate held out set. Their purpose is to balance regions with high rendering importance and spatial coverage under a fixed Gaussian budget. Table P1 lists the full configuration.

Local importance is estimated over a 5 by 5 neighborhood. A coefficient of 0.25 controls compensation in regions with insufficient local coverage, giving the adjusted score p′=p[1+0.25(1−AvgPool⁡5×5(p))]p'=p[1+0.25(1-\operatorname{AvgPool}_{5\times5}(p))]. Image tiles of size 8 by 8 provide candidates distributed across different regions. At most 25% of the second layer's budget is allocated to candidates that supplement surface coverage; the remaining slots are filled by ranking importance scores.

The target retention ratios for the two layers are approximately 0.05 and 0.45, corresponding to about 30K and 270K Gaussians, for a total budget of 300K. In the support score, the weights for individual opacity, the sum of opacity across the two layers, and depth smoothness in the second layer are 0.25, 0.10, and 0.10, respectively.

The score definitions and budget allocation are explained in Appendix A (p. 14, lines 707 to 723). We will also release the corresponding configuration for reproducibility.

Table P1. Configuration for coverage aware selection.

ParameterValue
gate_modestraight_through_topk
topk_ratio_layer10.05
topk_ratio_layer20.45
target_ratio_layer10.05
target_ratio_layer20.45
tile_size8
tile_min_keep1
support_tile_size8
support_tile_min_keep_layer10
support_tile_min_keep_layer21
support_budget_ratio_layer10.0
support_budget_ratio_layer20.25
coverage_diversity_weight0.25
coverage_kernel_size5
threshold0.5
rich_aux_featuresTrue
aux_channels14
support_opacity_weight0.25
support_opacity_union_weight0.1
support_layer2_depth_smoothness_weight0.1

W4: Addresses, support, and decoding dependencies

Response: Thank you for pointing out that the terminology and decoding dependencies need to be clearer. The nonzero positions in the opacity stream identify the retained addresses and also carry the quantized opacity values at those positions. All other attributes share the same retained addresses. An address specifies the source view, layer, and pixel position associated with a Gaussian.

On the original pixel grid, a removed position has an opacity code of zero, while a retained position has a quantized code of at least one. After lossless coding of these integer symbols, the decoder recovers the retained positions, or support, from the nonzero positions and obtains their quantized opacity values. Numerical error in opacity is determined by its quantization precision. Other attributes are encoded in a shared order of layer, row, and column, and placed back on the sparse grid using the same support. This preserves the correspondence across attributes during decoding.

The RGB image used for color prediction is also compressed and included in the bitstream, and its size is counted in the total rate. The encoder and decoder both use pixels from the decoded image for prediction. Position prediction uses already decoded neighbors to the left, above, and upper left. Missing neighbors do not participate in the calculation. If no neighbor is available, the midpoint of the quantization interval is used. Rotation precision is determined by decoded scales. This dependency order makes the required decoding context available at each step.

Support recovery is clarified in Section 3.3 (p. 5, lines 218 to 224). Prediction dependencies are described on p. 5, lines 226 to 239, and the full decoding order is in Appendix B.3 (p. 16, lines 841 to 843).

AuthorsOpenReview ↗

Response (3/6): Novel View Evaluation

W5: SHARP results beyond the source view

Response: Thank you for suggesting a stronger analysis of views other than the source view. We have added novel view crops comparing different selectors against dense SHARP, as well as results for SHARP, compaction, and compaction followed by coding against real held out ground truth.

The novel view images use dense SHARP as the reference. The full comparison includes Opacity, opacity-scale proxy, Vox, public and fine tuned RAP, and the corresponding scale refinement versions of RAP. Nearby view crops are provided for the main methods and for the full set of RAP versions. All methods use the same camera and crop, and the main objects correspond to those in the source view comparison. Corresponding source view crops are also provided.

Table N1 reports PSNR, SSIM, LPIPS, and DISTS for dense SHARP, the compact representation, and the compact and coded representation, covering views within 5 degrees, within 10 degrees, and all test views. For example, within 5 degrees, the PSNR values for the three stages are 15.558, 15.548, and 15.548 dB, and the LPIPS values are 0.464, 0.490, and 0.491. PSNR at nearby views remains close to dense SHARP, while compaction introduces perceptual error and the additional change from coding is small. The full images show geometric displacement. Errors in the monocular geometry and camera alignment of dense SHARP affect pixel correspondence. Together with the fidelity evaluation relative to dense SHARP, these results help explain the additional changes introduced by compaction and coding.

We also retain the multiview AnySplat comparison. Table S1 and the corresponding crops compare sparse methods against real held out ground truth, providing additional evidence on reconstruction quality from multiple input views.

The relevant locations are as follows.

  • Novel view crops for the main methods are in Fig. 4 (p. 7, lines 335 to 336). The full RAP comparison is in Fig. 15 in the appendix (p. 22, lines 1156 to 1158).
  • The real ground truth evaluation protocol is in Appendix E.4 (p. 24, lines 1260 to 1267), and the three stage results are in Table 12 (line 1268). The analysis is on p. 8, lines 399 to 404, and the full images are in Fig. 7 (line 417).
  • Corresponding source view crops are in Fig. 3 (p. 6, lines 320 to 321) and Fig. 14 (p. 21, lines 1114 to 1116). AnySplat crops are in Fig. 8 (p. 9, line 439).

Table N1. Three SHARP stages against real held out ground truth.

RangeRepresentationPSNR↑SSIM↑LPIPS↓DISTS↓
AllSHARP11.1870.1450.7370.351
Allcompact10.8910.1280.7560.363
AllccSplat10.9010.1280.7570.363
≤10°SHARP14.8550.2650.5040.158
≤10°compact14.7340.2610.5200.167
≤10°ccSplat14.7360.2600.5200.169
≤5°SHARP15.5580.3110.4640.126
≤5°compact15.5480.3120.4900.144
≤5°ccSplat15.5480.3110.4910.145

Table S1. Sparse multiview reconstruction against ground truth.

MethodGaussiansPSNR↑SSIM↑LPIPS↓
AnySplat110945120.7900.6080.242
EcoSplat29999615.8440.3610.560
Off The Grid30003220.0380.5850.339
AdaptiveSplat32119218.6170.4520.527
ccSplat30000022.9360.6810.242
Reviewer_kaQaOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes ccSplat, a framework that compacts and compresses the pixel-aligned outputs of frozen feed-forward 3DGS backbones. Two lightweight heads perform the compaction: an importance head supervised by a per-Gaussian removal teacher selects Gaussians under a coverage-aware budget, and a refinement head rescales the retained Gaussians. All retained Gaussians keep their original pixel addresses.

The codec then exploits this preserved grid in three ways. Opacity doubles as the support map, so no index stream is needed. Color is predicted from a compressed copy of the input image. Positions are predicted from decoded grid neighbors. Rotation precision is allocated according to the decoded Gaussian shape.

On SHARP (nine Mip-NeRF 360 scenes), ccSplat reduces 1.18M Gaussians and 66.06 MB to 0.30M and 2.45 MB, with source-view PSNR dropping from 27.63 to 27.26 dB. Additional experiments on AnySplat cover the multi-view setting.

Critical strengths

A simple, well-supported insight that links compaction and compression. The native pixel grid of feed-forward 3DGS provides free ordering, support, and image context for coding. The controlled layout experiment (Fig. 8 / Table 7) reconstructs identical attributes under every layout and shows clear savings over Morton and PLAS layouts. The RGB-disabled control further isolates where the gain comes from. Together these make the central claim credible and potentially useful for other pixel-aligned pipelines. A practical and effective pipeline. The backbone stays frozen, the heads are lightweight, and the method applies to both monocular and multi-view backbones. The method achieves a 27× storage reduction with a small source-view quality drop, and its codec outperforms SOGS, FCGS, and LGSCV at the representative operating points on the same compact input.

Critical weaknesses

Rendering quality is not compared against sparse feed-forward 3DGS methods at the same budget. The method stays on the pixel grid: refinement only rescales retained Gaussians, while their centers and other attributes remain fixed at the dense predictions. Sparse feed-forward methods, such as SparseSplat, AnchorSplat, Off The Grid, and EcoSplat, instead learn where to place a limited set of primitives. These methods may therefore use the same budget more effectively for rendering. The paper compares compaction only against post-hoc pruning baselines and AnySplat’s voxel fusion. As a result, it remains unclear how much rendering quality the grid constraint costs in exchange for coding efficiency. This is the key trade-off behind the paper’s claim that the grid should be preserved. The evaluation favors the proposed setting. The SHARP results rely mainly on source-view metrics. Novel views are compared only against dense SHARP renderings within ±10°, not against the real held-out GT views that Mip-NeRF 360 provides. Gaussians that are occluded in the source view but visible elsewhere are exactly what aggressive pruning may remove, and the current protocol would not reveal such losses.

Questions for authors

At a matched budget of about 300K Gaussians, how does ccSplat compare with EcoSplat and/or SparseSplat (or AnchorSplat) on GT held-out views? If sparse methods render noticeably better, how should this trade-off against coding efficiency be interpreted? This comparison would most affect my assessment. Can you report compaction and compression results on GT held-out Mip-NeRF 360 views for SHARP, beyond the ±10° teacher-fidelity protocol? (Clarification) How is the removal teacher in Eq. 2 computed in practice, and what is its training cost? Please also report encoding, decoding, and rendering times.

2 comments
AuthorsOpenReview ↗

Response (1/2): Sparse Baselines and Novel Views

W1/Q1: Sparse feedforward methods at a comparable Gaussian budget

Response: Thank you for suggesting these comparisons. We have added a multiview comparison with EcoSplat, Off The Grid, and AdaptiveSplat, targeting approximately 300K Gaussians and evaluating PSNR, SSIM, and LPIPS-VGG on the same test subsets and ground truth images. Table S1 below summarizes the actual Gaussian counts and reconstruction quality, with AnySplat's original voxel fusion output also included as a reference. These results are also reported in Table 3 of the revised manuscript (p. 8, line 426).

Under the reproduced settings, ccSplat has a PSNR of 22.936 dB and an SSIM of 0.681, compared with 20.038 dB and 0.585 for Off The Grid. Fig. 8 (p. 9, line 439) compares the same target view and image regions. These results show that preserving pixel correspondence can support both rendering quality and subsequent coding at a budget of approximately 300K Gaussians.

We have added the motivation for this comparison in Section 4.1 and report the results in Section 4.3. Table 3 also reports the results in Table S1. Fig. 8 uses the same target view and crop for all methods to compare local details and surface appearance. The corresponding locations are p. 6, lines 275 to 282; p. 8, lines 421 to 426; and p. 9, line 439 for Fig. 8.

Table S1. Sparse multiview reconstruction against ground truth.

MethodGaussiansPSNR↑SSIM↑LPIPS↓
AnySplat110945120.7900.6080.242
EcoSplat29999615.8440.3610.560
Off The Grid30003220.0380.5850.339
AdaptiveSplat32119218.6170.4520.527
ccSplat30000022.9360.6810.242

W2/Q2: SHARP quality on real held out views

Response: Thank you for highlighting the importance of evaluating novel views against ground truth. We have added an evaluation of SHARP, the compact representation, and the compact and coded representation against real held out ground truth across all test views. Among these, 95.9% have camera rotations greater than 10 degrees relative to the source view. We also report results for views within 10 degrees and within 5 degrees. Table N1 reports PSNR, SSIM, LPIPS, and DISTS for nine Mip-NeRF 360 scenes, allowing direct comparison of the changes introduced by compaction and coding in views other than the source view.

We restricted the original comparison to nearby views because SHARP is a monocular backbone. Appendix D.6 of the SHARP paper also discusses acceptable rendering quality for camera motion within approximately half a meter relative to a single input image. The paper also notes that errors in SHARP's camera parameter estimates and monocular geometry can spatially displace the rendered image relative to real ground truth. Even when the rendered appearance remains similar, this misalignment can substantially reduce PSNR and SSIM, which depend on pixel correspondence. SHARP discusses this sensitivity in Section 4 and Appendix C.1, where a translation of only 1% causes a large drop in these scores. We therefore also report LPIPS and DISTS to assess perceptual quality alongside pixelwise consistency. We recommend placing greater emphasis on visual quality and perceptual metrics when interpreting these results; we also provide pixelwise metrics such as PSNR.

The original nearby view experiment uses dense SHARP renderings as the reference to measure the additional distortion introduced by compaction and coding. The new experiment directly measures reconstruction quality against real ground truth. Table N1 compares the three stages using PSNR, SSIM, LPIPS, and DISTS. Even the original dense SHARP has low PSNR and SSIM, reflecting the effect of the camera estimation errors discussed above on pixel correspondence. This geometric displacement is clearly visible in Fig. 7 (p. 8, line 417).

Our multiview AnySplat experiments also evaluate real held out views against ground truth. The dense voxel fusion output has a PSNR of 20.79 dB and an SSIM of 0.608, compared with 22.94 dB and 0.681 for ccSplat with 300K Gaussians. This provides further evidence that compaction that preserves pixel organization can maintain competitive novel view quality with multiple input views.

Table N1. Three SHARP stages against real held out ground truth.

RangeRepresentationPSNR↑SSIM↑LPIPS↓DISTS↓
AllSHARP11.1870.1450.7370.351
Allcompact10.8910.1280.7560.363
AllccSplat10.9010.1280.7570.363
≤10°SHARP14.8550.2650.5040.158
≤10°compact14.7340.2610.5200.167
≤10°ccSplat14.7360.2600.5200.169
≤5°SHARP15.5580.3110.4640.126
≤5°compact15.5480.3120.4900.144
≤5°ccSplat15.5480.3110.4910.145
AuthorsOpenReview ↗

Response (2/2): Teacher and Computational Cost

Q3: Removal teacher and training cost

Response: Thank you for asking about the teacher and training cost. Equation (2) defines importance through the change in rendering error when each Gaussian is removed, and uses it to supervise the importance head. Training the two lightweight heads on eight GPUs has a throughput of approximately 1.5 to 2.5 images/s.

Following the definition in Eq. (2), we compute the removal score with the dense Gaussian representation, camera, and supervision image fixed. We compare the squared rendering error of the full representation with that of the representation after Gaussian jj is removed. The difference is δj\delta_j; a positive value means that removing the Gaussian increases the rendering error. We then rank these scores within each layer and select candidates according to that layer's budget, producing a binary teacher mask to supervise the importance head. This supervision is used during training. At test time, the importance head predicts importance scores in a single forward pass.

During training, the backbone remains frozen and only the importance and scale refinement heads are updated. On eight RTX 4090 GPUs, training these two heads processes approximately 1.5 to 2.5 images/s, or 6.6 to 11 minutes per 1,000 images.

The teacher construction is explained in Section 3.2 (p. 4, lines 186 to 194). Head training throughput is reported in Appendix E.6 (p. 25, lines 1328 to 1329).


Q4: Encoding, decoding, and rendering time

Response: Thank you for suggesting that we report computational cost. We have reported encoding, standalone decoding, and rendering times. ccSplat takes 5.461 s to encode and 1.155 s for standalone decoding. The compact representation can also be rendered continuously with less time per frame.

On the same server, FCGS, SOGS, and LGSCV take 5.729, 6.932, and 35.977 s to encode, and 7.159, 2.352, and 6.221 s for standalone decoding, respectively. Table T1a also reports size and quality at these operating points. Table T1b gives the timings and standard deviations for ccSplat in each scene.

The full timing results are in Appendix E.6 (p. 25, lines 1298 to 1304). Codec results are in Table 14 (lines 1306 to 1307), and rendering times are in Table 15 (line 1315).

Table T1a. End to end encoding time, standalone decoding time, and quality at the corresponding operating points for compact SHARP representations. Results are averaged over three scenes.

MethodEnc. (s)Dec. (s)Size (MB)PSNRSSIMLPIPS
FCGS5.7297.1593.27426.1420.7920.126
SOGS6.9322.3522.47225.0120.7840.144
LGSCV35.9776.2212.41627.1560.8590.098
ccSplat5.4611.1552.54927.3670.8740.083

Table T1b. ccSplat timing by scene.

SceneEncode (s), mean ± SDDecode (s), mean ± SDSize (bytes)
bonsai5.351 ± 0.5331.083 ± 0.0192310591
bicycle5.558 ± 0.0541.126 ± 0.0122864752
stump5.475 ± 0.2071.256 ± 0.0522473029

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.