acceptodds
Under review as a conference paper at ICLR 2027

CaliSplat: Sparse Gaussian Fitting and Calibrated Rate Allocation for Image Compression

Abstract

2D Gaussian representations provide an explicit and lightweight alternative for image representation, enabling fast deterministic decoding without a heavy neural synthesis network. However, existing per-image Gaussian codecs still require costly image-specific optimization to determine how limited Gaussian capacity should be distributed across heterogeneous regions. We introduce CaliSplat, an optimization-efficient Gaussian image codec that selectively explores candidate representations and globally allocates a constrained Gaussian budget. We exploit the closed-form reconstruction error of the single-Gaussian case as an inexpensive measure of local difficulty, fitting higher-capacity candidates only in regions where additional Gaussians are likely to be useful. To reduce selection errors caused by mismatched convergence rates across candidate sizes, a small set of longer-horizon fits is used to calibrate short-horizon distortion estimates before global budget-aware selection. The selected representation is then compressed into a bitstream. Across standard and large image datasets, CaliSplat achieves competitive or superior rate–distortion performance while reducing per-image fitting time by – compared with representative Gaussian codecs. It further maintains high-throughput deterministic decoding at – MP/s. These results demonstrate that content-adaptive Gaussian compression can substantially reduce per-image optimization cost while preserving strong reconstruction quality and efficient explicit decoding.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
2D Gaussian Splatting, Image Compression

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_DUDXOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents CaliSplat, a per-image compression framework based on 2D Gaussian representations. The method uses the analytic single-Gaussian reconstruction error to selectively fit higher-capacity candidates, calibrates short-horizon distortion scores using a small number of longer-horizon teacher fits, and performs global Gaussian-budget allocation followed by structured parameter coding. It aims to reduce fitting costs while maintaining reconstruction quality and efficient decoding.

Critical strengths

1)The paper addresses a clear and practically relevant problem. Separating computational effort for candidate fitting from final representation-capacity allocation provides a reasonable approach to reducing redundant per-image optimization. 2)The complete system shows promising performance. The reported fitting times and decoding throughput suggest an attractive trade-off between reconstruction quality and computational efficiency. 3)Several ablations are well motivated. Comparisons against exhaustive fitting, random candidate selection, and spatially shuffled allocations support the value of selective search and content-adaptive capacity allocation.

Critical weaknesses

1)The calibration target is misaligned with the final encoded representation, and a critical ablation is missing. Calibration predicts the distortion of 160-step teacher fits, whereas the final codec retains the 40-step candidate parameters without any reported post-selection refinement. The paper does not explain this mismatch or establish the practical benefit of calibration through a controlled comparison with uncalibrated allocation using the same candidate bank.

2)The rate-distortion comparison protocol is insufficiently transparent. The main tables and qualitative comparisons do not specify actual bitrates or how operating points are matched. The correspondence between the high-rate values and method rankings in Table 1 and Figure 4(a) also requires clarification.

3)The efficiency evaluation lacks essential details and a directly relevant baseline. Hardware configurations, timing boundaries, and baseline optimization settings are insufficiently specified, making the reported speedups and their sources difficult to assess. Instant GaussianImage, discussed in the introduction as a fitting-acceleration method, is omitted from the comparisons without explanation.

4)The existing ablations do not sufficiently isolate individual contributions. The allocation study mainly compares against uniform and random strategies under matched Gaussian counts, which does not establish the advantage of the proposed allocation algorithm at matched actual bitrates. The parameter-coding ablation reports bitstream reductions without verifying whether reconstruction quality remains unchanged.

5)valuation coverage and sensitivity analysis are limited. The large-image evaluation contains only nine images, with insufficient information about sample selection and image resolutions. End-to-end sensitivity analyses for fitting iterations, teacher sample counts, and candidate-retention ratios are also missing, limiting the evidence for stability and scalability.

Questions for authors

1)The calibration target is misaligned with the final encoded representation, and a critical ablation is missing. Calibration predicts the distortion of 160-step teacher fits, whereas the final codec retains the 40-step candidate parameters without any reported post-selection refinement. The paper does not explain this mismatch or establish the practical benefit of calibration through a controlled comparison with uncalibrated allocation using the same candidate bank.

2)The rate-distortion comparison protocol is insufficiently transparent. The main tables and qualitative comparisons do not specify actual bitrates or how operating points are matched. The correspondence between the high-rate values and method rankings in Table 1 and Figure 4(a) also requires clarification.

