The Resolution Problem

Indonesia's Spatial Planning Law (UU 26/2007) requires monitoring of building coverage across 500+ cities. But there's a problem: seeing buildings from space is expensive.

Two Satellites, One Solution

The project pairs two satellite systems. One provides the training target, the other provides the free input.

Sensor Specifications

Key parameters for the two satellite systems used in this pipeline:

The Super-Resolution Idea

The concept: show a neural network thousands of paired examples — “here's the blurry version, here's the sharp version” — until it learns to predict the sharp details from blurry input alone.

After training, the network can enhance any Sentinel-2 scene — it doesn't need PlanetScope anymore. The deep learning model has internalized the patterns that distinguish 10m imagery from 3m imagery.

Train Once Per City

Here's the economic breakthrough that makes this practical:

Check Your Understanding

The Assembly Line

Think of a semiconductor fabrication plant. Raw silicon enters one end, and through a series of precisely controlled stations — cleaning, etching, layering, testing — a finished chip emerges at the other end. Each station does one job extremely well.

This pipeline works the same way. Raw satellite files enter, and through 7 stages, enhanced imagery comes out.

The Cast of Characters

Each stage is handled by one or more Python scripts. Here's who does what:

How They Connect

Click any component to see what it does. Data flows top to bottom.

The Framework Connection

Rather than building everything from scratch, this project plugs into BasicSR, an existing super-resolution framework. The key file is launch.py — it registers all custom pieces:

# CRITICAL: Import our package FIRST to register all
# custom datasets, archs, losses, metrics with BasicSR.
import s2ps_dataset   # registers datasets
import s2ps_archs     # registers architectures
import s2ps_losses    # registers losses
import s2ps_metrics   # registers metrics
import s2ps_model     # registers models

Quick-Start Commands

Each stage of the pipeline has a corresponding command. Here are the essential recipes:

Check Your Understanding

Band Harmonization

Sentinel-2 captures light at different wavelengths — but not all bands have the same resolution. It's like having a camera where the red channel is sharp but the blue channel is blurry.

S2_L2A_BAND_INFO = {
    'B01': ('*B01_60m.jp2', 60),
    'B02': ('*B02_10m.jp2', 10),
    'B03': ('*B03_10m.jp2', 10),
    'B04': ('*B04_10m.jp2', 10),
    'B05': ('*B05_20m.jp2', 20),
    'B8A': ('*B8A_20m.jp2', 20),
}
OUTPUT_BANDS = ['B01','B02','B03','B04','B05','B8A']
NEEDS_DSEN2 = {'B01', 'B05', 'B8A'}

Aligning Two Different Cameras

Imagine taking a photo of a building from a drone at 100m altitude, then asking a friend on a different drone at 300m to photograph the same building. The photos will show the same place but from slightly different angles, at different times, with different zoom levels. Before you can compare them pixel-by-pixel, you need to align them precisely.

That's the co-registration challenge. The pipeline handles it in two steps:

Cutting Into Bite-Sized Pieces

A full satellite scene is massive — thousands of pixels wide. Patches are small, fixed-size crops that the neural network can actually process. Think of it like slicing a pizza into squares — you feed the network one square at a time.

A sliding window with 50% overlap extracts patches across the entire scene. For Semarang: 3,298 training pairs + 366 validation pairs.

for y in range(0, h_lr - self.patch_size_lr + 1, self.stride):
    for x in range(0, w_lr - self.patch_size_lr + 1, self.stride):
        lr_patch = lr_image[:, y:y+self.patch_size_lr,
                               x:x+self.patch_size_lr]
        y_hr = y * self.scale_factor
        x_hr = x * self.scale_factor
        hr_patch = hr_image[:, y_hr:y_hr+self.patch_size_hr,
                               x_hr:x_hr+self.patch_size_hr]

Speaking the Network's Language

Raw satellite values range from 0 to 10,000+ (units of surface reflectance). Neural networks work best with values between 0 and 1. Normalization bridges this gap.

def _percentile(self, image):
    result = np.zeros_like(image, dtype=np.float32)
    for c in range(image.shape[0]):
        band = image[c]
        valid = band[band > 0]
        p_low = np.percentile(valid, self.percentile_low)
        p_high = np.percentile(valid, self.percentile_high)
        if p_high - p_low > 0:
            result[c] = np.clip(
                (band - p_low) / (p_high - p_low), 0.0, 1.0
            )

Hands-On: Trace a Patch Through the Pipeline

Follow these steps to understand what happens to a single patch pair:

Preprocessing Parameters

Check Your Understanding

