Stop tracking grayscale mixed local files

.gitignore

@@ -0,0 +1,9 @@
+paper/
+configs/config_mixed_domain_ft_segformer_reliable5_grayscale.yaml
+dataset/definition_dataset_grayscale_mixed.py
+dataset/flairhub_grayscale_mixed.py
+dataset/prepare_swisstlm3d_patches.py
+dataset/rasterize_swisstlm3d.py
+dataset/split_swisstlm3d_geographic.py
+dataset/stats_swisstlm3d_masks.py
+dataset/swissimage_grayscale_mixed.py

configs/config_mixed_domain_ft_segformer_reliable5_grayscale.yaml

@@ -1,74 +0,0 @@
-paths:
-  flairhub_path: /mnt/CalcShare/datasets/FLAIR1024_merged
-  swiss_path: /mnt/CalcShare/datasets/Suisse_full/data/swisstlm3d_reliable5_forest_center20_patches_2048to1024_split
-
-  flairhub_train_img_subdir: train/img
-  flairhub_train_msk_subdir: train/msk
-  flairhub_val_img_subdir: valid/img
-  flairhub_val_msk_subdir: valid/msk
-  flairhub_test_img_subdir: test/img
-  flairhub_test_msk_subdir: test/msk
-
-  swiss_train_img_subdir: train/img
-  swiss_train_msk_subdir: train/msk
-  swiss_val_img_subdir: val/img
-  swiss_val_msk_subdir: val/msk
-  swiss_test_img_subdir: test/img
-  swiss_test_msk_subdir: test/msk
-
-  save_dir: weights
-  pretrained_path: weights/CASWiT-Base-SSL-aug_FLAIRHUB_SF.pth
-
-model:
-  model_name: openmmlab/upernet-swin-base
-  num_classes: 15  # Keep the 15-class head for exact FLAIR-HUB checkpoint compatibility; forest merge is handled by label remapping below.
-  cross_attention_heads: 1
-  ignore_index: 255
-  fusion_mlp_ratio: 4.0
-  fusion_drop_path: 0.1
-  lr_supervision_weight: 0.5
-  head: segformer
-
-training:
-  batch_size: 1
-  num_workers: 8
-  num_epochs: 10
-  learning_rate: 8.0e-06
-  amp: true
-  seed: 42
-  eta_min: 1.0e-06
-
-mixed:
-  # Conservative domain adaptation with sparse high-confidence SwissTLM3D labels only.
-  swiss_ratio: 0.20
-  epoch_length: 0
-  best_on: mean
-  simulate_grayscale_inputs: true
-
-labels:
-  flair_label_remap:
-    13: 12
-  swiss_label_remap:
-    13: 12
-
-wandb:
-  use_wandb: true
-  project: CASWiT-SwissTLM3D
-  entity: soloo
-  run_name: CASWiT-Base-SSL-aug_FLAIRHUB_SF_mixed_ft_reliable5_forest_center20_gray_r02
-
-print_device: true
-
-augmentations:
-  enable: true
-  p_hflip: 0.5
-  p_vflip: 0.5
-  p_rot90: 0.5
-  color_jitter:
-    brightness: 0.05
-    contrast: 0.05
-    saturation: 0.05
-    hue: 0.02
-  blur:
-    p: 0.0
-    kernel: 3

dataset/definition_dataset_grayscale_mixed.py