3)The efficiency evaluation lacks essential details and a directly relevant baseline. Hardware configurations, timing boundaries, and baseline optimization settings are insufficiently specified, making the reported speedups and their sources difficult to assess. Instant GaussianImage, discussed in the introduction as a fitting-acceleration method, is omitted from the comparisons without explanation.

4)The existing ablations do not sufficiently isolate individual contributions. The allocation study mainly compares against uniform and random strategies under matched Gaussian counts, which does not establish the advantage of the proposed allocation algorithm at matched actual bitrates. The parameter-coding ablation reports bitstream reductions without verifying whether reconstruction quality remains unchanged.

6)valuation coverage and sensitivity analysis are limited. The large-image evaluation contains only nine images, with insufficient information about sample selection and image resolutions. End-to-end sensitivity analyses for fitting iterations, teacher sample counts, and candidate-retention ratios are also missing, limiting the evidence for stability and scalability.

3 comments

W1&Q1

Thank you for raising this concern. Fig. 3(b) of the paper shows why we use a longer fitting horizon for scoring. For the same block, the K=12K=12 candidate has lower distortion at 40 steps, and the K=16K=16 candidate has lower distortion at 160 steps. This reversal shows that early rankings can depend on how quickly candidates converge. We use sampled 160-step fits to calibrate the scores that guide the choice of partition and Gaussian counts. After selection, the encoder directly quantizes and codes the stored 40-step parameters.

To test whether these scores improve the image we actually decode, we added a controlled ablation on the standard-image set. At each rate setting, all three variants use the same 40-step candidate bank, Gaussian-count budget, tree search, and coding settings. We vary only the allocation score. The 160-step reference measures long-fit distortion for every admitted candidate with K>1K > 1 and also encodes the selected 40-step fits.

Allocation scoreDecoded PSNR (dB) ↑MS-SSIM ↑Agreement with 160-step ranking ↑Encoding time (s/image) ↓
40-step measured24.32 / 28.450.801 / 0.89264.1%13.22 / 15.08
Teacher-calibrated27.71 / 32.950.887 / 0.96691.6%22.03 / 23.84
160-step measured (reference)28.10 / 33.150.891 / 0.969100%202.94 / 267.27

Paired values are reported in low-rate / high-rate order. Changing the allocation score improves decoded PSNR by 3.39 dB at low rate and 4.50 dB at high rate and improves MS-SSIM at both settings, with about 9 s of additional encoding time per image. Agreement with the measured 160-step ranking also rises from 64.1% to 91.6% on held-out blocks. The decoded gains show that calibration helps select among the available 40-step fits at the tested Gaussian budgets.

We added the controlled comparison in More ablation studies → Teacher calibration in the revised appendix.

W2&Q2

Thank you for pointing this out. We have added the measured bpp for every operating point in Table 1. The Low-rate and High-rate columns report two evaluated configurations per method. Their achieved bitrates vary across methods, so the table reports the quality of each configuration at its measured rate.

Image setMethodMeasured bpp (Low / High)PSNR (dB, Low / High)MS-SSIM (Low / High)
StandardGaussianImage0.271 / 0.85226.21 / 30.470.8829 / 0.9596
StandardGaussianImage++0.230 / 0.63126.30 / 30.300.8853 / 0.9578
StandardImage-GS0.215 / 0.90027.95 / 32.080.8994 / 0.9607
StandardCaliSplat0.208 / 0.90327.71 / 32.950.8866 / 0.9655
LargeLIG0.211 / 0.90023.64 / 29.700.7104 / 0.9163
LargeSGI0.192 / 0.91726.67 / 30.550.8634 / 0.9533
LargeCaliSplat0.155 / 0.85627.10 / 31.860.8504 / 0.9645

High-rate comparison at similar measured bitrates. On standard images, CaliSplat and Image-GS operate at 0.903 and 0.900 bpp in Table 1, a difference of only 0.003 bpp. At these closely matched rates, CaliSplat achieves 0.87 dB higher PSNR, with MS-SSIM of 0.9655 versus 0.9607. On large images, CaliSplat reaches 31.86 dB at 0.856 bpp, compared with 30.55 dB at 0.917 bpp for SGI, the strongest baseline by PSNR.

W3&Q3

Thank you for pointing out that the timing comparison needs more detail. Below we give the hardware and optimization settings.

Hardware and software. Each job used one NVIDIA A100 PCIe GPU with 40 GB of memory. The host has four Intel Xeon Platinum 8260 CPUs at 2.40 GHz, with 96 physical cores and 192 logical threads in total.

Optimization settings.

MethodOptimizer and learning rateFitting schedule
GaussianImageAdan, 0.001 initially, halved every 20k steps50k fitting + 50k QAT steps
GaussianImage++Adam, 0.018 for attributes and 0.001 for the quantizer50k fitting + 50k QAT steps, including a 6k-step QAT warm-up
Image-GSAdam, 0.0005 / 0.005 / 0.002 / 0.002 for position / color / scale / rotationUp to 10k steps, with learning-rate decay and early stopping
LIGAdam, 0.01830k steps at each of two scales
SGIAdam, with parameter-specific learning rates3k + 6k + 6k steps across three scales
CaliSplatAdam, 0.03540 steps per retained candidate and 160 steps per teacher fit, with up to 128 teacher samples per image and per count K>1K>1

Image-GS starts at half the target Gaussian count and adds one eighth of the target every 500 steps, four times. Our GaussianImage++ runs use SLV initialization and pruning, with adaptive_add disabled to control the Gaussian count. SGI uses 50-dimensional features and 10 offsets per seed.

What the timing includes. CaliSplat’s encoding time in Table 1 includes candidate fitting, sampled teacher fitting, and allocation and bitstream coding. On standard images at the low rate, these stages take 8.52, 10.71, and 2.80 s/image, respectively, for a total of 22.03 s/image. The revised appendix subsection Encoding time breakdown reports the same breakdown for both image sets and both rates.

Where the speedup comes from. Table 2 compares sparse screening with exhaustive candidate fitting within CaliSplat at the same Gaussian budget. Screening reduces the KK-weighted fitting work to 65% of the exhaustive run and brings encoding time down from 292.49 to 221.69 s. Decoded PSNR stays close, at 30.485 dB with exhaustive fitting and 30.509 dB with screening.

Comparison with Instant GaussianImage.

Thank you for pointing out this omission. Instant GaussianImage is a relevant baseline because its learned initialization directly targets per-image fitting time. We have added it to the standard-image benchmark.

Bold and italics indicate the best and second-best results at each rate.

MethodbppPSNR (dB) ↑MS-SSIM ↑Training time (s) ↓Decode speed (MP/s) ↑
GaussianImage0.271 / 0.85226.21 / 30.470.8829 / 0.9596332.12 / 345.42213.58 / 129.41
Instant GaussianImage0.269 / 0.84926.29 / 30.560.8841 / 0.960155.35 / 57.57219.47 / 136.82
GaussianImage++0.230 / 0.63126.30 / 30.300.8853 / 0.9578341.99 / 346.98256.53 / 241.74
Image-GS0.215 / 0.90027.95 / 32.080.8994 / 0.960777.50 / 71.51227.00 / 205.51
CaliSplat0.208 / 0.90327.71 / 32.950.8866 / 0.965522.03 / 23.84215.82 / 175.90

At nearly identical bitrates, Instant GaussianImage achieves similar reconstruction quality in about one sixth of GaussianImage’s training time. CaliSplat takes about 40% of Instant GaussianImage’s training time at both operating points. At the low-rate points, CaliSplat achieves 1.42 dB higher PSNR and uses 0.061 bpp less. At the high-rate points, CaliSplat achieves 2.39 dB higher PSNR at a bitrate 0.054 bpp higher.

W4&Q4

Thank you for flagging the missing measurements in Fig. 6.

1. Allocation at similar bitrates. At the same Gaussian budget in Fig. 6(b), the measured bitrates span 0.0056 bpp. CaliSplat gives the highest PSNR and uses fewer bits than either baseline.

AllocatorMeasured bpp
Uniform0.5220
Random shuffle0.5191
CaliSplat (ours)0.5164

2. Reconstruction after parameter coding. All four runs in Fig. 6(a) use the same partition and fitted Gaussians. Eq. (4) blends Gaussian colors as I^(p)=∑kπk(p)ck\hat I(p)=\sum_k\pi_k(p)c_k.

  • Template residual. Adding the exactly decoded residual to the known template recovers the quantized geometry, zk(0)+(zk−zk(0))=zkz_k^{(0)}+(z_k-z_k^{(0)})=z_k.
  • Relative log-weight. Subtracting a common reference rr from a block’s log-weights shifts every logit by −r-r. The common factor cancels in softmax.

e−reℓk(p)e−r∑jeℓj(p)=πk(p).\frac{e^{-r}e^{\ell_k(p)}}{e^{-r}\sum_j e^{\ell_j(p)}}=\pi_k(p).

  • Palette RGB. Lookup preserves color when P[ik]=ckP[i_k]=c_k. A color change contributes πk(p)(P[ik]−ck)\pi_k(p)(P[i_k]-c_k) to the pixel difference. Exact geometry and colors, with the same mixing weights, give the same reconstruction.