Two Ways to See

Think of two detectives examining a crime scene photo. One works methodically with a magnifying glass, scanning small areas one at a time. The other steps back, studying how distant clues relate to each other. Both find important details — but the second one catches patterns the first misses.

EDSR: The Workhorse CNN

EDSR's architecture is elegantly simple: compress the input through a series of residual blocks, then expand it to the target resolution.

def forward(self, x):
    head = self.head(x)
    body = self.body(head)
    body = body + head  # Global residual
    up = self.upsample(body)
    out = self.tail(up)
    return out

The Band Adapter Trick

Most pretrained super-resolution models expect 3-channel RGB input. Our satellite data has 6 bands. The BandAdapter pattern solves this with learnable 1×1 convolutions that wrap any pretrained model:

def _init_adapters(self):
    with torch.no_grad():
        w_in = self.adapter_in[0].weight
        nn.init.zeros_(w_in)
        for i in range(min(3, self.num_bands)):
            w_in[i, i, 0, 0] = 1.0

Architecture Specifications

Check Your Understanding

The Grading Rubric

Imagine grading a student's painting of a landscape. You could score it on two axes: (1) “Does each brushstroke land in the right spot?” — pixel accuracy; and (2) “Do the colors look natural together?” — spectral fidelity. This pipeline uses two loss functions that capture exactly these two qualities:

p = pred.reshape(b, c, -1)
t = target.reshape(b, c, -1)

dot = (p * t).sum(dim=1)
norm_p = p.norm(dim=1).clamp(min=self.eps)
norm_t = t.norm(dim=1).clamp(min=self.eps)

cos_angle = (dot / (norm_p * norm_t)).clamp(-1+self.eps, 1-self.eps)
sam = torch.acos(cos_angle)

The Training Loop

Training is a conversation between the model and its grading rubric, repeated 500,000 times. Each iteration follows the same pattern:

Training by Recipe Card

Every experiment is defined by a YAML configuration file. Change the recipe, change the experiment — no code modifications needed.

A Day in Training

Here's what the training process looks like as a conversation between the components:

Tuning Your Experiment

Common adjustments you can make by editing the YAML config — no code changes needed:

Training Configuration Reference

Check Your Understanding

Why Tiles?

A full Sentinel-2 scene is roughly 10,000 × 10,000 pixels. The neural network was trained on 64×64 patches. You can't feed the whole scene at once — it would need more GPU memory than exists.

The solution: slide a window across the scene, process each tile independently, then stitch the results together. Like mowing a lawn in overlapping rows — but the overlap is where the magic happens.

The Seamless Stitch

Without blending, you'd see visible grid lines where tiles meet — each tile's edge pixels would abruptly jump to the next tile's values. The solution: a raised-cosine blend window that tapers each tile's contribution from full strength at the center to zero at the edges.

def _make_blend_window(size, overlap):
    w = np.ones(size, dtype=np.float32)
    ramp = np.linspace(0, 1, overlap, dtype=np.float32)
    cos_ramp = 0.5 * (1 - np.cos(np.pi * ramp))
    w[:overlap] *= cos_ramp
    w[-overlap:] *= cos_ramp[::-1]
    window = w[np.newaxis, :] * w[:, np.newaxis]
    return window[np.newaxis]

The Core Loop

For every tile: extract, predict, accumulate with blending weights. Then divide by total weight to normalize.

with torch.no_grad():
  for row in range(n_rows):
    for col in range(n_cols):
      y0 = min(row * stride, h - tile_size)
      x0 = min(col * stride, w - tile_size)
      tile_lr = img_norm[:, y0:y1, x0:x1]
      tile_sr = model(tile_t)
      output[:, oy0:oy1, ox0:ox1] += tile_sr * blend
      weight[:, oy0:oy1, ox0:ox1] += blend

Hands-On: Trace a Tile Through Inference

Troubleshooting Inference

Inference Parameters

Check Your Understanding

The Report Card

How do you know if enhanced imagery is actually good? You need metrics that capture different aspects of quality — like grading an essay on both grammar and content, not just word count.

Semarang Results

Here's how each method performed on the Semarang test set:

Beyond Pixels: Real-World Impact

Sharp pixels are nice, but do they help with actual urban monitoring? The research tested this with land cover classification:

The Band-by-Band Story

Not all bands improve equally. The original resolution of each band matters:

Metric Quality Thresholds

Use these thresholds to interpret your model's output quality:

Running Evaluation

Final Assessment

Course Complete

You now understand the full pipeline — from raw satellite downloads to enhanced 3-meter imagery. The key takeaways: