Shorter Splatting Eval

---
name: shorter-splatting-eval
description: Evaluates the training efficiency and reconstruction fidelity of a 3D Gaussian Splatting method that uses scale reset and entropy-constrained alpha blending to reduce Gaussian list lengths. Use when the user wants to benchmark on Mip-NeRF 360, Deep Blending, Tanks and Temples, or asks about evaluating this task. Reports PSNR.
metadata:
  skill_kind: dataset_eval
  source_arxiv: 2603.09277
  bibtex_key: [REDACTED]
  confidence: high
---

# shorter-splatting-eval

> Speeding Up the Learning of 3D Gaussians with Much Shorter Gaussian Lists — Liu et al. (2026) (arXiv:2603.09277, 2026)

## What this evaluates

Evaluates the training efficiency and reconstruction fidelity of a 3D Gaussian Splatting method that uses scale reset and entropy-constrained alpha blending to reduce Gaussian list lengths.

## Datasets

- **Mip-NeRF 360** — total ?; splits: train (-1), test (-1)
- **Deep Blending** — total ?; splits: train (-1), test (-1)
- **Tanks and Temples** — total ?; splits: train (-1), test (-1)

## Metrics

- `PSNR` **(primary)** — range: [0, ∞)
  - Peak Signal-to-Noise Ratio computed in linear RGB space between rendered and ground-truth images. Higher is better.
- `SSIM` — range: [0, 1]
  - Structural Similarity Index Measure comparing local patterns of pixel intensities. Higher is better.
- `LPIPS` — range: [0, 1]
  - Learned Perceptual Image Patch Similarity using deep features. Lower is better.
- `Time(s)` — range: seconds
  - Total training time in seconds required to reach the specified iteration count.
- `N_G` — range: count
  - Total number of 3D Gaussians in the final optimized scene representation.

## Input / output format

**Input**: Multi-view images and corresponding camera poses for a static 3D scene.

**Output**: Rendered images from the optimized 3D Gaussian representation at specified test viewpoints.

## Scoring recipe

```python
def evaluate(rendered_imgs, gt_imgs, training_time_s, final_gaussian_count):
    psnr = compute_psnr(rendered_imgs, gt_imgs)
    ssim = compute_ssim(rendered_imgs, gt_imgs)
    lpips = compute_lpips(rendered_imgs, gt_imgs)
    return {
        'PSNR': psnr,
        'SSIM': ssim,
        'LPIPS': lpips,
        'Time(s)': training_time_s,
        'N_G': final_gaussian_count
    }
```

## Common pitfalls

- Comparing training times without controlling for iteration count or target Gaussian count, as speedups are highly dependent on these constraints.
- Misinterpreting LPIPS directionality (lower is better) compared to PSNR/SSIM (higher is better).
- Ignoring that the paper evaluates under two distinct setups (Taming-3DGS target counts vs. Mini-Splatting2 target counts) which yield different performance baselines.

## Evidence (verbatim from paper)

> Table 1: Quantitative comparison across three datasets. We follow Taming-3DGS’s target Gaussian count setup (3.3M, 2.8M, 1.8M for the three datasets respectively) for fair comparison. | Method | Iters | Mip-NeRF 360 | | | | | Deep Blending | | | | | Tanks and Temples | | | | | | | | N_G | PSNR↑ | SSIM↑ | LPIPS↓ | Time(s)↓ |

## Citation

```bibtex
@misc{liu2026shortersplatting,
  title={Speeding Up the Learning of 3D Gaussians with Much Shorter Gaussian Lists},
  author={Liu et al. (2026)},
  year={2026},
  note={arXiv:2603.09277}
}
```

- arXiv: 2603.09277