Size (KiB) / decoded PSNR (dB) / decoded SSIM

StageDIV2KICB
Absolute260/30.52/0.8913423/29.625/0.883
+Template residual249/30.52/0.8913213/29.625/0.883
+Relative weight246/30.52/0.8913178/29.625/0.883
+Palette RGB193/30.51/0.8892462/29.620/0.881

On DIV2K, the first two steps preserve both metrics to the reported precision. The full scheme saves 67 KiB, with drops of 0.01 dB and 0.002 SSIM. On ICB, the palette alone saves 716 KiB, with drops of 0.005 dB and 0.002 SSIM from the preceding stage.

W5&Q5

Thank you for flagging the missing image list and resolutions. Our nine-image benchmark matches SGI’s published large-image evaluation in scale and composition (Pan et al., CVPR 2026, Sec. 4.1), the closest precedent at tens of megapixels. Both use 4 FGF2, 2 ICB, and 3 STimage images. LIG uses 4 FGF2 (4K), 15 STimage (9K), and 100 DIV-HR (2K) images.

Table 1 and Fig. 4 cover 84 images across six datasets, including 75 standard-resolution images (15 Kodak, 35 Tecnick, 25 CLIC2020). The standard set is comparable in size to baseline benchmarks. Image-GS uses 45 RGB images and separately evaluates the CLIC2020 professional validation split. GaussianImage and GaussianImage++ each use 24 Kodak and 100 DIV2K validation images.

The 4 FGF2 and 3 STimage inputs came from the SGI authors’ experimental package. ICB’s big_building and big_tree match SGI’s reported 39.1 and 27.7 MP images, respectively. The nine images cover satellite, natural, and histopathology content. Their native sizes, verified from PNG headers, span 27.70–92.08 MP and total about 497 million pixels.

DatasetImage(s)Native W×HMP/image
FGF2GF2_0.png, GF2_1.png, GF2_2.png, GF2_3.png7300×690850.43
ICBbig_building.png7216×541239.05
ICBbig_tree.png6088×455027.70
STimageST_0.png6954×743551.70
STimageST_1.png9830×860284.56
STimageST_2.png9272×993192.08

End-to-end sensitivity

We tested five configurations on Table 1’s standard images at its low-rate Gaussian budget. Each variant changes one default setting.

ConfigurationPSNR (dB) ↑MS-SSIM ↑Enc. (s/image) ↓
Default (40 steps, teacher cap 128, default retention)27.710.88622.03
20 fitting steps27.420.880217.77
80 fitting steps27.860.89150.55
Teacher cap 6427.660.885816.68
Retention 0.75× default27.690.886220.07

The teacher cap is per image and per count K>1K>1, with 160 steps per teacher fit. The retention multiplier scales default quotas for K>2K>2.

Fitting steps show the clearest quality–time trade-off. Compared with 40 steps, 20 saves 4.26 s/image for a 0.29 dB PSNR drop. At 80 steps, PSNR gains 0.15 dB and MS-SSIM reaches 0.891, but encoding takes 28.52 s/image more. This supports the 40-step default.

Halving the teacher cap and lowering retention save 5.35 and 1.96 s/image with smaller PSNR drops of 0.05 and 0.02 dB, respectively. MS-SSIM stays near 0.886 in both cases.

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

This paper proposes CaliSplat which is an efficient per-image compression framework based on 2D Gaussian representations. The method introduces difficulty-guided sparse candidate fitting, sampled teacher calibration, and global Gaussian-budget allocation to reduce per-image optimization costs while maintaining reconstruction quality. Experiments demonstrate competitive rate–distortion performance against existing Gaussian-based codecs, with substantially reduced fitting time and high decoding throughput.

Critical strengths

Practical motivation. The paper addresses the high per-image optimization cost of Gaussian-based image compression, which is an important limitation for practical applications.

Competitive performance. CaliSplat achieves competitive or superior rate–distortion performance compared with existing Gaussian-based codecs, particularly on large images, while providing substantial improvements in fitting efficiency.

Reasonable experimental validation. The paper includes comparisons across multiple datasets, efficiency measurements, and ablation studies demonstrating the benefits of sparse candidate fitting, adaptive Gaussian allocation, and structured parameter coding.

Critical weaknesses
  1. Insufficient validation of the teacher calibration module.

