| """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 |
| 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) |
|
|
