Datasets:

NoraResearchLab
/

SatClean-Bench

---
license: cc-by-4.0
pretty_name: "SatClean-Bench"
task_categories:
  - image-to-image
tags:
  - remote-sensing
  - satellite
  - earth-observation
  - sentinel-2
  - image-restoration
  - image-denoising
  - super-resolution
  - 3x-super-resolution
  - benchmark
  - computer-vision
  - geospatial
size_categories:
  - n<1K
---
<div align="center">

# SatClean-Bench

**A fixed, reproducible benchmark for joint denoising and 3× super-resolution of Sentinel-2 RGB imagery**

SatClean-Bench evaluates whether an image-restoration model can recover a clean, high-resolution Sentinel-2 RGB image from a degraded, lower-resolution observation.

[![GitHub](https://img.shields.io/badge/GitHub-Nora--Research--Lab-181717?logo=github)](https://github.com/Nora-Research-Lab)
[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface\&logoColor=yellow)](https://huggingface.co/NoraResearchLab)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-NORA%20Research%20Lab-0A66C2?logo=linkedin)](https://www.linkedin.com/company/nora-research-lab)
[![X](https://img.shields.io/badge/X-@noraresearchlab-000000?logo=x)](https://x.com/noraresearchlab)
[![Website](https://img.shields.io/badge/Website-noraresearchlab.site-2ea44f)](https://noraresearchlab.site)

</div>

---

## Overview

**SatClean-Bench** is a fixed evaluation benchmark designed to measure the performance of computer-vision models on **joint image denoising and 3× super-resolution** for Sentinel-2 RGB satellite imagery.

The benchmark intentionally combines multiple degradation mechanisms rather than evaluating super-resolution or denoising in isolation. A model must therefore reconstruct spatial detail while simultaneously removing synthetic sensor and atmospheric artefacts.

The benchmark is designed around a simple evaluation question:

> **Given a degraded 30 m RGB observation, how accurately can a model reconstruct the corresponding clean 10 m RGB image?**

Every benchmark sample has a corresponding clean high-resolution target. The degraded inputs are generated using a **locked degradation specification**, allowing different models to be evaluated under exactly the same conditions.

SatClean-Bench is intended primarily for **model evaluation and comparison**, rather than as a general-purpose training dataset.

---

## Why this benchmark exists

Satellite image restoration is frequently evaluated using isolated tasks such as super-resolution, denoising, or dehazing. Real-world Earth-observation imagery, however, can contain several degradation mechanisms simultaneously.

SatClean-Bench therefore evaluates a more demanding restoration problem in which a model must address:

* spatial resolution loss;
* Gaussian sensor noise;
* structured striping artefacts;
* atmospheric haze;
* quantisation effects;
* and the interaction between degradation processes.

The benchmark provides three predefined degradation levels, allowing researchers to measure how model performance changes as the restoration problem becomes more difficult.

Because the degradation parameters and evaluation protocol are fixed, results from different models can be compared without changing the test distribution.

---

# Task

## Input

The input to the model is a degraded **30 m RGB image** with spatial dimensions:

```text
3 × 128 × 128
```

The three channels correspond to RGB.

## Target

The target is the corresponding clean **10 m RGB image**:

```text
384 × 384 × 3
```

The spatial scale factor is therefore:

```text
384 / 128 = 3×
```

The model must perform both:

1. **Denoising/restoration** of the degraded observation.
2. **3× spatial super-resolution** to recover the high-resolution target.

This makes SatClean-Bench a **joint image-restoration benchmark**, rather than a conventional super-resolution benchmark in which the only degradation is spatial downsampling.

---

# Benchmark Degradation Levels

SatClean-Bench provides three fixed degradation conditions.

| Level       | Gaussian Noise σ | Striping | Haze | Difficulty |
| ----------- | ---------------: | -------: | ---: | ---------- |
| **Level 1** |            15 DN |     None | None | Mild       |
| **Level 2** |            25 DN |     8 DN | None | Moderate   |
| **Level 3** |            50 DN |     None | 0.35 | Severe     |

Noise values are defined in the benchmark's 8-bit intensity domain.

### Level 1 — Mild degradation

Level 1 introduces moderate Gaussian noise while preserving the basic appearance of the underlying image.

This level primarily evaluates whether a model can perform spatial reconstruction without substantially amplifying or preserving noise.

### Level 2 — Structured degradation

Level 2 introduces stronger Gaussian noise together with an 8 DN striping component.

This tests whether a model can distinguish meaningful spatial structures from structured artefacts that may resemble real image content.

### Level 3 — Severe degradation

Level 3 introduces substantially stronger noise together with atmospheric haze.

The haze component uses an airlight-blending factor of **0.35**, producing a more challenging reconstruction problem involving both image restoration and recovery of spatial detail under reduced contrast.

---

# Degradation Pipeline

The benchmark generation process is deterministic and specified in:

```text
bench_spec.json
```

The conceptual pipeline is:

```text
Clean 10 m RGB image
        ↓
3× spatial downsampling
        ↓
Mild Gaussian PSF blur
        ↓
Optional atmospheric haze
        ↓
Additive Gaussian noise
        ↓
Optional row/column striping
        ↓
Clamping
        ↓
8-bit quantisation
        ↓
Degraded 30 m RGB input
```

More specifically:

### 1. 3× spatial downsampling

The original 10 m image is downsampled by a factor of three to produce the 30 m observation.

The resulting spatial dimensions are:

```text
384 × 384 → 128 × 128
```

### 2. Gaussian PSF blur

A mild Gaussian point-spread-function blur is applied before the final low-resolution observation is produced.

The benchmark uses:

```text
σ = 0.5 px
```

This represents additional optical/sensor response smoothing during image formation.

### 3. Optional haze

For the applicable degradation level, a smooth airlight field is blended into the image.

The haze parameter for Level 3 is:

```text
airlight blend = 0.35
```

### 4. Additive Gaussian noise

Gaussian noise is added according to the predefined level-specific standard deviation.

The noise is expressed in the benchmark's 8-bit DN/intensity domain.

### 5. Optional striping

Level 2 includes an 8 DN structured striping component.

The striping is intended to introduce a non-independent image artefact that differs from ordinary pixel-wise Gaussian noise.

### 6. Clamping and quantisation

The resulting values are clamped to the valid image range and converted to 8-bit unsigned integer representation.

The final benchmark inputs therefore use:

```text
dtype = uint8
range = [0, 255]
```

All parameters required to reproduce the degradation process are recorded in `bench_spec.json`.

---

# Dataset Structure

The benchmark contains **600 fixed evaluation scenes**.

Each scene has one clean high-resolution target and three degraded versions corresponding to the three benchmark levels.

| File              | Shape                | Data type | Description                                            |
| ----------------- | -------------------- | --------- | ------------------------------------------------------ |
| `test_hr.npy`     | `(600, 384, 384, 3)` | `uint8`   | Clean 10 m RGB reference images                        |
| `level1_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 1 degraded 30 m inputs                           |
| `level2_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 2 degraded 30 m inputs                           |
| `level3_lr.npy`   | `(600, 3, 128, 128)` | `uint8`   | Level 3 degraded 30 m inputs                           |
| `bench_spec.json` | —                    | JSON      | Benchmark specification and reproducibility parameters |

The same 600 high-resolution targets are used across all three degradation levels.

Consequently, a model can be evaluated under progressively different degradation conditions without changing the underlying geographic scenes.

---

# Tensor Conventions

The high-resolution reference file uses:

```text
(N, H, W, C)
```

with:

```text
N = 600
H = 384
W = 384
C = 3
```

The low-resolution files use:

```text
(N, C, H, W)
```

with:

```text
N = 600
C = 3
H = 128
W = 128
```

Users should therefore account for the different channel ordering when loading the arrays.

Example:

```python
import numpy as np

hr = np.load("test_hr.npy")
lr = np.load("level1_lr.npy")

print(hr.shape)
# (600, 384, 384, 3)

print(lr.shape)
# (600, 3, 128, 128)
```

---

# Data Source

The clean high-resolution image patches are extracted from the publicly available:

**Major-TOM / Core-S2L2A**

dataset:

https://huggingface.co/datasets/Major-TOM/Core-S2L2A

The source imagery is based on **Sentinel-2 Level-2A** observations at 10 m spatial resolution.

SatClean-Bench does not attempt to reproduce the complete Sentinel-2 acquisition process. Instead, it constructs a controlled restoration benchmark from high-resolution source imagery using a fixed synthetic degradation model.

This distinction is important: the benchmark measures performance under the specified degradation distribution and should not be interpreted as a complete simulation of every physical Sentinel-2 imaging artefact.

---

# Radiometric Processing

A tone transformation is applied to the source imagery before benchmark generation:

```text
clip(DN / 3000) ** 0.7
```

where `DN` represents the source digital-number/intensity value.

The resulting image is subsequently represented in the benchmark's 8-bit RGB space.

The exact processing parameters should be taken from `bench_spec.json` when reproducing the benchmark.

---

# Evaluation Protocol

Models should be evaluated independently on:

```text
Level 1
Level 2
Level 3
```

For each input image, the model produces a reconstructed 10 m RGB image.

The output should correspond to:

```text
384 × 384 × 3
```

and should be evaluated against the matching image in:

```text
test_hr.npy
```

Evaluation is performed after converting the model output to the benchmark's **uint8 representation**.

This is important because evaluation occurs in the same quantised image space used to define the benchmark targets.

---

# Primary Metrics

SatClean-Bench reports three primary image-quality metrics.

## PSNR

**Peak Signal-to-Noise Ratio (PSNR)** measures pixel-level reconstruction fidelity.

Higher PSNR indicates lower reconstruction error relative to the reference image.

PSNR is particularly useful for measuring whether a restoration model accurately reproduces the target pixel values.

## SSIM

**Structural Similarity Index Measure (SSIM)** evaluates structural similarity between the reconstructed image and the reference.

Unlike PSNR, SSIM is designed to capture perceptual changes in local image structure.

Higher SSIM indicates greater structural similarity.

## LPIPS

**Learned Perceptual Image Patch Similarity (LPIPS)** measures deep feature-space similarity using an AlexNet-based feature representation.

Lower LPIPS indicates greater perceptual similarity between the reconstructed image and the reference.

Together, these metrics provide complementary measurements:

| Metric | Measures                      | Preferred direction |
| ------ | ----------------------------- | ------------------- |
| PSNR   | Pixel-level fidelity          | Higher              |
| SSIM   | Structural similarity         | Higher              |
| LPIPS  | Learned perceptual similarity | Lower               |

No single metric completely characterises satellite-image restoration quality. Reporting all three helps distinguish pixel fidelity from structural and perceptual reconstruction quality.

---

# Optional Efficiency Metrics

SatClean-Bench can additionally be used to report computational efficiency.

Recommended measurements include:

### FLOPs

Compute the approximate number of floating-point operations required for inference on a:

```text
256 × 256
```

low-resolution tile.

### Inference latency

Measure tiled FP16 inference latency for a:

```text
1024 × 1024
```

low-resolution input.

When reporting latency, researchers should state the hardware, software framework, precision, batch size, and tiling configuration because these factors can substantially affect results.

Efficiency measurements are supplementary and should not replace the image-quality metrics.

---

# Recommended Reporting Format

For reproducible model comparisons, report results separately for every degradation level.

| Model   | Level | PSNR ↑ | SSIM ↑ | LPIPS ↓ | FLOPs | Latency |
| ------- | ----- | -----: | -----: | ------: | ----: | ------: |
| Model A | 1     |      — |      — |       — |     — |       — |
| Model A | 2     |      — |      — |       — |     — |       — |
| Model A | 3     |      — |      — |       — |     — |       — |

Researchers should not report only an aggregate score because the three levels represent different restoration conditions.

Per-level results make it possible to determine whether a model's performance is stable as degradation becomes more severe.

---

# Reproducibility

The benchmark is intended to be **fixed and reproducible**.

The benchmark specification is stored in:

```text
bench_spec.json
```

This file contains the parameters necessary to reproduce the degradation procedure, including the relevant random seed and metric definitions.

The benchmark therefore separates:

**Benchmark generation**

from:

**Model evaluation**

Researchers evaluating a model should use the released benchmark arrays rather than regenerating the test set with modified degradation parameters.

This prevents differences in preprocessing or random degradation from becoming a source of variation between reported model results.

---

# Benchmark Design Principles

SatClean-Bench follows several principles:

**Fixed evaluation set.**
The same 600 reference scenes are used for all models.

**Multiple degradation regimes.**
Models are tested under mild, structured, and severe degradation.

**Joint restoration.**
The task combines denoising and 3× super-resolution instead of treating them as independent problems.

**Deterministic specification.**
The degradation procedure is defined by a versioned benchmark specification.

**Multiple evaluation dimensions.**
PSNR, SSIM, and LPIPS capture different aspects of reconstruction quality.

**Separation of training and evaluation.**
SatClean-Bench is intended as a held-out evaluation benchmark rather than simply another training corpus.

---

# Intended Uses

SatClean-Bench can be used for:

* benchmarking satellite image-restoration architectures;
* comparing CNN, Transformer, diffusion, and hybrid restoration models;
* evaluating denoising + super-resolution pipelines;
* testing lightweight Earth-observation models;
* studying robustness to increasing degradation;
* measuring the trade-off between reconstruction quality and computational cost;
* establishing reproducible baselines for Sentinel-2 image restoration.

The benchmark can also be used to evaluate models intended for downstream Earth-observation workflows where image quality affects subsequent computer-vision tasks.

---

# Out-of-Scope Uses and Limitations

SatClean-Bench should not be interpreted as a complete representation of real Sentinel-2 image degradation.

The benchmark uses controlled synthetic degradation. Real satellite imagery may contain additional effects including:

* atmospheric variability;
* cloud and cloud-shadow contamination;
* spatially varying sensor effects;
* radiometric calibration differences;
* compression artefacts;
* geometric misregistration;
* temporal changes between observations;
* surface reflectance variation;
* sensor-specific noise characteristics;
* spatially correlated degradation not represented by the benchmark.

Consequently, strong performance on SatClean-Bench demonstrates performance on the **defined benchmark task**, but does not by itself establish equivalent performance on every real-world Sentinel-2 restoration scenario.

For real-world deployment, benchmark results should therefore be complemented with evaluation on independent real satellite observations.

---

# Data Leakage and Evaluation Integrity

Because SatClean-Bench is intended as a fixed evaluation benchmark, users should avoid training directly on the released test targets or their corresponding degraded inputs.

For meaningful comparisons, benchmark samples should remain unseen during model training.

If a model is trained using imagery derived from the same underlying source data, researchers should explicitly disclose this in their experiment description.

---

# License

SatClean-Bench is released under:

**CC BY 4.0**

Users should also review the licensing and usage conditions of the underlying Major-TOM / Core-S2L2A source dataset before redistributing derived data or using the benchmark in a downstream project.

---

# Citation

If you use SatClean-Bench in research, benchmarking, model development, or publications, please cite both the underlying Major-TOM dataset/paper and this benchmark.

### Major TOM

```bibtex
@inproceedings{Major_TOM,
  title     = {Major TOM: Expandable Datasets for Earth Observation},
  author    = {Alistair Francis and Mikolaj Czerkawski},
  year      = {2024},
  booktitle = {IGARSS 2024 - 2024 IEEE International Geoscience and Remote Sensing Symposium},
  eprint    = {2402.12095},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CV}
}
```

### SatClean-Bench

```bibtex
@misc{satcleanbench2026,
  title        = {SatClean-Bench: A Fixed Benchmark for Joint Denoising and 3x Super-Resolution of Sentinel-2 Imagery},
  author       = {{NORA Research Lab}},
  year         = {2026},
  publisher    = {Hugging Face},
  note         = {Benchmark dataset}
}
```

---

# Maintainer

**NORA Research Lab**

NORA Research Lab develops datasets, models, tools, and benchmarks for artificial intelligence applied to real-world scientific and Earth-observation problems.

[![GitHub](https://img.shields.io/badge/GitHub-Nora--Research--Lab-181717?logo=github)](https://github.com/Nora-Research-Lab)
[![Hugging Face](https://img.shields.io/badge/HuggingFace-NoraResearchLab-FFD21E?logo=huggingface\&logoColor=black)](https://huggingface.co/NoraResearchLab)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-NORA%20Research%20Lab-0A66C2?logo=linkedin)](https://www.linkedin.com/company/nora-research-lab)
[![X](https://img.shields.io/badge/X-@noraresearchlab-000000?logo=linkedin)](https://x.com/noraresearchlab)

### Quick Links

[Website](https://noraresearchlab.site) ·
[GitHub](https://github.com/Nora-Research-Lab) ·
[Hugging Face](https://huggingface.co/NoraResearchLab) ·
[LinkedIn](https://www.linkedin.com/company/nora-research-lab) ·
[X](https://x.com/noraresearchlab)

---

# Summary

**SatClean-Bench** provides 600 fixed Sentinel-2 RGB evaluation scenes across three controlled degradation regimes.

The benchmark asks models to transform:

```text
128 × 128 × 3
30 m degraded RGB
```

into:

```text
384 × 384 × 3
10 m clean RGB
```

while simultaneously addressing noise, spatial resolution loss, and selected structured/atmospheric artefacts.

The fixed test set, locked degradation specification, and multi-metric evaluation protocol are intended to make SatClean-Bench a reproducible reference point for research on satellite image restoration.