Teacher calibration is presented as a key contribution, but the paper lacks a direct ablation comparing calibrated and uncalibrated candidate scores. Moreover, calibration estimates long-horizon distortion (160 steps), whereas the final representation retains the short-horizon fitted parameters (40 steps). It remains unclear whether minimizing the calibrated distortion leads to better reconstruction quality for the representations actually encoded. The authors should clarify this design and provide corresponding experimental evidence.

  1. Gaussian-budget allocation does not directly optimize actual bitrate.

The proposed allocation strategy constrains the total Gaussian count rather than the actual compressed bitstream size. However, different Gaussian configurations may have different encoding costs due to parameter quantization, color coding, and structural metadata. Consequently, optimizing distortion under a Gaussian-count constraint may not achieve the best rate–distortion trade-off. The authors should clarify this approximation and investigate whether bitrate-aware allocation could further improve compression performance.

Questions for authors

How does teacher calibration improve the selection of the final 40-step fitted representations? Can the authors provide a direct ablation comparing calibrated and uncalibrated candidate scores?

Why is Gaussian count used as the allocation constraint instead of actual encoded bitrate? Could bitrate-aware allocation lead to better rate–distortion performance?

4 comments

W1 / Q1

Thank you for asking for a direct comparison. Using calibrated scores to select from the same 40-step fits improves decoded quality at both tested Gaussian budgets. Different counts can converge at different speeds, and a candidate that looks better after 40 steps can rank lower after a longer fit. The sampled 160-step fits calibrate the scores used to choose the partition and counts. For K>1K>1, the encoder stores the selected candidates' 40-step parameters in every variant.

We compared three scoring rules on the standard-image set. The uncalibrated baseline uses the measured 40-step distortion Dbcheap(K)D_b^{\mathrm{cheap}}(K). CaliSplat uses D~b(K)\widetilde D_b(K) estimated from sampled teacher fits. The reference measures 160-step distortion for every admitted candidate with K>1K>1. At each setting, the three runs share the fitted candidate bank, Gaussian budget, allocator, and coding settings.

On held-out blocks, we measure how often the score ordering of two candidates for the same block agrees with their ordering by measured 160-step distortion. Paired entries show low-rate / high-rate results.

Allocation scoreDecoded PSNR (dB) ↑MS-SSIM ↑Agreement with 160-step ranking ↑Encoding time (s/image) ↓
40-step measured24.32 / 28.450.801 / 0.89264.1%13.22 / 15.08
Teacher-calibrated27.71 / 32.950.887 / 0.96691.6%22.03 / 23.84
160-step measured (reference)28.10 / 33.150.891 / 0.969100% by definition202.94 / 267.27

Calibration increases ranking agreement from 64.1% to 91.6%. With the 40-step parameters shared across variants, the calibrated scores improve decoded PSNR by 3.39 dB at low rate and 4.50 dB at high rate over the raw scores. MS-SSIM also improves at both settings. Calibration adds about 9 s per image and brings decoded PSNR within 0.39 and 0.20 dB of exhaustive 160-step scoring, which takes 9.2 and 11.2 times as long as the calibrated encoder. The decoded gains therefore come from choosing a better combination of the available short fits.

We added the direct ablation and ranking analysis in More ablation studies → Teacher calibration in the revised appendix.

W2 / Q2

We agree that two representations with the same Gaussian count can have different bitstream sizes. CaliSplat minimizes summed calibrated distortion under an image-wide count constraint, ∑b∈TKb≤B\sum_{b\in\mathcal T}K_b\le B. The count is known before encoding and adds across blocks, so the search can evaluate it without estimating each candidate's code length.

We tested a rate-aware variant with the same fitted candidates and calibrated distortions. For each candidate (b,K)(b,K), we quantize the geometry, weights, and colors and estimate their coding cost under a fixed probability model pmp_m for each attribute stream mm,

R^b(K)=∑m∑z∈Qb,K(m)−log⁡2pm(z).\widehat R_b(K)=\sum_m\sum_{z\in\mathcal Q_{b,K}^{(m)}}-\log_2 p_m(z).

Here Qb,K(m)\mathcal Q_{b,K}^{(m)} is the sequence of quantized symbols in stream mm. The count-based allocator charges λGK\lambda_G K for a kept block. The rate-aware allocator charges a trial price λR\lambda_R per estimated bit, including the estimated cost of signaling the keep or split decision and the Gaussian count. For a splittable node, this gives