@@ -1,114 +0,0 @@
-"""
-Dataset definitions dedicated to grayscale-simulated mixed-domain fine-tuning.
-
-This variant keeps the exact same HR/LR extraction logic as the standard fusion
-dataset, but converts RGB imagery to simulated grayscale replicated on 3 bands
-directly inside the dataset definition.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Dict, Optional
-
-import numpy as np
-import torch
-from PIL import Image
-from torch.utils.data import Dataset
-from torchvision import transforms
-
-from dataset.definition_dataset import (
-    apply_label_remap,
-    load_image,
-    load_mask,
-    to_pil_uint8,
-    to_tensor_img,
-)
-
-
-def simulate_grayscale_rgb(image_hwc_float01: np.ndarray) -> np.ndarray:
-    """
-    Convert an RGB image in [0,1] to simulated grayscale and replicate it on 3 channels.
-    """
-    if image_hwc_float01.ndim != 3 or image_hwc_float01.shape[-1] != 3:
-        raise ValueError(
-            f"simulate_grayscale_rgb expects HWC RGB input, got shape={image_hwc_float01.shape}"
-        )
-    gray = (
-        0.299 * image_hwc_float01[..., 0]
-        + 0.587 * image_hwc_float01[..., 1]
-        + 0.114 * image_hwc_float01[..., 2]
-    ).astype(np.float32, copy=False)
-    return np.repeat(gray[..., None], 3, axis=-1)
-
-
-class SemanticSegmentationDatasetFusionGrayscaleMixed(Dataset):
-    """
-    Mixed-domain HR/LR fusion dataset with grayscale simulation replicated on 3 bands.
-
-    The geometry, crops, downsampling and augmentations are intentionally kept
-    identical to the standard fusion dataset so that only the color information
-    is removed during training/validation/test.
-    """
-
-    def __init__(
-        self,
-        image_dir: Path,
-        mask_dir: Path,
-        transform: Optional[transforms.Compose] = None,
-        augment=None,
-        label_remap: Optional[Dict[int, int]] = None,
-    ):
-        self.image_dir = Path(image_dir)
-        self.mask_dir = Path(mask_dir)
-        self.image_filenames = sorted(os.listdir(self.image_dir))
-        self.mask_filenames = sorted(os.listdir(self.mask_dir))
-        assert len(self.image_filenames) == len(self.mask_filenames), "Images/Masks count mismatch"
-        self.transform = transform
-        self.augment = augment
-        self.label_remap = label_remap or {}
-
-    def __len__(self):
-        return len(self.image_filenames)
-
-    def __getitem__(self, idx):
-        image_path = self.image_dir / self.image_filenames[idx]
-        mask_path = self.mask_dir / self.mask_filenames[idx]
-
-        image = simulate_grayscale_rgb(load_image(image_path))
-        mask = load_mask(mask_path)
-        mask = apply_label_remap(mask, self.label_remap)
-        mask[mask >= 15] = 255
-
-        hr_crop_size = 512
-        crop_x, crop_y = 256, 256
-
-        image_hr = image[crop_x:crop_x + hr_crop_size, crop_y:crop_y + hr_crop_size]
-        mask_hr = mask[crop_x:crop_x + hr_crop_size, crop_y:crop_y + hr_crop_size]
-
-        image_lr = image[::2, ::2, :]
-        mask_lr = mask[::2, ::2]
-
-        img_hr_pil = to_pil_uint8(image_hr)
-        img_lr_pil = to_pil_uint8(image_lr)
-
-        m_hr_pil = Image.fromarray(mask_hr.astype(np.uint8), mode="L")
-        m_lr_pil = Image.fromarray(mask_lr.astype(np.uint8), mode="L")
-
-        if self.augment is not None:
-            img_hr_pil, m_hr_pil, img_lr_pil, m_lr_pil = self.augment(
-                img_hr_pil, m_hr_pil, img_lr_pil, m_lr_pil
-            )
-
-        if self.transform:
-            image_hr = self.transform(img_hr_pil)
-            image_lr = self.transform(img_lr_pil)
-        else:
-            image_hr = to_tensor_img(np.array(img_hr_pil))
-            image_lr = to_tensor_img(np.array(img_lr_pil))
-
-        mask_hr = torch.as_tensor(np.array(m_hr_pil, dtype=np.uint8), dtype=torch.long)
-        mask_lr = torch.as_tensor(np.array(m_lr_pil, dtype=np.uint8), dtype=torch.long)
-
-        return image_hr, mask_hr, image_lr, mask_lr

dataset/flairhub_grayscale_mixed.py

@@ -1,24 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-from torchvision import transforms
-
-from dataset.definition_dataset_grayscale_mixed import (
-    SemanticSegmentationDatasetFusionGrayscaleMixed,
-)
-
-
-def build(
-    image_dir: Path,
-    mask_dir: Path,
-    transform: Optional[transforms.Compose],
-    augment=None,
-    label_remap: Optional[Dict[int, int]] = None,
-):
-    return SemanticSegmentationDatasetFusionGrayscaleMixed(
-        image_dir,
-        mask_dir,
-        transform=transform,
-        augment=augment,
-        label_remap=label_remap,
-    )

dataset/prepare_swisstlm3d_patches.py

@@ -1,233 +0,0 @@
-"""
-Prepare SwissImage + SwissTLM3D patches for training.
-
-Optimized version:
-- processes source tiles in parallel across multiple CPU workers
-- reads only 2048x2048 windows with rasterio instead of loading whole 10000x10000 tiles
-- resizes image patches to 1024x1024 with bilinear interpolation
-- resizes mask patches to 1024x1024 with nearest-neighbor interpolation
-- optionally skips patches whose mask is entirely 255
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import sys
-from concurrent.futures import ProcessPoolExecutor, as_completed
-from pathlib import Path
-
-import numpy as np
-import rasterio
-from PIL import Image
-from tqdm import tqdm
-
-
-project_root = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(project_root))
-
-Image.MAX_IMAGE_PIXELS = None
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Prepare 2048->1024 SwissTLM3D training patches.")
-    parser.add_argument(
-        "--image_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/image"),
-        help="Directory containing full SwissImage tiles.",
-    )
-    parser.add_argument(
-        "--mask_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/mask_tlm3d"),
-        help="Directory containing full SwissTLM3D masks aligned with image_dir.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/swisstlm3d_patches_2048to1024"),
-        help="Directory where prepared patches will be written.",
-    )
-    parser.add_argument(
-        "--tile_size",
-        type=int,
-        default=2048,
-        help="Patch size extracted from the original SwissImage tile.",
-    )
-    parser.add_argument(
-        "--output_size",
-        type=int,
-        default=1024,
-        help="Final patch size after resizing.",
-    )
-    parser.add_argument(
-        "--ignore_index",
-        type=int,
-        default=255,
-        help="Ignore label value in masks.",
-    )
-    parser.add_argument(
-        "--drop_all_ignore",
-        action="store_true",
-        help="Skip patches whose mask is entirely equal to ignore_index.",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Overwrite existing patch files if they already exist.",
-    )
-    parser.add_argument(
-        "--workers",
-        type=int,
-        default=os.cpu_count() or 1,
-        help="Number of worker processes. Default: all visible CPU cores.",
-    )
-    return parser.parse_args()
-
-
-def ensure_output_dirs(output_dir: Path) -> tuple[Path, Path]:
-    img_dir = output_dir / "img"
-    msk_dir = output_dir / "msk"
-    img_dir.mkdir(parents=True, exist_ok=True)
-    msk_dir.mkdir(parents=True, exist_ok=True)
-    return img_dir, msk_dir
-
-
-def resize_image_patch(image_hwc_uint8: np.ndarray, output_size: int) -> np.ndarray:
-    img = Image.fromarray(image_hwc_uint8, mode="RGB")
-    img = img.resize((output_size, output_size), resample=Image.BILINEAR)
-    return np.asarray(img, dtype=np.uint8)
-
-
-def resize_mask_patch(mask_hw: np.ndarray, output_size: int) -> np.ndarray:
-    img = Image.fromarray(mask_hw.astype(np.uint8), mode="L")
-    img = img.resize((output_size, output_size), resample=Image.NEAREST)
-    return np.asarray(img, dtype=np.uint8)
-
-
-def iter_non_overlapping_windows(height: int, width: int, tile_size: int):
-    for y0 in range(0, height - tile_size + 1, tile_size):
-        for x0 in range(0, width - tile_size + 1, tile_size):
-            yield y0, x0
-
-
-def patch_name(stem: str, y0: int, x0: int) -> str:
-    return f"{stem}_y{y0:05d}_x{x0:05d}.tif"
-
-
-def read_image_window(src: rasterio.DatasetReader, y0: int, x0: int, tile_size: int) -> np.ndarray:
-    window = rasterio.windows.Window(col_off=x0, row_off=y0, width=tile_size, height=tile_size)
-    arr = src.read(indexes=[1, 2, 3], window=window)  # CHW
-    return np.transpose(arr, (1, 2, 0)).astype(np.uint8, copy=False)
-
-
-def read_mask_window(src: rasterio.DatasetReader, y0: int, x0: int, tile_size: int) -> np.ndarray:
-    window = rasterio.windows.Window(col_off=x0, row_off=y0, width=tile_size, height=tile_size)
-    return src.read(1, window=window)
-
-
-def process_tile(
-    image_path: str,
-    mask_path: str,
-    out_img_dir: str,
-    out_msk_dir: str,
-    tile_size: int,
-    output_size: int,
-    ignore_index: int,
-    drop_all_ignore: bool,
-    overwrite: bool,
-) -> tuple[int, int, int]:
-    image_path = Path(image_path)
-    mask_path = Path(mask_path)
-    out_img_dir = Path(out_img_dir)
-    out_msk_dir = Path(out_msk_dir)
-
-    kept = 0
-    dropped_all_ignore_count = 0
-    total_windows = 0
-    stem = image_path.stem
-
-    with rasterio.open(image_path) as img_src, rasterio.open(mask_path) as msk_src:
-        if (img_src.height, img_src.width) != (msk_src.height, msk_src.width):
-            raise ValueError(
-                f"Shape mismatch for {image_path.name}: "
-                f"image={(img_src.height, img_src.width)} mask={(msk_src.height, msk_src.width)}"
-            )
-
-        for y0, x0 in iter_non_overlapping_windows(msk_src.height, msk_src.width, tile_size):
-            total_windows += 1
-            out_name = patch_name(stem, y0, x0)
-            out_img = out_img_dir / out_name
-            out_msk = out_msk_dir / out_name
-
-            if not overwrite and out_img.exists() and out_msk.exists():
-                kept += 1
-                continue
-
-            mask_patch = read_mask_window(msk_src, y0, x0, tile_size)
-            if drop_all_ignore and np.all(mask_patch == ignore_index):
-                dropped_all_ignore_count += 1
-                continue
-
-            image_patch = read_image_window(img_src, y0, x0, tile_size)
-            image_patch_resized = resize_image_patch(image_patch, output_size)
-            mask_patch_resized = resize_mask_patch(mask_patch, output_size)
-
-            Image.fromarray(image_patch_resized, mode="RGB").save(out_img)
-            Image.fromarray(mask_patch_resized, mode="L").save(out_msk)
-            kept += 1
-
-    return kept, dropped_all_ignore_count, total_windows
-
-
-def main() -> None:
-    args = parse_args()
-    out_img_dir, out_msk_dir = ensure_output_dirs(args.output_dir)
-
-    image_paths = {p.name: p for p in sorted(args.image_dir.glob("*.tif"))}
-    mask_paths = {p.name: p for p in sorted(args.mask_dir.glob("*.tif"))}
-    common_names = sorted(image_paths.keys() & mask_paths.keys())
-
-    if not common_names:
-        raise RuntimeError("No matching .tif image/mask pairs found.")
-
-    workers = max(1, int(args.workers))
-    kept = 0
-    dropped_all_ignore = 0
-    total_windows = 0
-
-    with ProcessPoolExecutor(max_workers=workers) as executor:
-        futures = [
-            executor.submit(
-                process_tile,
-                str(image_paths[name]),
-                str(mask_paths[name]),
-                str(out_img_dir),
-                str(out_msk_dir),
-                int(args.tile_size),
-                int(args.output_size),
-                int(args.ignore_index),
-                bool(args.drop_all_ignore),
-                bool(args.overwrite),
-            )
-            for name in common_names
-        ]
-
-        for future in tqdm(as_completed(futures), total=len(futures), desc="Tiles", unit="tile"):
-            tile_kept, tile_dropped, tile_windows = future.result()
-            kept += tile_kept
-            dropped_all_ignore += tile_dropped
-            total_windows += tile_windows
-
-    print(f"matched_tiles: {len(common_names)}")
-    print(f"workers: {workers}")
-    print(f"total_windows: {total_windows}")
-    print(f"kept_patches: {kept}")
-    print(f"dropped_all_ignore: {dropped_all_ignore}")
-    print(f"output_img_dir: {out_img_dir}")
-    print(f"output_msk_dir: {out_msk_dir}")
-
-
-if __name__ == "__main__":
-    main()

dataset/rasterize_swisstlm3d.py

@@ -1,403 +0,0 @@
-"""
-Rasterize SwissTLM3D features onto SwissImage tiles.
-
-This script writes masks that are compatible with the 15-class FLAIR-HUB
-land-cover setup used in this repository. SwissTLM3D does not expose every
-FLAIR-HUB class with the same level of granularity, so the script only
-projects a reliable subset of classes and leaves the rest to ignore_index=255.
-
-The implementation intentionally relies on GDAL/OGR command-line tools
-(`gdal_rasterize`) plus `rasterio`, because the current `caswit` environment
-does not ship a full vector Python stack.
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import subprocess
-from concurrent.futures import ProcessPoolExecutor, as_completed
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable
-
-import numpy as np
-import rasterio
-from rasterio.errors import RasterioIOError
-from tqdm import tqdm
-
-
-IGNORE_INDEX = 255
-
-
-FLAIR_HUB_CLASSES = {
-    0: "building",
-    1: "greenhouse",
-    2: "swimming_pool",
-    3: "impervious surface",
-    4: "pervious surface",
-    5: "bare soil",
-    6: "water",
-    7: "snow",
-    8: "herbaceous vegetation",
-    9: "agricultural land",
-    10: "plowed land",
-    11: "vineyard",
-    12: "deciduous",
-    13: "coniferous",
-    14: "brushwood",
-}
-
-
-def sql_in(values: Iterable[str]) -> str:
-    return "(" + ", ".join(f"'{value}'" for value in values) + ")"
-
-
-@dataclass(frozen=True)
-class BurnSpec:
-    name: str
-    layer: str
-    class_id: int
-    where: str
-    sql_expr: str = "geom"
-
-    @property
-    def rtree(self) -> str:
-        return f"rtree_{self.layer}_geom"
-
-    def sql(self, minx: float, miny: float, maxx: float, maxy: float) -> str:
-        spatial_filter = (
-            f"id IN (SELECT id FROM {self.rtree} "
-            f"WHERE maxx >= {minx} AND minx <= {maxx} "
-            f"AND maxy >= {miny} AND miny <= {maxy})"
-        )
-        return (
-            f"SELECT {self.sql_expr} AS geom "
-            f"FROM {self.layer} "
-            f"WHERE ({self.where}) AND {spatial_filter}"
-        )
-
-
-ROAD_WIDTH_CASE = """
-CASE objektart
-    WHEN '1m Weg' THEN 0.5
-    WHEN '1m Wegfragment' THEN 0.5
-    WHEN '2m Weg' THEN 1.0
-    WHEN '2m Wegfragment' THEN 1.0
-    WHEN '3m Strasse' THEN 1.5
-    WHEN '4m Strasse' THEN 2.0
-    WHEN '6m Strasse' THEN 3.0
-    WHEN '8m Strasse' THEN 4.0
-    WHEN '10m Strasse' THEN 5.0
-    WHEN 'Autobahn' THEN 10.0
-    WHEN 'Autostrasse' THEN 6.0
-    WHEN 'Ausfahrt' THEN 3.5
-    WHEN 'Einfahrt' THEN 3.0
-    WHEN 'Zufahrt' THEN 3.0
-    WHEN 'Dienstzufahrt' THEN 3.0
-    WHEN 'Raststaette' THEN 8.0
-    WHEN 'Platz' THEN 6.0
-    WHEN 'Markierte Spur' THEN 2.0
-    WHEN 'Verbindung' THEN 2.0
-    ELSE 0.0
-END
-""".strip()
-
-
-BUILDING_OBJECTS = (
-    "Gebaeude",
-    "Hochhaus",
-    "Historische Baute",
-    "Im Bau",
-    "Kapelle",
-    "Offenes Gebaeude",
-    "Sakraler Turm",
-    "Sakrales Gebaeude",
-    "Turm",
-    "Unterirdisches Gebaeude",
-    "Einhausung",
-)
-
-GREENHOUSE_OBJECTS = ("Treibhaus",)
-
-BARE_SOIL_OBJECTS = (
-    "Fels",
-    "Fels locker",
-    "Felsbloecke",
-    "Felsbloecke locker",
-    "Lockergestein",
-    "Lockergestein locker",
-)
-
-WATER_OBJECTS = (
-    "Fliessgewaesser",
-    "Stehende Gewaesser",
-)
-
-SNOW_OBJECTS = (
-    "Gletscher",
-    "Schneefeld Toteis",
-)
-
-BRUSHWOOD_OBJECTS = ("Gebueschwald",)
-
-AGRICULTURAL_OBJECTS = (
-    "Baumschule",
-    "Obstanlage",
-    "Schrebergartenareal",
-)
-
-VINEYARD_OBJECTS = ("Reben",)
-
-TRAFFIC_AREA_OBJECTS = (
-    "Flugfeldareal",
-    "Flughafenareal",
-    "Flugplatzareal",
-    "Gleisareal",
-    "Heliport",
-    "Oeffentliches Parkplatzareal",
-    "Privates Fahrareal",
-    "Privates Parkplatzareal",
-    "Rastplatzareal",
-    "Verkehrsflaeche",
-)
-
-ROAD_OBJECTS = (
-    "10m Strasse",
-    "1m Weg",
-    "1m Wegfragment",
-    "2m Weg",
-    "2m Wegfragment",
-    "3m Strasse",
-    "4m Strasse",
-    "6m Strasse",
-    "8m Strasse",
-    "Ausfahrt",
-    "Autobahn",
-    "Autostrasse",
-    "Dienstzufahrt",
-    "Einfahrt",
-    "Markierte Spur",
-    "Platz",
-    "Raststaette",
-    "Verbindung",
-    "Zufahrt",
-)
-
-
-BURN_SPECS = (
-    BurnSpec(
-        name="bare_soil",
-        layer="tlm_bb_bodenbedeckung",
-        class_id=5,
-        where=f"objektart IN {sql_in(BARE_SOIL_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="snow",
-        layer="tlm_bb_bodenbedeckung",
-        class_id=7,
-        where=f"objektart IN {sql_in(SNOW_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="brushwood",
-        layer="tlm_bb_bodenbedeckung",
-        class_id=14,
-        where=f"objektart IN {sql_in(BRUSHWOOD_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="agricultural_land",
-        layer="tlm_areale_nutzungsareal",
-        class_id=9,
-        where=f"objektart IN {sql_in(AGRICULTURAL_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="vineyard",
-        layer="tlm_areale_nutzungsareal",
-        class_id=11,
-        where=f"objektart IN {sql_in(VINEYARD_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="impervious_polygons",
-        layer="tlm_areale_verkehrsareal",
-        class_id=3,
-        where=f"objektart IN {sql_in(TRAFFIC_AREA_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="impervious_roads",
-        layer="tlm_strassen_strasse",
-        class_id=3,
-        where=f"objektart IN {sql_in(ROAD_OBJECTS)}",
-        sql_expr=f"ST_Buffer(geom, {ROAD_WIDTH_CASE})",
-    ),
-    BurnSpec(
-        name="water",
-        layer="tlm_bb_bodenbedeckung",
-        class_id=6,
-        where=f"objektart IN {sql_in(WATER_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="building",
-        layer="tlm_bauten_gebaeude_footprint",
-        class_id=0,
-        where=f"objektart IN {sql_in(BUILDING_OBJECTS)}",
-    ),
-    BurnSpec(
-        name="greenhouse",
-        layer="tlm_bauten_gebaeude_footprint",
-        class_id=1,
-        where=f"objektart IN {sql_in(GREENHOUSE_OBJECTS)}",
-    ),
-)
-
-
-def init_mask_from_image(image_path: Path, output_path: Path) -> tuple[float, float, float, float, int, int]:
-    if output_path.exists():
-        output_path.unlink()
-
-    with rasterio.open(image_path) as src:
-        bounds = src.bounds
-        width = src.width
-        height = src.height
-        transform = src.transform
-        crs = src.crs
-
-    profile = {
-        "driver": "GTiff",
-        "width": width,
-        "height": height,
-        "count": 1,
-        "dtype": "uint8",
-        "crs": crs,
-        "transform": transform,
-        "nodata": IGNORE_INDEX,
-        "compress": "lzw",
-        "tiled": True,
-        "blockxsize": 512,
-        "blockysize": 512,
-    }
-    with rasterio.open(output_path, "w", **profile) as dst:
-        dst.write(np.full((1, height, width), IGNORE_INDEX, dtype=np.uint8))
-
-    return bounds.left, bounds.bottom, bounds.right, bounds.top, width, height
-
-
-def rasterize_spec(
-    gpkg_path: Path,
-    output_path: Path,
-    spec: BurnSpec,
-    minx: float,
-    miny: float,
-    maxx: float,
-    maxy: float,
-    width: int,
-    height: int,
-) -> None:
-    sql = spec.sql(minx=minx, miny=miny, maxx=maxx, maxy=maxy)
-    command = [
-        "gdal_rasterize",
-        "-b",
-        "1",
-        "-burn",
-        str(spec.class_id),
-        "-sql",
-        sql,
-        "-dialect",
-        "SQLITE",
-        str(gpkg_path),
-        str(output_path),
-    ]
-    subprocess.run(command, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-
-
-def process_one(image_path: Path, output_dir: Path, gpkg_path: Path, overwrite: bool) -> tuple[str, str]:
-    output_path = output_dir / image_path.name
-    if output_path.exists() and not overwrite:
-        return image_path.name, "skipped"
-
-    try:
-        minx, miny, maxx, maxy, width, height = init_mask_from_image(image_path, output_path)
-        for spec in BURN_SPECS:
-            rasterize_spec(
-                gpkg_path=gpkg_path,
-                output_path=output_path,
-                spec=spec,
-                minx=minx,
-                miny=miny,
-                maxx=maxx,
-                maxy=maxy,
-                width=width,
-                height=height,
-            )
-    except (subprocess.CalledProcessError, RasterioIOError) as exc:
-        return image_path.name, f"error: {exc}"
-
-    return image_path.name, "ok"
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Rasterize SwissTLM3D onto SwissImage tiles.")
-    parser.add_argument(
-        "--gpkg",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/swisstlm3d/SWISSTLM3D_2026_LV95_LN02.gpkg"),
-        help="Path to the extracted SwissTLM3D GeoPackage.",
-    )
-    parser.add_argument(
-        "--image_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/image"),
-        help="Directory containing SwissImage GeoTIFF tiles.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/mask_tlm3d"),
-        help="Directory where rasterized masks will be written.",
-    )
-    parser.add_argument("--workers", type=int, default=max(1, os.cpu_count() // 2))
-    parser.add_argument("--limit", type=int, default=None, help="Optional number of image tiles to process.")
-    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing masks.")
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    args.output_dir.mkdir(parents=True, exist_ok=True)
-
-    if not args.gpkg.exists():
-        raise FileNotFoundError(f"Missing SwissTLM3D GeoPackage: {args.gpkg}")
-    if not args.image_dir.exists():
-        raise FileNotFoundError(f"Missing SwissImage directory: {args.image_dir}")
-
-    image_paths = sorted(args.image_dir.glob("*.tif"))
-    if args.limit is not None:
-        image_paths = image_paths[: args.limit]
-
-    if not image_paths:
-        raise RuntimeError(f"No .tif files found in {args.image_dir}")
-
-    failures = []
-    with ProcessPoolExecutor(max_workers=args.workers) as executor:
-        futures = {
-            executor.submit(process_one, image_path, args.output_dir, args.gpkg, args.overwrite): image_path
-            for image_path in image_paths
-        }
-        for future in tqdm(as_completed(futures), total=len(futures), desc="Rasterizing SwissTLM3D"):
-            image_name, status = future.result()
-            if status != "ok" and status != "skipped":
-                failures.append((image_name, status))
-
-    if failures:
-        print("Failures:")
-        for image_name, status in failures[:20]:
-            print(f"- {image_name}: {status}")
-        raise SystemExit(1)
-
-    print(f"Done. Wrote masks to {args.output_dir}")
-    print("Projected classes:")
-    for spec in BURN_SPECS:
-        print(f"- {spec.class_id:2d}: {FLAIR_HUB_CLASSES[spec.class_id]} ({spec.name})")
-
-
-if __name__ == "__main__":
-    main()

dataset/split_swisstlm3d_geographic.py

@@ -1,314 +0,0 @@
-"""
-Create a deterministic random split for SwissImage + SwissTLM3D masks.
-
-Supported naming conventions:
-1. Full tiles:
-   swissimage-dop10_<year>_<x>-<y>_0.1_2056.tif
-2. Prepared patches:
-   swissimage-dop10_<year>_<x>-<y>_0.1_2056_y<row>_x<col>.tif
-
-For prepared patches, the split is performed at source-tile level `(year, x, y)`,
-so all patches from the same original tile stay in the same split.
-"""
-
-from __future__ import annotations
-
-import argparse
-import csv
-import os
-import random
-import re
-import shutil
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Iterable
-
-
-FULL_TILE_RE = re.compile(
-    r"^swissimage-dop10_(?P<year>\d{4})_(?P<x>\d+)-(?P<y>\d+)_0\.1_2056\.tif$"
-)
-PATCH_RE = re.compile(
-    r"^swissimage-dop10_(?P<year>\d{4})_(?P<x>\d+)-(?P<y>\d+)_0\.1_2056_y(?P<yoff>\d+)_x(?P<xoff>\d+)\.tif$"
-)
-
-
-@dataclass(frozen=True)
-class TileRecord:
-    name: str
-    year: int
-    x: int
-    y: int
-    x_offset: int
-    y_offset: int
-    x_geo: int
-    y_geo: int
-    image_path: Path
-    mask_path: Path
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Create a random 60/20/20 split for SwissTLM3D fine-tuning.")
-    parser.add_argument(
-        "--image_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/image"),
-        help="Directory containing SwissImage tiles.",
-    )
-    parser.add_argument(
-        "--mask_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/mask_tlm3d"),
-        help="Directory containing SwissTLM3D masks with matching filenames.",
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/swisstlm3d_ft"),
-        help="Output root with train/val/test subfolders.",
-    )
-    parser.add_argument(
-        "--train_ratio",
-        type=float,
-        default=0.6,
-        help="Train ratio.",
-    )
-    parser.add_argument(
-        "--val_ratio",
-        type=float,
-        default=0.2,
-        help="Validation ratio.",
-    )
-    parser.add_argument(
-        "--test_ratio",
-        type=float,
-        default=0.2,
-        help="Test ratio.",
-    )
-    parser.add_argument(
-        "--seed",
-        type=int,
-        default=42,
-        help="Random seed used for deterministic split assignment.",
-    )
-    parser.add_argument(
-        "--link_mode",
-        choices=["symlink", "hardlink", "copy"],
-        default="symlink",
-        help="How to materialize split files.",
-    )
-    parser.add_argument(
-        "--overwrite",
-        action="store_true",
-        help="Delete an existing output_dir before writing the split.",
-    )
-    return parser.parse_args()
-
-
-def parse_tile_name(path: Path) -> tuple[int, int, int, int, int]:
-    patch_match = PATCH_RE.match(path.name)
-    if patch_match is not None:
-        year = int(patch_match.group("year"))
-        x = int(patch_match.group("x"))
-        y = int(patch_match.group("y"))
-        y_offset = int(patch_match.group("yoff"))
-        x_offset = int(patch_match.group("xoff"))
-        return year, x, y, x_offset, y_offset
-
-    full_match = FULL_TILE_RE.match(path.name)
-    if full_match is not None:
-        year = int(full_match.group("year"))
-        x = int(full_match.group("x"))
-        y = int(full_match.group("y"))
-        return year, x, y, 0, 0
-
-    raise ValueError(f"Unexpected SwissImage filename format: {path.name}")
-
-
-def collect_records(image_dir: Path, mask_dir: Path) -> list[TileRecord]:
-    image_files = {p.name: p for p in sorted(image_dir.glob("*.tif"))}
-    mask_files = {p.name: p for p in sorted(mask_dir.glob("*.tif"))}
-    common_names = sorted(image_files.keys() & mask_files.keys())
-
-    if not common_names:
-        raise RuntimeError("No matching image/mask filenames found.")
-
-    records = []
-    for name in common_names:
-        year, x, y, x_offset, y_offset = parse_tile_name(Path(name))
-        records.append(
-            TileRecord(
-                name=name,
-                year=year,
-                x=x,
-                y=y,
-                x_offset=x_offset,
-                y_offset=y_offset,
-                x_geo=x * 10000 + x_offset,
-                y_geo=y * 10000 + y_offset,
-                image_path=image_files[name],
-                mask_path=mask_files[name],
-            )
-        )
-    return records
-
-
-def split_random_by_source_tile(
-    records: list[TileRecord],
-    train_ratio: float,
-    val_ratio: float,
-    test_ratio: float,
-    seed: int,
-) -> tuple[list[TileRecord], list[TileRecord], list[TileRecord]]:
-    tile_to_records: dict[tuple[int, int, int], list[TileRecord]] = {}
-    for record in records:
-        tile_to_records.setdefault((record.year, record.x, record.y), []).append(record)
-
-    groups = list(tile_to_records.items())
-    rng = random.Random(seed)
-    rng.shuffle(groups)
-
-    total = len(groups)
-    n_train = round(total * train_ratio)
-    n_val = round(total * val_ratio)
-    n_test = total - n_train - n_val
-
-    if min(n_train, n_val, n_test) <= 0:
-        raise RuntimeError("Random split produced an empty split. Adjust ratios or input size.")
-
-    train_groups = groups[:n_train]
-    val_groups = groups[n_train:n_train + n_val]
-    test_groups = groups[n_train + n_val:]
-
-    train_records = [record for _, tile_records in train_groups for record in tile_records]
-    val_records = [record for _, tile_records in val_groups for record in tile_records]
-    test_records = [record for _, tile_records in test_groups for record in tile_records]
-
-    return train_records, val_records, test_records
-
-
-def ensure_empty_dir(path: Path, overwrite: bool) -> None:
-    if path.exists():
-        if not overwrite:
-            raise FileExistsError(f"{path} already exists. Use --overwrite to recreate it.")
-        shutil.rmtree(path)
-    path.mkdir(parents=True, exist_ok=True)
-
-
-def materialize(src: Path, dst: Path, mode: str) -> None:
-    if mode == "symlink":
-        os.symlink(src, dst)
-        return
-    if mode == "hardlink":
-        os.link(src, dst)
-        return
-    shutil.copy2(src, dst)
-
-
-def write_split(
-    split_name: str,
-    records: Iterable[TileRecord],
-    output_dir: Path,
-    link_mode: str,
-) -> None:
-    img_dir = output_dir / split_name / "img"
-    msk_dir = output_dir / split_name / "msk"
-    img_dir.mkdir(parents=True, exist_ok=True)
-    msk_dir.mkdir(parents=True, exist_ok=True)
-
-    for record in records:
-        materialize(record.image_path, img_dir / record.name, link_mode)
-        materialize(record.mask_path, msk_dir / record.name, link_mode)
-
-
-def write_manifest(
-    output_dir: Path,
-    mode: str,
-    train_records: list[TileRecord],
-    val_records: list[TileRecord],
-    test_records: list[TileRecord],
-) -> None:
-    manifest_path = output_dir / "split_manifest.csv"
-    with manifest_path.open("w", newline="") as f:
-        writer = csv.writer(f)
-        writer.writerow(["split", "name", "year", "x", "y", "x_offset", "y_offset", "x_geo", "y_geo", "image_path", "mask_path"])
-        for split_name, records in (
-            ("train", train_records),
-            ("val", val_records),
-            ("test", test_records),
-        ):
-            for record in records:
-                writer.writerow(
-                    [
-                        split_name,
-                        record.name,
-                        record.year,
-                        record.x,
-                        record.y,
-                        record.x_offset,
-                        record.y_offset,
-                        record.x_geo,
-                        record.y_geo,
-                        str(record.image_path),
-                        str(record.mask_path),
-                    ]
-                )
-
-    summary_path = output_dir / "split_summary.txt"
-    with summary_path.open("w") as f:
-        f.write(f"mode={mode}\n")
-        f.write(f"train={len(train_records)}\n")
-        f.write(f"val={len(val_records)}\n")
-        f.write(f"test={len(test_records)}\n")
-        f.write(
-            f"train_coords=({min(r.x_geo for r in train_records)}, {max(r.x_geo for r in train_records)}) x "
-            f"({min(r.y_geo for r in train_records)}, {max(r.y_geo for r in train_records)})\n"
-        )
-        f.write(
-            f"val_coords=({min(r.x_geo for r in val_records)}, {max(r.x_geo for r in val_records)}) x "
-            f"({min(r.y_geo for r in val_records)}, {max(r.y_geo for r in val_records)})\n"
-        )
-        f.write(
-            f"test_coords=({min(r.x_geo for r in test_records)}, {max(r.x_geo for r in test_records)}) x "
-            f"({min(r.y_geo for r in test_records)}, {max(r.y_geo for r in test_records)})\n"
-        )
-
-
-def main() -> None:
-    args = parse_args()
-
-    ratio_sum = args.train_ratio + args.val_ratio + args.test_ratio
-    if abs(ratio_sum - 1.0) > 1e-8:
-        raise ValueError(f"Ratios must sum to 1.0, got {ratio_sum:.6f}")
-
-    if not args.image_dir.exists():
-        raise FileNotFoundError(f"Missing image_dir: {args.image_dir}")
-    if not args.mask_dir.exists():
-        raise FileNotFoundError(f"Missing mask_dir: {args.mask_dir}")
-
-    records = collect_records(args.image_dir, args.mask_dir)
-    train_records, val_records, test_records = split_random_by_source_tile(
-        records=records,
-        train_ratio=args.train_ratio,
-        val_ratio=args.val_ratio,
-        test_ratio=args.test_ratio,
-        seed=args.seed,
-    )
-
-    ensure_empty_dir(args.output_dir, args.overwrite)
-    write_split("train", train_records, args.output_dir, args.link_mode)
-    write_split("val", val_records, args.output_dir, args.link_mode)
-    write_split("test", test_records, args.output_dir, args.link_mode)
-    write_manifest(args.output_dir, "random_by_source_tile", train_records, val_records, test_records)
-
-    total = len(records)
-    print(f"Matched tiles: {total}")
-    print(f"Split mode: random_by_source_tile")
-    print(f"Seed: {args.seed}")
-    print(f"Train: {len(train_records)} ({100.0 * len(train_records) / total:.2f}%)")
-    print(f"Val:   {len(val_records)} ({100.0 * len(val_records) / total:.2f}%)")
-    print(f"Test:  {len(test_records)} ({100.0 * len(test_records) / total:.2f}%)")
-    print(f"Output: {args.output_dir}")
-
-
-if __name__ == "__main__":
-    main()

dataset/stats_swisstlm3d_masks.py

@@ -1,136 +0,0 @@
-"""
-Compute mask statistics for SwissTLM3D-generated masks with a progress bar.
-
-Outputs:
-- global class histogram
-- class proportions
-- count of masks entirely equal to 255
-- count of masks containing at least one non-255 pixel
-- CSV list of fully-255 masks
-- text summary
-"""
-
-from __future__ import annotations
-
-import argparse
-import csv
-from collections import Counter
-from pathlib import Path
-
-import numpy as np
-import rasterio
-from tqdm import tqdm
-
-
-CLASS_NAMES = {
-    0: "building",
-    1: "greenhouse",
-    2: "swimming_pool",
-    3: "impervious_surface",
-    4: "pervious_surface",
-    5: "bare_soil",
-    6: "water",
-    7: "snow",
-    8: "herbaceous_vegetation",
-    9: "agricultural_land",
-    10: "plowed_land",
-    11: "vineyard",
-    12: "deciduous",
-    13: "coniferous",
-    14: "brushwood",
-    255: "ignore",
-}
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Compute class statistics for SwissTLM3D masks.")
-    parser.add_argument(
-        "--mask_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/mask_tlm3d"),
-        help="Directory containing rasterized SwissTLM3D masks.",
-    )
-    parser.add_argument(
-        "--out_dir",
-        type=Path,
-        default=Path("/mnt/CalcShare/datasets/Suisse_full/data/mask_tlm3d_stats"),
-        help="Directory where summary files will be written.",
-    )
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    args.out_dir.mkdir(parents=True, exist_ok=True)
-
-    mask_paths = sorted(args.mask_dir.glob("*.tif"))#[:100]
-    if not mask_paths:
-        raise RuntimeError(f"No .tif masks found in {args.mask_dir}")
-
-    pixel_counts: Counter[int] = Counter()
-    all_255_masks: list[str] = []
-    non_255_masks = 0
-    partial_255_masks = 0
-
-    for mask_path in tqdm(mask_paths, desc="Scanning masks", unit="mask"):
-        with rasterio.open(mask_path) as src:
-            arr = src.read(1)
-
-        values, counts = np.unique(arr, return_counts=True)
-        local = dict(zip(values.tolist(), counts.tolist()))
-        pixel_counts.update(local)
-
-        if set(local.keys()) == {255}:
-            all_255_masks.append(mask_path.name)
-        else:
-            non_255_masks += 1
-            if 255 in local:
-                partial_255_masks += 1
-
-    total_pixels = sum(pixel_counts.values())
-
-    summary_txt = args.out_dir / "summary.txt"
-    class_csv = args.out_dir / "class_stats.csv"
-    all_255_csv = args.out_dir / "all_255_masks.csv"
-
-    with summary_txt.open("w") as f:
-        f.write(f"mask_count={len(mask_paths)}\n")
-        f.write(f"all_255_count={len(all_255_masks)}\n")
-        f.write(f"non_255_count={non_255_masks}\n")
-        f.write(f"partial_255_count={partial_255_masks}\n")
-        f.write(f"total_pixels={total_pixels}\n")
-
-    with class_csv.open("w", newline="") as f:
-        writer = csv.writer(f)
-        writer.writerow(["value", "class_name", "pixel_count", "proportion"])
-        for value in sorted(pixel_counts):
-            writer.writerow(
-                [
-                    value,
-                    CLASS_NAMES.get(value, "unknown"),
-                    pixel_counts[value],
-                    pixel_counts[value] / total_pixels if total_pixels > 0 else 0.0,
-                ]
-            )
-
-    with all_255_csv.open("w", newline="") as f:
-        writer = csv.writer(f)
-        writer.writerow(["filename"])
-        for name in all_255_masks:
-            writer.writerow([name])
-
-    print(f"mask_count: {len(mask_paths)}")
-    print(f"all_255_count: {len(all_255_masks)}")
-    print(f"non_255_count: {non_255_masks}")
-    print(f"partial_255_count: {partial_255_masks}")
-    print("class_stats:")
-    for value in sorted(pixel_counts):
-        proportion = pixel_counts[value] / total_pixels if total_pixels > 0 else 0.0
-        print(f"  {value:>3} {CLASS_NAMES.get(value, 'unknown'):<24} {pixel_counts[value]} ({proportion:.8f})")
-    print(f"wrote: {summary_txt}")
-    print(f"wrote: {class_csv}")
-    print(f"wrote: {all_255_csv}")
-
-
-if __name__ == "__main__":
-    main()

dataset/swissimage_grayscale_mixed.py

@@ -1,24 +0,0 @@
-from pathlib import Path
-from typing import Dict, Optional
-
-from torchvision import transforms
-
-from dataset.definition_dataset_grayscale_mixed import (
-    SemanticSegmentationDatasetFusionGrayscaleMixed,
-)
-
-
-def build(
-    image_dir: Path,
-    mask_dir: Path,
-    transform: Optional[transforms.Compose],
-    augment=None,
-    label_remap: Optional[Dict[int, int]] = None,
-):
-    return SemanticSegmentationDatasetFusionGrayscaleMixed(
-        image_dir,
-        mask_dir,
-        transform=transform,
-        augment=augment,
-        label_remap=label_remap,
-    )