source

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.DS_Store

app.py

@@ -0,0 +1,773 @@
+#!/usr/bin/env python3
+"""
+Forest Metrics Inference Demo - Interactive Patch-based Version
+Click anywhere on the input tile to run inference on a 45m×45m patch
+"""
+import numpy as np
+import torch
+import torch.nn.functional as F
+import rasterio
+import gradio as gr
+from transformers import SegformerModel
+from torch import nn
+from PIL import Image, ImageDraw
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import os
+import tempfile
+import zipfile
+import gc
+from scipy.ndimage import zoom
+
+# ============================================================
+# CONFIG
+# ============================================================
+PATCH_SIZE = 224
+DROP_BORDER = 16
+STRIDE = 112
+OUT_CHANNELS = 3
+
+# Patch inference settings
+PATCH_SIZE_METERS = 380  # 380m × 380m patch
+GSD = 0.2  # Ground Sample Distance in meters/pixel
+PATCH_SIZE_PIXELS = int(PATCH_SIZE_METERS / GSD)  # 1900 pixels
+
+# File paths
+FIXED_INPUT_TIF = "data/dop20rgbi_33348_5612_2_sn.tif"
+FIXED_GT_CHM = "data/lsc_33348_5612_2_sn_chm.tif"
+FIXED_GT_PAI = "data/lsc_33348_5612_2_sn_pai.tif"
+FIXED_GT_FHD = "data/lsc_33348_5612_2_sn_fhd.tif"
+MODEL_PATH = "data/student_MiTB2.pt"
+VIDEO_PATH = "data/overview.mp4"
+
+# ============================================================
+# DEVICE
+# ============================================================
+if torch.backends.mps.is_available():
+    DEVICE = "mps"
+elif torch.cuda.is_available():
+    DEVICE = "cuda"
+else:
+    DEVICE = "cpu"
+
+print(f"[INFO] Using device: {DEVICE}")
+
+
+# ============================================================
+# UTILITY FUNCTIONS
+# ============================================================
+def make_weight_mask(out_size):
+    """Pyramidal weight mask for smooth blending."""
+    y = np.linspace(-1, 1, out_size)
+    x = np.linspace(-1, 1, out_size)
+    yy, xx = np.meshgrid(y, x)
+    w = (1 - np.abs(xx)) * (1 - np.abs(yy))
+    return w
+
+
+def create_colormap_image(array, cmap_name="viridis", vmin=None, vmax=None):
+    """Convert array to RGB image with colormap."""
+    if vmin is None:
+        vmin = np.nanmin(array)
+    if vmax is None:
+        vmax = np.nanmax(array)
+
+    norm = mcolors.Normalize(vmin=vmin, vmax=vmax)
+    cmap = plt.get_cmap(cmap_name)
+    rgba = cmap(norm(array))
+    rgb = (rgba[:, :, :3] * 255).astype(np.uint8)
+
+    return Image.fromarray(rgb)
+
+
+def create_comparison_plot(pred, gt, title, cmap="viridis"):
+    """Create a scatter plot comparing predictions vs ground truth."""
+    # Flatten arrays and remove NaN values
+    pred_flat = pred.flatten()
+    gt_flat = gt.flatten()
+
+    # Create mask for valid values
+    valid_mask = ~(np.isnan(pred_flat) | np.isnan(gt_flat))
+    pred_valid = pred_flat[valid_mask]
+    gt_valid = gt_flat[valid_mask]
+
+    if len(pred_valid) == 0:
+        # Return empty plot if no valid data
+        fig, ax = plt.subplots(figsize=(6, 6))
+        ax.text(0.5, 0.5, "No valid data", ha="center", va="center")
+        ax.set_title(title)
+        plt.close(fig)  # Close to prevent memory leak
+        return fig
+
+    # Create figure
+    fig, ax = plt.subplots(figsize=(6, 6))
+
+    # Scatter plot
+    ax.scatter(gt_valid, pred_valid, alpha=0.3, s=1, c="#047857")
+
+    # 1:1 line
+    min_val = min(np.min(gt_valid), np.min(pred_valid))
+    max_val = max(np.max(gt_valid), np.max(pred_valid))
+    ax.plot(
+        [min_val, max_val], [min_val, max_val], "r--", linewidth=2, label="1:1 line"
+    )
+
+    # Calculate metrics
+    mae = np.mean(np.abs(pred_valid - gt_valid))
+    rmse = np.sqrt(np.mean((pred_valid - gt_valid) ** 2))
+    r2 = np.corrcoef(pred_valid, gt_valid)[0, 1] ** 2
+
+    # Add metrics text
+    metrics_text = f"MAE: {mae:.3f}\nRMSE: {rmse:.3f}\nR²: {r2:.3f}"
+    ax.text(
+        0.05,
+        0.95,
+        metrics_text,
+        transform=ax.transAxes,
+        verticalalignment="top",
+        bbox=dict(boxstyle="round", facecolor="white", alpha=0.8),
+    )
+
+    ax.set_xlabel("Ground Truth", fontsize=12)
+    ax.set_ylabel("Prediction", fontsize=12)
+    ax.set_title(title, fontsize=14, fontweight="bold")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    return fig
+
+
+# ============================================================
+# MODEL DEFINITION
+# ============================================================
+class SegFormerStudent(nn.Module):
+    def __init__(self, out_ch=OUT_CHANNELS):
+        super().__init__()
+
+        self.backbone = SegformerModel.from_pretrained(
+            "nvidia/mit-b2", use_safetensors=True, trust_remote_code=True
+        )
+        self.backbone.config.output_hidden_states = True
+
+        old_conv = self.backbone.encoder.patch_embeddings[0].proj
+        new_conv = nn.Conv2d(
+            4,
+            old_conv.out_channels,
+            kernel_size=old_conv.kernel_size,
+            stride=old_conv.stride,
+            padding=old_conv.padding,
+            bias=old_conv.bias is not None,
+        )
+        with torch.no_grad():
+            new_conv.weight[:, :3, :, :] = old_conv.weight.clone()
+            new_conv.weight[:, 3:, :, :] = 0.0
+            if old_conv.bias is not None:
+                new_conv.bias.copy_(old_conv.bias)
+        self.backbone.encoder.patch_embeddings[0].proj = new_conv
+
+        self.dims = self.backbone.config.hidden_sizes
+        self.proj0 = nn.Conv2d(self.dims[0], 128, 1)
+        self.proj1 = nn.Conv2d(self.dims[1], 128, 1)
+        self.proj2 = nn.Conv2d(self.dims[2], 128, 1)
+        self.proj3 = nn.Conv2d(self.dims[3], 128, 1)
+        self.adapter = nn.Conv2d(128, 256, 1)
+
+        self.pred_head = nn.Sequential(
+            nn.Conv2d(128, 64, 3, padding=1), nn.GELU(), nn.Conv2d(64, out_ch, 1)
+        )
+
+    def forward(self, x):
+        outputs = self.backbone(pixel_values=x, output_hidden_states=True)
+        hs = outputs.hidden_states[-4:]
+
+        if len(hs[0].shape) == 3:
+            B, N, C = hs[0].shape
+            H = W = int(N**0.5)
+            f0, f1, f2, f3 = [h.permute(0, 2, 1).reshape(B, -1, H, W) for h in hs]
+        else:
+            f0, f1, f2, f3 = hs
+
+        fused = (
+            self.proj0(f0)
+            + F.interpolate(self.proj1(f1), size=f0.shape[-2:], mode="bilinear")
+            + F.interpolate(self.proj2(f2), size=f0.shape[-2:], mode="bilinear")
+            + F.interpolate(self.proj3(f3), size=f0.shape[-2:], mode="bilinear")
+        )
+
+        return self.pred_head(fused)
+
+
+# ============================================================
+# LOAD MODEL AND DATA AT STARTUP
+# ============================================================
+print("[INFO] Loading model...")
+try:
+    model = SegFormerStudent().to(DEVICE)
+    state = torch.load(MODEL_PATH, map_location=DEVICE, weights_only=False)
+    model.load_state_dict(state)
+    model.eval()
+    print("✓ Model loaded successfully!")
+except Exception as e:
+    print(f"✗ Error loading model: {e}")
+    model = None
+
+# Load input tile
+print("[INFO] Loading input tile...")
+try:
+    with rasterio.open(FIXED_INPUT_TIF) as src:
+        input_data_full = src.read().astype("float32")  # C, H, W
+        input_profile = src.profile
+        input_bounds = src.bounds
+        input_transform = src.transform
+
+    # Create RGB preview for display
+    rgb_data = input_data_full[:3].copy()
+    rgb_data = np.transpose(rgb_data, (1, 2, 0))  # H, W, C
+    rgb_data = (rgb_data / rgb_data.max() * 255).astype(np.uint8)
+    input_preview = Image.fromarray(rgb_data)
+
+    print(f"✓ Input tile loaded: {input_data_full.shape}")
+    INPUT_LOADED = True
+except Exception as e:
+    print(f"✗ Error loading input: {e}")
+    input_preview = None
+    INPUT_LOADED = False
+
+# Load ground truth
+print("[INFO] Loading ground truth data...")
+try:
+    with rasterio.open(FIXED_GT_CHM) as src:
+        gt_chm_full = src.read(1).astype("float32")
+        gt_profile = src.profile
+        nodata_chm = src.nodata
+        if nodata_chm is not None:
+            gt_chm_full[gt_chm_full == nodata_chm] = np.nan
+
+    with rasterio.open(FIXED_GT_PAI) as src:
+        gt_pai_full = src.read(1).astype("float32")
+        nodata_pai = src.nodata
+        if nodata_pai is not None:
+            gt_pai_full[gt_pai_full == nodata_pai] = np.nan
+
+    with rasterio.open(FIXED_GT_FHD) as src:
+        gt_fhd_full = src.read(1).astype("float32")
+        nodata_fhd = src.nodata
+        if nodata_fhd is not None:
+            gt_fhd_full[gt_fhd_full == nodata_fhd] = np.nan
+        gt_fhd_full[gt_fhd_full < -9000] = np.nan
+
+    print(f"✓ Ground truth loaded")
+    print(f"  CHM range: [{np.nanmin(gt_chm_full):.2f}, {np.nanmax(gt_chm_full):.2f}]")
+    print(f"  PAI range: [{np.nanmin(gt_pai_full):.2f}, {np.nanmax(gt_pai_full):.2f}]")
+    print(f"  FHD range: [{np.nanmin(gt_fhd_full):.2f}, {np.nanmax(gt_fhd_full):.2f}]")
+    GT_LOADED = True
+except Exception as e:
+    print(f"✗ Error loading ground truth: {e}")
+    GT_LOADED = False
+
+
+# ============================================================
+# PATCH EXTRACTION AND INFERENCE
+# ============================================================
+def extract_patch(array, center_y, center_x, patch_size):
+    """Extract a patch centered at (center_y, center_x)."""
+    H, W = array.shape[-2:]
+
+    # Calculate patch boundaries
+    half_patch = patch_size // 2
+    y_start = max(0, center_y - half_patch)
+    y_end = min(H, center_y + half_patch)
+    x_start = max(0, center_x - half_patch)
+    x_end = min(W, center_x + half_patch)
+
+    # Extract patch
+    if array.ndim == 3:  # C, H, W
+        patch = array[:, y_start:y_end, x_start:x_end]
+    else:  # H, W
+        patch = array[y_start:y_end, x_start:x_end]
+
+    return patch, (y_start, y_end, x_start, x_end)
+
+
+def run_patch_inference(evt: gr.SelectData, progress=gr.Progress()):
+    """Run inference on a patch centered at clicked location."""
+
+    if not INPUT_LOADED or not GT_LOADED or model is None:
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            "❌ Model or data not loaded",
+        )
+
+    # Clear any previous GPU memory
+    if DEVICE == "cuda":
+        torch.cuda.empty_cache()
+    elif DEVICE == "mps":
+        torch.mps.empty_cache()
+
+    progress(0, desc="Extracting patch...")
+
+    try:
+        # Get click coordinates from the event
+        # evt.index is [x, y] for images in Gradio
+        click_x, click_y = evt.index
+
+        print(f"[INFO] Click at display ({click_x}, {click_y})")
+
+        # Get display and original image dimensions
+        display_w, display_h = input_preview.size
+        original_h, original_w = input_data_full.shape[1], input_data_full.shape[2]
+
+        # Calculate scaling factors
+        scale_x = original_w / display_w
+        scale_y = original_h / display_h
+
+        # Convert to original coordinates
+        center_x = int(click_x * scale_x)
+        center_y = int(click_y * scale_y)
+
+        print(f"[INFO] Mapped to original ({center_x}, {center_y})")
+
+        progress(0.1, desc="Extracting input patch...")
+
+        # Extract input patch (RGBI) - from original high-res input
+        input_patch, (y_start, y_end, x_start, x_end) = extract_patch(
+            input_data_full, center_y, center_x, PATCH_SIZE_PIXELS
+        )
+
+        # Normalize
+        input_patch = input_patch / max(input_patch.max(), 1e-6)
+
+        # Ensure 4 channels
+        C, H, W = input_patch.shape
+        if C == 3:
+            input_patch = np.vstack(
+                [input_patch, np.zeros((1, H, W), dtype=np.float32)]
+            )
+
+        # Create RGB preview of patch
+        rgb_patch = input_patch[:3].copy()
+        rgb_patch = np.transpose(rgb_patch, (1, 2, 0))
+        rgb_patch = (rgb_patch * 255).astype(np.uint8)
+        rgb_patch_img = Image.fromarray(rgb_patch)
+
+        progress(0.2, desc="Preparing display...")
+
+        # Add boundary box to full image
+        full_img_with_box = input_preview.copy()
+        draw = ImageDraw.Draw(full_img_with_box)
+
+        # Scale box coordinates to display size
+        box_x_start = int(x_start / scale_x)
+        box_x_end = int(x_end / scale_x)
+        box_y_start = int(y_start / scale_y)
+        box_y_end = int(y_end / scale_y)
+
+        draw.rectangle(
+            [box_x_start, box_y_start, box_x_end, box_y_end], outline="red", width=8
+        )
+
+        progress(0.3, desc="Running model inference...")
+
+        # Run inference on patch
+        patch_tensor = torch.from_numpy(input_patch).unsqueeze(0).to(DEVICE)
+
+        with torch.inference_mode():  # More efficient than no_grad()
+            pred = model(patch_tensor)[0]  # C, H_out, W_out
+
+        # Clear GPU memory after inference
+        del patch_tensor
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        elif DEVICE == "mps":
+            torch.mps.empty_cache()
+
+        progress(0.5, desc="Processing predictions...")
+
+        # Upsample to original patch size
+        pred = (
+            F.interpolate(
+                pred.unsqueeze(0), size=(H, W), mode="bilinear", align_corners=False
+            )[0]
+            .cpu()
+            .numpy()
+        )
+
+        # Extract predictions
+        pred_chm = pred[0]
+        pred_pai = pred[1]
+        pred_fhd = pred[2]
+
+        progress(0.6, desc="Extracting ground truth...")
+
+        # Calculate corresponding GT coordinates
+        # GT has different resolution than input, so we need to scale coordinates
+        gt_h, gt_w = gt_chm_full.shape
+
+        # Scale center coordinates to GT resolution
+        gt_scale_y = gt_h / original_h
+        gt_scale_x = gt_w / original_w
+
+        gt_center_y = int(center_y * gt_scale_y)
+        gt_center_x = int(center_x * gt_scale_x)
+
+        # Scale patch size to GT resolution
+        gt_patch_size = int(PATCH_SIZE_PIXELS * gt_scale_y)  # Assuming square pixels
+
+        # Extract ground truth patches at correct resolution
+        gt_chm_patch, _ = extract_patch(
+            gt_chm_full, gt_center_y, gt_center_x, gt_patch_size
+        )
+        gt_pai_patch, _ = extract_patch(
+            gt_pai_full, gt_center_y, gt_center_x, gt_patch_size
+        )
+        gt_fhd_patch, _ = extract_patch(
+            gt_fhd_full, gt_center_y, gt_center_x, gt_patch_size
+        )
+
+        progress(0.7, desc="Resampling predictions to match ground truth...")
+
+        # Resize predictions to match GT resolution
+        if pred_chm.shape != gt_chm_patch.shape:
+            zoom_factors = (
+                gt_chm_patch.shape[0] / pred_chm.shape[0],
+                gt_chm_patch.shape[1] / pred_chm.shape[1],
+            )
+            pred_chm = zoom(pred_chm, zoom_factors, order=1)
+            pred_pai = zoom(pred_pai, zoom_factors, order=1)
+            pred_fhd = zoom(pred_fhd, zoom_factors, order=1)
+            print(
+                f"[INFO] Resampled predictions from {pred.shape} to {gt_chm_patch.shape}"
+            )
+
+        progress(0.8, desc="Creating visualizations...")
+
+        # Create visualization images (patches are now large enough, no upscaling needed)
+        chm_pred_img = create_colormap_image(
+            pred_chm, "viridis", np.nanmin(gt_chm_full), np.nanmax(gt_chm_full)
+        )
+        pai_pred_img = create_colormap_image(
+            pred_pai, "Greens", np.nanmin(gt_pai_full), np.nanmax(gt_pai_full)
+        )
+        fhd_pred_img = create_colormap_image(
+            pred_fhd, "magma", np.nanmin(gt_fhd_full), np.nanmax(gt_fhd_full)
+        )
+
+        chm_gt_img = create_colormap_image(
+            gt_chm_patch, "viridis", np.nanmin(gt_chm_full), np.nanmax(gt_chm_full)
+        )
+        pai_gt_img = create_colormap_image(
+            gt_pai_patch, "Greens", np.nanmin(gt_pai_full), np.nanmax(gt_pai_full)
+        )
+        fhd_gt_img = create_colormap_image(
+            gt_fhd_patch, "magma", np.nanmin(gt_fhd_full), np.nanmax(gt_fhd_full)
+        )
+
+        progress(0.9, desc="Generating comparison plots...")
+
+        # Create comparison plots
+        chm_plot = create_comparison_plot(
+            pred_chm, gt_chm_patch, "CHM Comparison", "viridis"
+        )
+        pai_plot = create_comparison_plot(
+            pred_pai, gt_pai_patch, "PAI Comparison", "Greens"
+        )
+        fhd_plot = create_comparison_plot(
+            pred_fhd, gt_fhd_patch, "FHD Comparison", "magma"
+        )
+
+        # Free intermediate arrays to reduce memory footprint
+        del pred_chm, pred_pai, pred_fhd
+        del gt_chm_patch, gt_pai_patch, gt_fhd_patch
+
+        # Calculate metrics
+        chm_mae = np.nanmean(np.abs(pred_chm - gt_chm_patch))
+        chm_rmse = np.sqrt(np.nanmean((pred_chm - gt_chm_patch) ** 2))
+        pai_mae = np.nanmean(np.abs(pred_pai - gt_pai_patch))
+        pai_rmse = np.sqrt(np.nanmean((pred_pai - gt_pai_patch) ** 2))
+        fhd_mae = np.nanmean(np.abs(pred_fhd - gt_fhd_patch))
+        fhd_rmse = np.sqrt(np.nanmean((pred_fhd - gt_fhd_patch) ** 2))
+
+        status = f"""
+✓ **Inference completed on 45m×45m patch**
+
+**Location:** ({center_x}, {center_y}) in input coordinates
+**Patch Metrics:**
+- CHM: MAE = {chm_mae:.4f} m, RMSE = {chm_rmse:.4f} m
+- PAI: MAE = {pai_mae:.4f}, RMSE = {pai_rmse:.4f}
+- FHD: MAE = {fhd_mae:.4f}, RMSE = {fhd_rmse:.4f}
+- Input patch: {H}×{W} pixels ({PATCH_SIZE_METERS}m×{PATCH_SIZE_METERS}m)
+- GT patch: {gt_chm_patch.shape[0]}×{gt_chm_patch.shape[1]} pixels
+"""
+
+        progress(1.0, desc="Complete!")
+
+        # Close all matplotlib figures to prevent memory leaks
+        plt.close('all')
+        
+        # Force garbage collection
+        gc.collect()
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        elif DEVICE == "mps":
+            torch.mps.empty_cache()
+
+        return (
+            full_img_with_box,
+            rgb_patch_img,
+            chm_pred_img,
+            pai_pred_img,
+            fhd_pred_img,
+            chm_gt_img,
+            pai_gt_img,
+            fhd_gt_img,
+            chm_plot,
+            pai_plot,
+            fhd_plot,
+            status,
+        )
+
+    except Exception as e:
+        import traceback
+
+        # Cleanup on error
+        plt.close('all')
+        gc.collect()
+        if DEVICE == "cuda":
+            torch.cuda.empty_cache()
+        elif DEVICE == "mps":
+            torch.mps.empty_cache()
+
+        error_msg = f"❌ Error during inference:\n```\n{traceback.format_exc()}\n```"
+        return (
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            error_msg,
+        )
+
+
+# ============================================================
+# GRADIO INTERFACE
+# ============================================================
+def create_demo():
+
+    with gr.Blocks(title="FSKD Inference Demo") as demo:
+        # <sup>1</sup>, Co-Author Name<sup>1,2</sup>, Another Author<sup>1</sup>
+        gr.HTML(
+            """
+        <div style="text-align: center; padding: 2.5rem 2rem; background: linear-gradient(135deg, #065f46 0%, #047857 100%); border-radius: 1rem; margin-bottom: 1.5rem; color: white;">
+            <h1 style="font-size: 2.5rem; font-weight: 700; margin-bottom: 0.5rem; color: white;">Monocular Forest Structure Inference via LiDAR-to-RGBI Knowledge Distillation</h1>
+            <h2 style="font-size: 1.2rem; font-weight: 400; margin: 1rem 0 0.5rem 0; color: white; opacity: 0.95;">
+                Taimur Khan<sup style="color: red;">1,2</sup>
+            </h2>
+            <p style="font-size: 0.85rem; margin: 0.25rem 0 0.75rem 0; color: white; opacity: 0.8;">
+                <sup style="color: red;">1</sup>Leipzig University, <br/>
+                <sup style="color: red;">2</sup>Helmholtz Centre for Environmental Research -- UFZ
+            </p>
+            <div style="display: flex; justify-content: center; gap: 1rem; margin-top: 1.5rem; flex-wrap: wrap;">
+                <button disabled style="padding: 0.75rem 1.5rem; background: linear-gradient(135deg, #24292e 0%, #1a1e22 100%); color: white; border: none; border-radius: 0.5rem; font-weight: 600; cursor: not-allowed; opacity: 0.7; font-size: 0.95rem;">
+                    💻 Code (Coming Soon)
+                </button>
+                <button disabled style="padding: 0.75rem 1.5rem; background: linear-gradient(135deg, #FF9D00 0%, #FF7A00 100%); color: white; border: none; border-radius: 0.5rem; font-weight: 600; cursor: not-allowed; opacity: 0.7; font-size: 0.95rem;">
+                    🤗 Model (Coming Soon)
+                </button>
+                <button disabled style="padding: 0.75rem 1.5rem; background: linear-gradient(135deg, #FF9D00 0%, #FF7A00 100%); color: white; border: none; border-radius: 0.5rem; font-weight: 600; cursor: not-allowed; opacity: 0.7; font-size: 0.95rem;">
+                    🤗 Dataset (Coming Soon)
+                </button>
+                <button disabled style="padding: 0.75rem 1.5rem; background: linear-gradient(135deg, #B31B1B 0%, #8B0000 100%); color: white; border: none; border-radius: 0.5rem; font-weight: 600; cursor: not-allowed; opacity: 0.7; font-size: 0.95rem;">
+                    📄 Paper (Coming Soon)
+                </button>
+            </div>
+            <p style="font-size: 1.1rem; opacity: 0.95; color: white;">Interactive Patch-based Deep Learning Demo for Forest Structure Inference <br/> (CHM, PAI, and FHD) from RGBI Aerial Image with SegFormer-B2</p>
+            
+        </div>
+        """
+        )
+
+        # Video overview
+        if os.path.exists(VIDEO_PATH):
+            gr.Video(
+                value=VIDEO_PATH,
+                label="📹 Simplified Paper Overview (NotebookLM Generated)",
+                autoplay=False,
+                show_label=True,
+            )
+
+        gr.Markdown("---")
+
+        # Main interaction area
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown(
+                    "### 👇🏼 Click anywhere on the input tile to get inferred forest metrics"
+                )
+                input_tile_display = gr.Image(
+                    value=input_preview if INPUT_LOADED else None,
+                    label="Input RGBI Tile (RGB preview)",
+                    type="pil",
+                    interactive=False,
+                )
+
+                status_display = gr.Markdown(
+                    value="Awaiting user input...",
+                )
+
+                gr.Markdown(
+                    """
+                ### 📖 About
+                This demo allows interactive inference of forest structure metrics from aerial RGBI imagery using a deep learning model trained via knowledge distillation from LiDAR data.
+                
+                **Model**: SegFormer (MiT-B2) trained with knowledge distillation
+                
+                **Patch Size**: 380m×380m ≈ 1900×1900 pixels at 0.2m GSD
+                
+                **Test Tile ID**: 3348_5612_2
+                """
+                )
+
+            with gr.Column(scale=1):
+                gr.Markdown("### 🔍 Selected Patch")
+                patch_preview = gr.Image(
+                    label="RGB Patch Preview", type="pil", interactive=False
+                )
+
+        gr.Markdown("---")
+        gr.Markdown("## 📊 Row 1: Predictions")
+
+        with gr.Row():
+            chm_pred_display = gr.Image(
+                label="CHM - Prediction", type="pil", interactive=False, height=600
+            )
+            pai_pred_display = gr.Image(
+                label="PAI - Prediction", type="pil", interactive=False, height=600
+            )
+            fhd_pred_display = gr.Image(
+                label="FHD - Prediction", type="pil", interactive=False, height=600
+            )
+
+        gr.Markdown("## 🎯 Row 2: Ground Truth")
+
+        with gr.Row():
+            chm_gt_display = gr.Image(
+                label="CHM - Ground Truth", type="pil", interactive=False, height=600
+            )
+            pai_gt_display = gr.Image(
+                label="PAI - Ground Truth", type="pil", interactive=False, height=600
+            )
+            fhd_gt_display = gr.Image(
+                label="FHD - Ground Truth", type="pil", interactive=False, height=600
+            )
+
+        gr.Markdown("## 📈 Row 3: Prediction vs Ground Truth Comparison")
+
+        with gr.Row():
+            chm_comparison = gr.Plot(label="CHM: Predicted vs Ground Truth")
+            pai_comparison = gr.Plot(label="PAI: Predicted vs Ground Truth")
+            fhd_comparison = gr.Plot(label="FHD: Predicted vs Ground Truth")
+
+        # Info section
+        gr.Markdown(
+            """
+        ---
+        ### 📚 Metric Definitions
+        
+        - **CHM (Canopy Height Model)**: Height of forest canopy above ground (meters)
+        - **PAI (Plant Area Index)**: Total one-sided area of plant material per unit ground area
+        - **FHD (Foliage Height Diversity)**: Vertical distribution of vegetation layers
+        
+        ### 🎯 How to Use
+        1. Click anywhere on the input tile image
+        2. The model runs inference on a 45m×45m patch at that location
+        3. View predictions, ground truth, and comparison plots
+        4. Click different locations to explore the tile
+        """
+        )
+
+        # Connect click event
+        input_tile_display.select(
+            fn=run_patch_inference,
+            inputs=[],
+            outputs=[
+                input_tile_display,
+                patch_preview,
+                chm_pred_display,
+                pai_pred_display,
+                fhd_pred_display,
+                chm_gt_display,
+                pai_gt_display,
+                fhd_gt_display,
+                chm_comparison,
+                pai_comparison,
+                fhd_comparison,
+                status_display,
+            ],
+        )
+
+    return demo
+
+
+# ============================================================
+# LAUNCH
+# ============================================================
+if __name__ == "__main__":
+
+    # Check files
+    print("\n" + "=" * 70)
+    print("Checking required files...")
+    print("=" * 70)
+
+    for path, name in [
+        (MODEL_PATH, "Model checkpoint"),
+        (FIXED_INPUT_TIF, "Input RGBI tile"),
+        (FIXED_GT_CHM, "Ground truth CHM"),
+        (FIXED_GT_PAI, "Ground truth PAI"),
+        (FIXED_GT_FHD, "Ground truth FHD"),
+        (VIDEO_PATH, "Overview video"),
+    ]:
+        if os.path.exists(path):
+            size_mb = os.path.getsize(path) / (1024**2)
+            print(f"✓ {name}: {path} ({size_mb:.1f} MB)")
+        else:
+            print(f"✗ {name}: {path} (NOT FOUND)")
+
+    print("=" * 70 + "\n")
+
+    # Launch
+    custom_theme = gr.themes.Soft(
+        primary_hue="emerald",
+        secondary_hue="teal",
+    )
+
+    custom_css = """
+    .gradio-container {
+        max-width: 1900px !important;
+    }
+    """
+
+    demo = create_demo()
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        theme=custom_theme,
+        css=custom_css,
+    )

data/overview.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9d61b4092346e73bca76bc063a90767e8e0bdc3535783c0b167496655a73852
+size 37614381

data/student_MiTB2.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c507e2978fe053b8e77e974abc83a9e4e20638a0562e5f30ad59924342e1979a
+size 97904267

requirements.txt

@@ -0,0 +1,244 @@
+accelerate==1.11.0
+affine==2.4.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.15
+aiosignal==1.4.0
+alabaster==0.7.16
+ansicolors==1.1.8
+appdirs==1.4.4
+asn1crypto==1.5.1
+asttokens==3.0.0
+atomicwrites==1.4.1
+attrs==23.2.0
+azure-core==1.35.1
+azure-datalake-store==1.0.1
+azure-identity==1.25.0
+azure-storage-blob==12.26.0
+Babel==2.15.0
+backports.entry-points-selectable==1.3.0
+backports.functools-lru-cache==2.0.0
+beniget==0.4.1
+bitarray==2.9.2
+bitstring==4.2.3
+black==25.9.0
+blist==1.3.6
+boto3==1.40.40
+botocore==1.40.40
+Bottleneck==1.3.8
+CacheControl==0.14.0
+cachetools==5.5.2
+cachy==0.3.0
+certifi==2024.6.2
+cffi==1.16.0
+chardet==5.2.0
+charset-normalizer==3.3.2
+cleo==2.1.0
+click==8.1.7
+click-plugins==1.1.1
+cligj==0.7.2
+cloudpickle==3.0.0
+colorama==0.4.6
+comm==0.2.2
+commonmark==0.9.1
+contourpy==1.3.2
+crashtest==0.4.1
+cryptography==42.0.8
+cycler==0.12.1
+deap==1.4.1
+debugpy==1.8.15
+decorator==5.1.1
+distlib==0.3.8
+distro==1.9.0
+docopt==0.6.2
+docutils==0.21.2
+doit==0.36.0
+dulwich==0.22.1
+ecdsa==0.19.0
+editables==0.5
+einops==0.8.1
+entrypoints==0.4
+exceptiongroup==1.2.1
+execnet==2.1.1
+executing==2.2.0
+fastjsonschema==2.21.2
+filelock==3.15.1
+fonttools==4.59.0
+frozenlist==1.7.0
+fsspec==2024.6.0
+future==1.0.0
+gast==0.5.4
+gcsfs==2025.9.0
+GDAL==3.10.3
+geopandas==1.1.1
+glob2==0.7
+google-api-core==2.25.1
+google-auth==2.40.3
+google-auth-oauthlib==1.2.2
+google-cloud-core==2.4.3
+google-cloud-storage==3.4.0
+google-crc32c==1.7.1
+google-resumable-media==2.7.2
+googleapis-common-protos==1.70.0
+hf-xet==1.1.5
+html5lib==1.1
+huggingface-hub==0.36.0
+idna==3.7
+imagesize==1.4.1
+importlib-metadata==7.1.0
+importlib-resources==6.4.0
+iniconfig==2.0.0
+intervaltree==3.1.0
+intreehooks==1.0
+ipaddress==1.0.23
+ipykernel==6.30.0
+ipython==9.4.0
+ipython-pygments-lexers==1.1.1
+isodate==0.7.2
+jaraco.classes==3.4.0
+jaraco.context==5.3.0
+jedi==0.19.2
+jeepney==0.8.0
+Jinja2==3.1.4
+jmespath==1.0.1
+joblib==1.4.2
+jsonschema==4.22.0
+jsonschema-specifications==2023.12.1
+jupyter-client==8.7.1
+jupyter-core==5.7.3
+kiwisolver==1.4.8
+keyring==25.2.1
+lark==1.1.9
+liac-arff==2.5.0
+lockfile==0.12.2
+lxml==5.2.2
+MarkupSafe==2.1.5
+matplotlib==3.9.4
+matplotlib-inline==0.1.7
+mock==5.1.0
+more-itertools==10.2.0
+mpi4py==4.0.3
+mpmath==1.4.0
+msal==1.34.1
+msal-extensions==1.2.2
+msgpack==1.0.8
+multidict==6.1.0
+mypy-extensions==1.0.0
+nest-asyncio==1.6.0
+netCDF4==1.7.3
+networkx==3.5.1
+nose==1.3.7
+numexpr==2.10.0
+numpy==1.26.4
+oauthlib==3.2.2
+packaging==24.1
+pandas==2.2.2
+parso==0.8.4
+pathspec==0.12.1
+pbr==6.1.0
+pexpect==4.9.0
+pillow==10.4.0
+pkgconfig==1.5.5
+platformdirs==4.2.2
+ply==3.11
+pooch==1.8.2
+prompt-toolkit==3.0.51
+propcache==0.3.2
+proto-plus==1.26.1
+protobuf==6.32.1
+psutil==5.9.8
+ptyprocess==0.7.0
+pure-eval==0.2.3
+py==1.11.0
+py-expression-eval==0.3.14
+pyarrow==21.0.0
+pyasn1==0.6.0
+pyasn1-modules==0.4.2
+pycparser==2.22
+pycryptodome==3.20.0
+pydevtool==0.3.0
+pyforestscan==0.3.0
+PyGithub==2.8.1
+Pygments==2.18.0
+PyJWT==2.10.1
+pylev==1.4.0
+PyNaCl==1.5.0
+pyogrio==0.11.0
+pyparsing==3.1.2
+pyproj==3.7.1
+pyrsistent==0.20.0
+pytest==8.2.2
+pytest-xdist==3.6.1
+python-dateutil==2.9.0.post0
+pythran==0.16.1
+pytokens==0.1.10
+pytoml==0.1.21
+pytz==2024.1
+PyYAML==6.0.2
+pyzmq==27.0.0
+rapidfuzz==3.9.3
+rasterio==1.4.3
+referencing==0.35.1
+regex==2024.5.15
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==13.7.1
+rich-click==1.8.3
+rioxarray==0.19.0
+rpds-py==0.18.1
+rsa==4.9.1
+s3transfer==0.14.0
+safetensors==0.5.3
+scandir==1.10.0
+scipy==1.13.1
+seaborn==0.13.2
+SecretStorage==3.3.3
+semantic-version==2.10.0
+setuptools==80.9.0
+shapely==2.1.1
+shellingham==1.5.4
+simplegeneric==0.8.1
+simplejson==3.19.2
+six==1.16.0
+snowballstemmer==2.2.0
+sortedcontainers==2.4.0
+Sphinx==7.3.7
+sphinx-bootstrap-theme==0.8.1
+sphinxcontrib-applehelp==1.0.8
+sphinxcontrib-devhelp==1.0.6
+sphinxcontrib-htmlhelp==2.0.5
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.7
+sphinxcontrib-serializinghtml==1.1.10
+sphinxcontrib-websupport==1.2.7
+stack-data==0.6.3
+sympy==1.14.0
+tabulate==0.9.0
+tenacity==9.1.2
+threadpoolctl==3.5.0
+timm==1.0.17
+tokenizers==0.22.1
+toml==0.10.2
+tomli==2.0.1
+tomli-w==1.0.0
+tomlkit==0.12.5
+torch==2.7.1
+torchvision==0.22.1
+tornado==6.5.1
+tqdm==4.67.1
+traitlets==5.14.3
+transformers==4.57.1
+triton==3.3.1
+typing-extensions==4.14.1
+tzdata==2024.1
+ujson==5.10.0
+urllib3==2.2.1
+versioneer==0.29
+virtualenv==20.26.2
+wcwidth==0.2.13
+webencodings==0.5.1
+xarray==2025.7.1
+xlrd==2.0.1
+yarl==1.20.1
+zipfile36==0.1.3
+zipp==3.19.2