F_b^{\mathrm{rate}}(\lambda_R)=\min\Big\\{& \min_{K\in\mathcal{K}_b} \big[\widetilde D_b(K) +\lambda_R(\widehat R_b(K)+\widehat h_b^{\mathrm{keep}}(K))\big],\\\\ &\lambda_R\widehat h_b^{\mathrm{split}} +\sum_{c\in\mathrm{child}(b)}F_c^{\mathrm{rate}}(\lambda_R) \Big\\}. \end{aligned}$$ The additive estimate lets us reuse the bottom-up tree search and backtracking. We vary $\lambda_R$ to obtain configurations at different estimated rates. Allocation time below includes the bit-cost estimation pass where applicable and the subsequent search. |Image|Allocator|PSNR (dB) ↑|MS-SSIM ↑|Allocation time (s) ↓| |---|---|---:|---:|---:| |DIV2K example|Count-based ($B/N=4$)|28.37|0.861|**2.42**| |DIV2K example|Rate-aware|**28.92**|**0.866**|4.69| |ICB building|Count-based ($B/N=4$)|30.48|0.855|**19.63**| |ICB building|Rate-aware|**31.02**|**0.859**|36.44| At these operating points, the rate-aware variant gains **0.55 dB on DIV2K and 0.54 dB on ICB**, and improves MS-SSIM on both images. Allocation takes **2.27 and 16.81 additional seconds**, respectively, or 1.94 and 1.86 times the count-based time. The extra pass generates quantized symbols and estimates their costs for every candidate before the final configurations are selected. The results show a quality gain at the evaluated operating points. Prior work has explored rate-aware compression for 3D Gaussian splatting, including Wang et al. (ECCV 2024) and Lee et al. (ICCV 2025). Future work could build on these approaches to develop allocation algorithms that better account for actual bitstream costs in 2D Gaussian image compression. The experiment and discussion are in **More ablation studies → Bitrate-aware Gaussian allocation** in the revised appendix.

The authors’ response addresses most of my concerns. After considering it, I have decided to keep my original score.

Thank you for your thoughtful review and for considering our response.

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

This paper proposes CaliSplat, a Gaussian-based image compression method that aims to reduce the computational cost of per-image optimization. The method uses an analytic reconstruction error to identify candidate regions for Gaussian fitting, followed by distortion calibration and budget-aware Gaussian allocation. The experiments show competitive compression performance and reduced optimization time compared with existing Gaussian-based methods.

Critical strengths

1). The proposed approach seems novel and provides an interesting direction for reducing the computational cost of Gaussian-based image compression. 2). Table 1 shows competitive results against recent Gaussian-based methods at both low and high bitrates. The evaluation across multiple datasets also supports the effectiveness of the method.

Critical weaknesses

1). Even though the proposed method seems novel, I feel the authors could establish its novelty and differences from existing approaches more clearly. Also, the proposed method section is somewhat difficult to follow, as the concepts are not introduced sequentially.

2). The experimental comparisons are mainly limited to Gaussian-based approaches. Even though some INR-based compression methods are discussed, comparisons with representative recent INR-based codecs are missing. I feel such comparisons would provide a more comprehensive evaluation of the proposed method.

Questions for authors

1). I would like to know how robust the sparse candidate selection based on Db(1) is for noisy or highly textured regions, where high initial error may not necessarily lead to significant improvements with additional Gaussians. Could this result in unnecessary candidate fitting or inefficient Gaussian allocation? 2). I would like to know whether the reported fitting times include the sampled teacher calibration overhead. A breakdown of the time spent on different components would also be helpful. 3). How does the proposed method compare with simpler approaches, such as directly allocating Gaussians based on block variance or using a greedy allocation strategy? Such comparisons would help clarify the benefits of the proposed allocation framework.

5 comments

W1

Thank you for pointing out both issues. CaliSplat's main distinction is that it fits screened local alternatives at several Gaussian counts, then uses their calibrated scores to jointly select the image partition and per-block counts under one image-wide Gaussian budget.

Comparison with prior work

  • How are Gaussian representations constructed? Instant GaussianImage learns an initializer, GaussianImage fits a prescribed count, and Image-GS and GaussianImage++ use reconstruction error to guide growth during fitting. CaliSplat computes the single-Gaussian distortion Db(1)D_b(1) in closed form and uses it to shortlist block–count pairs before iterative fitting. The separate fits give the allocator several representations to compare for the same region.
  • How is the final representation selected under a budget? LIG combines fits for coarse content and fine residuals, and SGI uses coarse fits to initialize finer ones. In CaliSplat, a parent block and its children are two possible covers of the same pixels. Candidates at different counts can converge at different speeds, so we calibrate their short-fit scores using sampled longer fits before deciding which blocks to split and how many Gaussians to assign.
MethodConstructionCount rule or selectionJoint budgeted search
Instant GaussianImage (ICCV 2025)Learned initializationImage-adaptive initial count×
GaussianImage (ECCV 2024)Per-image fittingPrescribed count×
Image-GS (SIGGRAPH 2025)Residual-guided insertionGrowth to a target count×
GaussianImage++ (AAAI 2026)Residual-driven growth and pruningImage-wide count cap×
LIG (AAAI 2025)Coarse and fine residual fitsCombines both Gaussian sets×
SGI (CVPR 2026)Coarse-to-fine seed fittingUses the refined fine-scale fit×
CaliSplatScreens and fits block–count pairsSelects the partition and counts under a shared budget✓

The full comparison and table appear in Comparison with Related 2D Gaussian Image Compression Methods in the revised appendix.

Method presentation

We revised Section 3 to introduce each concept before it is used.

  • Overview and Section 3.1. We define root and child blocks before introducing candidate screening. We distinguish the fitting quota, which limits the number of candidates evaluated, from the Gaussian budget, which limits the final representation.
  • Section 3.2. We explain how the sampled 160-step fits calibrate the scores used for allocation. For selected candidates with K>1K>1, the encoder uses the stored 40-step parameters.
  • Section 3.3. Before introducing the objective, we compare a parent block with four Gaussians to four child blocks with one Gaussian each. The two choices use the same number of Gaussians, so the example shows directly how the distortion scores guide the split decision.

W2

Thank you for the suggestion. We added RECOMBINER (ICLR 2024), LotteryCodec (ICML 2025), and MoRIC (NeurIPS 2025) to the standard-image evaluation. At the two rate settings, we report decoded quality, per-image training time, and decoding throughput on the same image set.

RateMethodPSNR (dB) ↑MS-SSIM ↑Training time (s) ↓Decode speed (MP/s) ↑
LowRECOMBINER26.180.8675163.841.52
LowLotteryCodec27.660.8872097.601.34
LowMoRIC27.690.8913304.920.97
LowCaliSplat27.710.88722.03215.82
HighRECOMBINER32.570.9636785.231.19
HighLotteryCodec33.910.9762806.591.08
HighMoRIC33.930.9744269.930.74
HighCaliSplat32.950.96623.84175.90

CaliSplat fits each image in 22–24 s and decodes at 176–216 MP/s. At the corresponding settings, LotteryCodec, the fastest INR baseline to train, takes 95–118 times as long. CaliSplat's reported decoding throughput is 142–148 times that of RECOMBINER, the fastest INR decoder in the comparison.

At low rate, CaliSplat is within 0.05 dB in PSNR and 0.004 in MS-SSIM of LotteryCodec and MoRIC. At high rate, it exceeds RECOMBINER on both quality metrics. LotteryCodec and MoRIC achieve 0.96 and 0.98 dB higher PSNR, respectively, with the fitting and decoding costs shown above.

The full comparison is in Comparison with INR-based image codecs in the revised appendix.

Q1

We agree that a high Db(1)D_b(1) can overstate the benefit of adding Gaussians. Our experiments confirm that local noise can push lower-gain candidates into the shortlist and shift where Gaussians are allocated. At the strongest tested noise level, the decoded PSNR loss relative to dense fitting was at most 0.031 dB under the same Gaussian budget cap.

We tested three fixed DIV2K crops. In each crop, we added Gaussian noise to the 256 blocks with the lowest clean Db(1)D_b(1), using the same block locations and noise draw across noise levels. We measured the fitting gain as Gb160(K)=Db(1)−Db160(K)G_b^{160}(K)=D_b(1)-D_b^{160}(K) and compared the changes in score and gain at the same locations. We also examined naturally textured blocks from the clean crops.

At K=16K=16 and σ=20/255\sigma=20/255, the median increase in Db(1)D_b(1) was 350.2–391.4 across the crops. The median increase in fitting gain was 72.6–84.2 in the same RGB8 MSE units. The sampled natural-texture blocks showed larger fitting gains than the noisy blocks in all three crops. On crop 0001, noise replaced 186 of the 512 fitting slots. Scoring both shortlists on the same noisy input, this exchange reduced the retained share of positive fitting gain by 6.19 percentage points. Across all 36 tested crop, noise, and count settings, the gate retained 4.98–32.50 percentage points more gain than the mean of equal-quota random screening.

We then measured the effect on allocation and decoding. With the 40-step fits fixed, restricting candidate availability increased the allocated RGB squared error by 0.029%–0.531% relative to Dense at the strongest noise level. For the full-codec comparison, each variant ran its own teacher calibration and used the same Gaussian budget cap B/N=4B/N=4. Dense fits every candidate. The quality differences below are Gate minus Dense.

