Datasets:
File size: 4,600 Bytes
4878bd3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | """Canonical masks, sample-balanced statistics, and normalization."""
import hashlib
import json
from pathlib import Path
import numpy as np
VERSION = 'eo-independent-reconstruction-v1'
BANDS = ('Blue', 'Green', 'Red', 'NIR', 'SWIR1', 'SWIR2')
ALIASES = {'prithvi': 'prithvi', 'prithvi_data': 'prithvi',
'lstsr_tb': 'lstsr_tb', 'lstsr': 'lstsr_tb',
'lstsr_tb_final_upload_20260721': 'lstsr_tb'}
def dataset_name(name):
try:
return ALIASES[name]
except KeyError:
raise ValueError(f'Unknown dataset {name!r}; use prithvi or lstsr_tb') from None
def modality_name(name):
if name in ('lst', 'lst_hr'):
return 'lst_hr'
if name == 'hls':
return name
raise ValueError('Use hls or lst_hr (alias lst)')
def sha256_file(path):
h = hashlib.sha256()
with Path(path).open('rb') as f:
for block in iter(lambda: f.read(8 * 1024 * 1024), b''):
h.update(block)
return h.hexdigest()
def json_write(path, value):
path = Path(path)
temp = path.with_suffix(path.suffix + '.tmp')
temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False), encoding='utf-8')
temp.replace(path)
def canonical(raw, modality, dataset, fmask=None, source_valid=None):
"""Decode each source without clipping, resizing, or per-image fitting."""
modality = modality_name(modality)
raw = np.asarray(raw)
if modality == 'hls':
if raw.shape != (6, 256, 256) or raw.dtype != np.int16:
raise ValueError(f'Unexpected HLS schema {raw.shape}, {raw.dtype}')
if fmask is None or fmask.shape != (256, 256) or fmask.dtype != np.uint8:
raise ValueError('Expected uint8 HLS Fmask [256,256]')
fill = (-9999, -32767, -32768) if dataset == 'prithvi' else (-32768,)
valid = ~np.isin(raw, fill).any(axis=0)
valid &= (fmask != 255) & ((fmask & 14) == 0)
scale = 0.0001
else:
if raw.shape != (256, 256) or raw.dtype != np.int16:
raise ValueError(f'Unexpected HR LST schema {raw.shape}, {raw.dtype}')
fill = (-32767,) if dataset == 'prithvi' else (-32768,)
valid = ~np.isin(raw, fill)
raw = raw[None]
scale = 1.0 # Explicit raw-coded LST; no unverified temperature unit.
if source_valid is not None:
if source_valid.shape != (256, 256):
raise ValueError('Invalid source mask shape')
valid &= source_valid.astype(bool)
image = raw.astype(np.float32) * np.float32(scale)
return image, valid[None]
def sample_moments(image, mask):
n = int(mask.sum())
if n == 0:
return None
values = image[:, mask[0]].astype(np.float64)
return {'pixels': n, 'mean': values.mean(axis=1).tolist(),
'second': np.square(values).mean(axis=1).tolist()}
def empty_accumulator(channels):
return {'samples': 0, 'pixels': 0, 'sum_mean': [0.0]*channels, 'sum_second': [0.0]*channels}
def accumulate(acc, moments):
if moments is None:
return
acc['samples'] += 1
acc['pixels'] += moments['pixels']
acc['sum_mean'] = (np.asarray(acc['sum_mean']) + moments['mean']).tolist()
acc['sum_second'] = (np.asarray(acc['sum_second']) + moments['second']).tolist()
def finish_stats(acc, modality):
if not acc['samples']:
raise ValueError(f'No valid training samples for {modality}')
mean = np.asarray(acc['sum_mean']) / acc['samples']
variance = np.maximum(np.asarray(acc['sum_second']) / acc['samples'] - mean**2, 0)
std = np.sqrt(variance)
return {'mean': mean.tolist(), 'std': np.maximum(std, 1e-6).tolist(),
'unfloored_std': std.tolist(), 'std_floor': 1e-6,
'samples': acc['samples'], 'valid_spatial_pixels': acc['pixels'],
'fit_split': 'train', 'weighting': 'equal_samples_then_equal_valid_pixels_within_sample',
'units': 'reflectance' if modality == 'hls' else 'source_raw_int16_units',
'physical_temperature_unit_confirmed': False if modality == 'lst_hr' else None}
def normalize(image, mask, stats):
mean = np.asarray(stats['mean'], np.float32)[:, None, None]
std = np.asarray(stats['std'], np.float32)[:, None, None]
return np.where(mask, (image - mean) / std, np.float32(0)).astype(np.float32)
def denormalize(image, stats):
"""Channel axis is -3; supports [C,H,W] and [B,C,H,W]."""
shape = [1] * np.ndim(image)
shape[-3] = len(stats['mean'])
return np.asarray(image) * np.asarray(stats['std'], np.float32).reshape(shape) + np.asarray(stats['mean'], np.float32).reshape(shape)
|