CropClean ΔPSNR (dB)Noisy ΔPSNR (dB)Noisy ΔSSIMNoisy bpp (Gate / Dense)
0001+0.003−0.031−0.0058080.810 / 0.811
0002+0.010−0.013+0.0001150.801 / 0.800
0003−0.044−0.010−0.0000020.813 / 0.812

The four-panel figure and full-codec table are in More ablation studies → Candidate screening in noisy and textured regions in the revised appendix.

Q2

Yes. The CaliSplat times in Table 1 include the sampled teacher fits used for calibration. For each image, we compute

=T_{\mathrm{cand}}+T_{\mathrm{teacher}}+T_{\mathrm{alloc+code}}.$$ Candidate fitting uses 40 Adam steps. For each Gaussian count $K>1$, we sample up to 128 candidates per image and fit each for 160 steps to obtain reference distortions for calibration. |Component|Standard, low|Standard, high|Large, low|Large, high| |---|---:|---:|---:|---:| |Candidate fitting (s/image)|8.52|10.29|55.30|62.28| |Sampled teacher fitting (s/image)|10.71|10.66|15.65|14.46| |Allocation and coding (s/image)|2.80|2.89|23.91|26.51| |**Total encoding time (s/image)**|**22.03**|**23.84**|**94.86**|**103.25**| |Teacher fitting share|48.6%|44.7%|16.5%|14.0%| Teacher fitting takes about 11 s on standard images and 14–16 s on large images. It accounts for a smaller share on large images because candidate fitting, allocation, and coding take substantially longer. From low to high rate, candidate fitting accounts for most of the added time, and the teacher share falls by 3.9 percentage points on standard images and 2.5 points on large images. The share is calculated as mean teacher fitting time divided by mean total encoding time. We added the timing definition and full breakdown in **Encoding time breakdown** in the revised appendix.

Q3

We tested both suggested baselines. CaliSplat gives the highest PSNR and MS-SSIM on both examples and allocates faster than hierarchical greedy. The three methods start from the same fitted candidate bank and use the same target budget B/N=4B/N=4, where NN is the number of 16×1616\times16 root blocks.

Variance-based allocation keeps the root grid fixed. It assigns one Gaussian per root and distributes the remaining budget according to the block's RGB variance vb=Db(1)/nbv_b=D_b(1)/n_b, where nbn_b is its pixel count. The target is qb=1+(B−N)vb/∑jvjq_b=1+(B-N)v_b/\sum_j v_j, with equal shares when all variances are zero. We round down to an available count and use the remaining budget for feasible upgrades, prioritizing the largest gap qb−Kbq_b-K_b.

Hierarchical greedy uses the same partition tree and calibrated scores as CaliSplat. For each root and count, it keeps the lowest-distortion configuration among the legal keep and split options. Starting with one Gaussian per root, it repeatedly takes the feasible upgrade with the largest positive distortion reduction per added Gaussian,

{G_{\mathrm{new}}-G_{\mathrm{current}}},\qquad G_{\mathrm{new}}>G_{\mathrm{current}}.$$ Here $G$ is the Gaussian count and $\widetilde D$ is the summed calibrated distortion of a root configuration. Allocation time measures the selection stage starting from the prepared candidates. |Image|Allocator|PSNR (dB) ↑|MS-SSIM ↑|Allocation time (s) ↓| |---|---|---:|---:|---:| |DIV2K example|Variance-based|25.95|0.812|**0.38**| |DIV2K example|Hierarchical greedy|27.21|0.847|10.26| |DIV2K example|CaliSplat|**28.37**|**0.861**|2.42| |ICB building|Variance-based|24.92|0.804|**3.15**| |ICB building|Hierarchical greedy|28.19|0.839|119.84| |ICB building|CaliSplat|**30.48**|**0.855**|19.63| The variance rule allocates fastest because it uses a single statistic on a fixed grid. That statistic measures constant-color error and only indirectly indicates how much a fitted candidate can recover. CaliSplat gains **2.42 and 5.56 dB** over this rule. With the scores and split options held fixed, CaliSplat gains **1.16 and 2.29 dB** over hierarchical greedy. The greedy runs take **4.2 and 6.1 times** as long to allocate, respectively. Greedy commits the budget one upgrade at a time. CaliSplat evaluates keep and split choices across the tree in a bottom-up pass at each trial Gaussian price. The full setup and results are in **More ablation studies → Gaussian allocation strategies** in the revised appendix.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.