GeoScan web app

geoscan/geoscan/config.py

@@ -1,172 +1,173 @@
-"""Run settings.
-
-Every tunable parameter lives here, with its default. A YAML file (see
-``config/default.yaml``) can override any subset of them. The resolved settings
-are written into each run's manifest, so every output is traceable to the exact
-parameters that produced it.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field, fields, is_dataclass
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-
-@dataclass
-class GridConfig:
-    base_res_m: float = 30.0      # terrain / lineament grid (SRTM native ~30 m)
-    emit_factor: int = 2          # EMIT grid = 60 m (native EMIT pixel)
-    aster_factor: int = 3         # ASTER GED grid = 90 m (closest multiple to native 100 m)
-    align_m: float = 180.0        # origin snapped to this so all grids share edges
-    structure_pad_m: float = 1500.0  # extra DEM around the AOI so edge lineaments are complete
-
-
-@dataclass
-class AcquireConfig:
-    ee_project: str | None = None
-    start_date: str = "2022-08-01"
-    end_date: str | None = None         # None = today
-    min_aoi_coverage: float = 0.05      # skip EMIT scenes covering less of the AOI than this
-    max_request_mb: float = 30.0        # Earth Engine computePixels payload limit is ~48 MB
-    retries: int = 4
-
-
-@dataclass
-class SpectralConfig:
-    mc_draws: int = 64                  # Monte-Carlo draws for uncertainty propagation
-    seed: int = 42
-    shoulder_halfwidth_nm: float = 10.0  # shoulders are averaged over +/- this window
-    detect_sigma: float = 2.0           # detection = depth > detect_sigma * sigma
-    min_depth: float = 0.01             # ... and depth above this absolute floor
-    ndvi_max: float = 0.30              # pixels greener than this are masked as vegetation
-    min_albedo: float = 0.04            # darker pixels (shadow, water, burn scars) are masked
-    chunk_pixels: int = 4096
-
-
-@dataclass
-class L2BConfig:
-    group2_min_fit: float = 0.30        # 2 um vibrational group (Tetracorder group 2)
-    group2_max_unc: float = 0.025
-    group1_min_fit: float = 0.25        # 1 um electronic Fe group (Tetracorder group 1)
-    group1_max_unc: float = 0.020
-
-
-@dataclass
-class StructureConfig:
-    n_azimuths: int = 8                 # hillshade illumination directions (every 360/n deg)
-    sun_elevation_deg: float = 30.0
-    smooth_sigma_px: float = 1.0
-    canny_low_quantile: float = 0.80    # adaptive Canny thresholds (terrain independent)
-    canny_high_quantile: float = 0.95
-    hough_threshold: int = 40
-    min_segment_m: float = 450.0
-    max_gap_m: float = 90.0
-    merge_angle_deg: float = 12.0
-    merge_perp_m: float = 90.0
-    merge_gap_m: float = 300.0
-    dedup_angle_deg: float = 10.0
-    dedup_perp_m: float = 60.0
-    min_length_m: float = 800.0
-    density_radius_m: float = 1000.0
-    support_min_fraction: float = 0.5   # share of a line that must lie on edges of one azimuth
-    local_contrast: bool = True         # CLAHE on hillshades + local normalisation of ridge filter
-    clahe_window_m: float = 1500.0
-    clahe_clip: float = 0.01
-    ridge_valley: bool = True           # add Hessian ridge/valley axes to the edge maps
-    ridge_sigmas_m: tuple = (30.0, 60.0)
-    ridge_quantile: float = 0.90
-    profile_offset_m: float = 90.0      # cross-profile sample distance either side of a line
-    scarp_min_step_m: float = 2.0       # one-sided relief needed to call a line a scarp
-    scarp_step_ratio: float = 1.0       # scarp if step > ratio * |centre - mean(sides)|
-    exclude_scarps: bool = True         # leave scarps out of distance / density / S_prox
-    dem_source: str = "srtm"            # srtm | aw3d30 | copernicus
-    canny_tile_m: float = 0.0           # > 0: Canny quantile thresholds per tile of this size (0 = whole grid)
-
-
-@dataclass
-class AlterationConfig:
-    """Four alteration layers (methodology sections 3-4)."""
-    sigma_core_m: float = 90.0          # core vent field kernel (4.3)
-    sigma_halo_m: float = 375.0         # hydrothermal halo kernel (4.3)
-    theta_decay: float = 0.05           # confidence = 1 - exp(-W_halo / theta)
-    reference_percentile: float = 98.0  # a = clip(F / P98(F > 0), 0, 1)   (4.4)
-    sericite_position_nm: tuple = (2190.0, 2215.0)   # Al-OH minimum accepted as white mica
-    propylitic_l2b_classes: tuple = ("chlorite", "epidote", "prehnite", "amphibole")
-    quartz_weights: tuple = (0.55, 0.45)             # QSI = 0.55 QI + 0.45 SI   (4.5)
-    quartz_background_percentile: float = 15.0      # a_qtz = (QSI - P15) / (P98 - P15)
-    # EMIT L2B evidence in the alteration layers (weight = fit / uncertainty, as in the legacy method):
-    #   "none"           L2A detections only (default)
-    #   "combine_all"    add QC-passed L2B identifications everywhere (incl. vegetation-masked pixels)
-    #   "combine_valid"  add L2B only on pixels where L2A has a valid observation
-    l2b_evidence: str = "none"
-    l2b_classes: dict = field(default_factory=lambda: {
-        "muscovite": ["white_mica"], "chlorite": ["chlorite", "epidote"], "gossan": ["ferric_oxide", "jarosite"]})
-    # Lithology background removal: subtract the per-unit median of each layer (mapped rock units),
-    # keep the positive residual ("stronger than normal for this rock"), then P98-normalise.
-    lithology_background: bool = False
-    lithology_file: str | None = None      # default: data/<aoi>/ground_truth/lithology*.geojson
-    lithology_field: str = "LITHOLOGICAL_UNIT"
-    min_unit_area_km2: float = 0.25        # smaller units (and unmapped ground) use the block median
-    min_support: float = 0.20           # usable-pixel fraction in the halo below which a map shows "no data"
-    support_sigma_m: float | None = None  # neighbourhood for data support: None = sigma_halo / 2 (~190 m),
-                                          # > 0 = Gaussian of this sigma, 0 = pixel or an immediate neighbour usable
-    display_upsample: int = 4
-
-
-@dataclass
-class TargetConfig:
-    """Copper Prospectivity Index and drill-target selection (methodology sections 5-6)."""
-    w_hydrothermal: float = 0.70
-    w_structure: float = 0.30
-    w_muscovite: float = 0.30
-    w_quartz: float = 0.28
-    w_gossan: float = 0.22
-    w_chlorite: float = 0.20
-    structure_lambda_m: float = 250.0   # S_prox = exp(-d / lambda)   (4.6)
-    min_cpi: float = 0.25
-    n_targets: int = 50
-    min_spacing_m: float = 250.0
-    tier1: float = 0.70
-    tier2: float = 0.50
-    tier3: float = 0.28
-    require_data_support: bool = True   # no targets where EMIT had no usable pixels (vegetation/cloud)
-
-
-@dataclass
-class Settings:
-    grid: GridConfig = field(default_factory=GridConfig)
-    acquire: AcquireConfig = field(default_factory=AcquireConfig)
-    spectral: SpectralConfig = field(default_factory=SpectralConfig)
-    l2b: L2BConfig = field(default_factory=L2BConfig)
-    structure: StructureConfig = field(default_factory=StructureConfig)
-    alteration: AlterationConfig = field(default_factory=AlterationConfig)
-    targets: TargetConfig = field(default_factory=TargetConfig)
-    run_label: str = ""   # shown on every map, e.g. "EXTENDED COVERAGE (NDVI <= 0.35) - lower confidence"
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-def _apply(obj: Any, values: dict[str, Any], path: str = "") -> None:
-    known = {f.name: f for f in fields(obj)}
-    for key, value in (values or {}).items():
-        if key not in known:
-            raise KeyError(f"Unknown setting '{path}{key}'")
-        current = getattr(obj, key)
-        if is_dataclass(current):
-            _apply(current, value, f"{path}{key}.")
-        else:
-            setattr(obj, key, value)
-
-
-def load_settings(path: str | Path | None = None, overrides: dict[str, Any] | None = None) -> Settings:
-    settings = Settings()
-    if path:
-        with open(path, encoding="utf-8") as f:
-            _apply(settings, yaml.safe_load(f) or {})
-    if overrides:
-        _apply(settings, overrides)
-    return settings
+"""Run settings.
+
+Every tunable parameter lives here, with its default. A YAML file (see
+``config/default.yaml``) can override any subset of them. The resolved settings
+are written into each run's manifest, so every output is traceable to the exact
+parameters that produced it.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field, fields, is_dataclass
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+@dataclass
+class GridConfig:
+    base_res_m: float = 30.0      # terrain / lineament grid (SRTM native ~30 m)
+    emit_factor: int = 2          # EMIT grid = 60 m (native EMIT pixel)
+    aster_factor: int = 3         # ASTER GED grid = 90 m (closest multiple to native 100 m)
+    align_m: float = 180.0        # origin snapped to this so all grids share edges
+    structure_pad_m: float = 1500.0  # extra DEM around the AOI so edge lineaments are complete
+
+
+@dataclass
+class AcquireConfig:
+    ee_project: str | None = None
+    start_date: str = "2022-08-01"
+    end_date: str | None = None         # None = today
+    min_aoi_coverage: float = 0.05      # skip EMIT scenes covering less of the AOI than this
+    max_request_mb: float = 30.0        # Earth Engine computePixels payload limit is ~48 MB
+    retries: int = 4
+
+
+@dataclass
+class SpectralConfig:
+    mc_draws: int = 64                  # Monte-Carlo draws for uncertainty propagation
+    seed: int = 42
+    shoulder_halfwidth_nm: float = 10.0  # shoulders are averaged over +/- this window
+    detect_sigma: float = 2.0           # detection = depth > detect_sigma * sigma
+    min_depth: float = 0.01             # ... and depth above this absolute floor
+    ndvi_max: float = 0.30              # pixels greener than this are masked as vegetation
+    min_albedo: float = 0.04            # darker pixels (shadow, water, burn scars) are masked
+    chunk_pixels: int = 4096
+
+
+@dataclass
+class L2BConfig:
+    group2_min_fit: float = 0.30        # 2 um vibrational group (Tetracorder group 2)
+    group2_max_unc: float = 0.025
+    group1_min_fit: float = 0.25        # 1 um electronic Fe group (Tetracorder group 1)
+    group1_max_unc: float = 0.020
+
+
+@dataclass
+class StructureConfig:
+    n_azimuths: int = 8                 # hillshade illumination directions (every 360/n deg)
+    sun_elevation_deg: float = 30.0
+    smooth_sigma_px: float = 1.0
+    canny_low_quantile: float = 0.80    # adaptive Canny thresholds (terrain independent)
+    canny_high_quantile: float = 0.95
+    hough_threshold: int = 40
+    min_segment_m: float = 450.0
+    max_gap_m: float = 90.0
+    merge_angle_deg: float = 12.0
+    merge_perp_m: float = 90.0
+    merge_gap_m: float = 300.0
+    dedup_angle_deg: float = 10.0
+    dedup_perp_m: float = 60.0
+    min_length_m: float = 800.0
+    density_radius_m: float = 1000.0
+    support_min_fraction: float = 0.5   # share of a line that must lie on edges of one azimuth
+    local_contrast: bool = True         # CLAHE on hillshades + local normalisation of ridge filter
+    clahe_window_m: float = 1500.0
+    clahe_clip: float = 0.01
+    ridge_valley: bool = True           # add Hessian ridge/valley axes to the edge maps
+    ridge_sigmas_m: tuple = (30.0, 60.0)
+    ridge_quantile: float = 0.90
+    profile_offset_m: float = 90.0      # cross-profile sample distance either side of a line
+    scarp_min_step_m: float = 2.0       # one-sided relief needed to call a line a scarp
+    scarp_step_ratio: float = 1.0       # scarp if step > ratio * |centre - mean(sides)|
+    exclude_scarps: bool = True         # leave scarps out of distance / density / S_prox
+    dem_source: str = "srtm"            # srtm | aw3d30 | copernicus
+    canny_tile_m: float = 0.0           # > 0: Canny quantile thresholds per tile of this size (0 = whole grid)
+
+
+@dataclass
+class AlterationConfig:
+    """Four alteration layers (methodology sections 3-4)."""
+    sigma_core_m: float = 90.0          # core vent field kernel (4.3)
+    sigma_halo_m: float = 375.0         # hydrothermal halo kernel (4.3)
+    theta_decay: float = 0.05           # confidence = 1 - exp(-W_halo / theta)
+    reference_percentile: float = 98.0  # a = clip(F / P98(F > 0), 0, 1)   (4.4)
+    sericite_position_nm: tuple = (2190.0, 2215.0)   # Al-OH minimum accepted as white mica
+    propylitic_l2b_classes: tuple = ("chlorite", "epidote", "prehnite", "amphibole")
+    quartz_weights: tuple = (0.55, 0.45)             # QSI = 0.55 QI + 0.45 SI   (4.5)
+    quartz_background_percentile: float = 15.0      # a_qtz = (QSI - P15) / (P98 - P15)
+    # EMIT L2B evidence in the alteration layers (weight = fit / uncertainty, as in the legacy method):
+    #   "none"           L2A detections only (default)
+    #   "combine_all"    add QC-passed L2B identifications everywhere (incl. vegetation-masked pixels)
+    #   "combine_valid"  add L2B only on pixels where L2A has a valid observation
+    l2b_evidence: str = "none"
+    l2b_classes: dict = field(default_factory=lambda: {
+        "muscovite": ["white_mica"], "chlorite": ["chlorite", "epidote"], "gossan": ["ferric_oxide", "jarosite"]})
+    # Lithology background removal: subtract the per-unit median of each layer (mapped rock units),
+    # keep the positive residual ("stronger than normal for this rock"), then P98-normalise.
+    lithology_background: bool = False
+    lithology_file: str | None = None      # default: data/<aoi>/ground_truth/lithology*.geojson
+    lithology_field: str = "LITHOLOGICAL_UNIT"
+    min_unit_area_km2: float = 0.25        # smaller units (and unmapped ground) use the block median
+    min_support: float = 0.20           # usable-pixel fraction in the halo below which a map shows "no data"
+    support_sigma_m: float | None = None  # neighbourhood for data support: None = sigma_halo / 2 (~190 m),
+                                          # > 0 = Gaussian of this sigma, 0 = pixel or an immediate neighbour usable
+    display_upsample: int = 4
+
+
+@dataclass
+class TargetConfig:
+    """Copper Prospectivity Index and drill-target selection (methodology sections 5-6)."""
+    w_hydrothermal: float = 0.70
+    w_structure: float = 0.30
+    w_muscovite: float = 0.30
+    w_quartz: float = 0.28
+    w_gossan: float = 0.22
+    w_chlorite: float = 0.20
+    structure_lambda_m: float = 250.0   # S_prox = exp(-d / lambda)   (4.6)
+    min_cpi: float = 0.25
+    n_targets: int = 50
+    min_spacing_m: float = 250.0
+    tier1: float = 0.70
+    tier2: float = 0.50
+    tier3: float = 0.28
+    require_data_support: bool = True   # no field-check locations where EMIT had no usable pixels
+    zone_min_area_km2: float = 0.01     # prospective zones smaller than this (~11 cells) are dropped
+
+
+@dataclass
+class Settings:
+    grid: GridConfig = field(default_factory=GridConfig)
+    acquire: AcquireConfig = field(default_factory=AcquireConfig)
+    spectral: SpectralConfig = field(default_factory=SpectralConfig)
+    l2b: L2BConfig = field(default_factory=L2BConfig)
+    structure: StructureConfig = field(default_factory=StructureConfig)
+    alteration: AlterationConfig = field(default_factory=AlterationConfig)
+    targets: TargetConfig = field(default_factory=TargetConfig)
+    run_label: str = ""   # shown on every map, e.g. "EXTENDED COVERAGE (NDVI <= 0.35) - lower confidence"
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def _apply(obj: Any, values: dict[str, Any], path: str = "") -> None:
+    known = {f.name: f for f in fields(obj)}
+    for key, value in (values or {}).items():
+        if key not in known:
+            raise KeyError(f"Unknown setting '{path}{key}'")
+        current = getattr(obj, key)
+        if is_dataclass(current):
+            _apply(current, value, f"{path}{key}.")
+        else:
+            setattr(obj, key, value)
+
+
+def load_settings(path: str | Path | None = None, overrides: dict[str, Any] | None = None) -> Settings:
+    settings = Settings()
+    if path:
+        with open(path, encoding="utf-8") as f:
+            _apply(settings, yaml.safe_load(f) or {})
+    if overrides:
+        _apply(settings, overrides)
+    return settings

geoscan/geoscan/pipeline.py

@@ -455,10 +455,10 @@ class Pipeline:
         return {"minerals": list(MINERALS)}
 
     def step_targets(self) -> dict:
-        """CPI and ranked drill targets (methodology sections 5-6)."""
+        """CPI, ranked prospective zones and suggested field-check locations (methodology sections 5-6)."""
         import geopandas as gpd
         from shapely.geometry import Point
-        from .prospectivity.targets import cpi, select_targets
+        from .prospectivity.targets import cpi, prospective_zones, select_locations
         cfg = self.settings.targets
         out = self.ws.outputs
 
@@ -475,29 +475,57 @@ class Pipeline:
                      f"H = {cfg.w_muscovite:g} musc + {cfg.w_quartz:g} qtz + {cfg.w_gossan:g} goss + "
                      f"{cfg.w_chlorite:g} chl, S_prox = exp(-d/{cfg.structure_lambda_m:g} m)")
 
+        # ---- prospective zones: the main result (a region, not a point)
+        lines = None
+        lp = out / "vectors/lineaments.gpkg"
+        if lp.exists():
+            lines = gpd.read_file(lp).to_crs(grid.crs)
+            if self.settings.structure.exclude_scarps and len(lines):
+                lines = lines[lines["morphology"] != "scarp"]
+        zones, zone_rank = prospective_zones(c, grid, a, s_prox, cfg, lines, a["data_support"],
+                                             self.settings.alteration.min_support)
+
+        # ---- suggested field-check locations: where to start looking inside the zones
         eligible = inside & ((a["data_support"] >= self.settings.alteration.min_support)
                              if cfg.require_data_support else True)
         attrs = {"Muscovite_Pct": 100 * a["muscovite"], "Quartz_Pct": 100 * a["quartz"],
                  "Gossan_Pct": 100 * a["gossan"], "Chlorite_Pct": 100 * a["chlorite"],
                  "Hydrothermal_Index": h, "Structural_Proximity": s_prox, "Distance_to_Lineament_m": dist,
                  "EMIT_Data_Support": a["data_support"]}
-        df = select_targets(c, grid, attrs, eligible, cfg)
+        df = select_locations(c, grid, attrs, eligible, cfg, zone_rank)
         for col in ("Muscovite_Pct", "Quartz_Pct", "Gossan_Pct", "Chlorite_Pct"):
             if col in df:
                 df[col] = df[col].round(1)
         if "Distance_to_Lineament_m" in df:
             df["Distance_to_Lineament_m"] = df["Distance_to_Lineament_m"].round(0)
-        self._table("tables/top50_targets.csv", df, "Ranked drill targets (CPI, 250 m minimum spacing)")
+        zones["Field_Check_Locations"] = [int((df["Zone"] == z).sum()) if len(df) else 0 for z in zones["Zone_ID"]] \
+            if len(zones) else []
+
+        for stale in ("tables/top50_targets.csv", "vectors/top50_targets.geojson"):    # names used before zones
+            (out / stale).unlink(missing_ok=True)
+            self._outputs.pop(stale, None)
+        self._table("tables/prospective_zones.csv", pd.DataFrame(zones.drop(columns="geometry")),
+                    f"Prospective zones: connected areas with CPI >= {cfg.tier2:g} (Tier 1 / 2) and isolated anomalies "
+                    f"with CPI >= {cfg.tier3:g} (Tier 3), ranked by tier and peak CPI")
+        zp = self.ws.out("vectors", "prospective_zones.geojson")
+        zones.to_crs(4326).to_file(zp, driver="GeoJSON")
+        self._record(zp, "Prospective zones, ranked (EPSG:4326)", features=len(zones))
+        self._table("tables/field_check_locations.csv", df,
+                    f"Suggested field-check locations (highest CPI cells, >= {cfg.min_spacing_m:g} m apart). "
+                    "Starting points for field work inside the zones, not drill collars.")
+        fp = self.ws.out("vectors", "field_check_locations.geojson")
         if len(df):
             gdf = gpd.GeoDataFrame(df, geometry=[Point(xy) for xy in zip(df["Longitude"], df["Latitude"])], crs=4326)
-            p = self.ws.out("vectors", "top50_targets.geojson")
-            gdf.to_file(p, driver="GeoJSON")
-            self._record(p, "Ranked drill targets (EPSG:4326)", features=len(gdf))
+            gdf.to_file(fp, driver="GeoJSON")
+            self._record(fp, "Suggested field-check locations (EPSG:4326)", features=len(gdf))
+        else:
+            fp.unlink(missing_ok=True)
         self._zones(np.nan_to_num(c), grid, (cfg.tier3, cfg.tier2, cfg.tier1, 1.001),
                     ("Tier 3 General Anomaly", "Tier 2 Medium Priority", "Tier 1 High Priority"),
-                    "vectors/cpi_target_zones.geojson", "CPI target zones")
-        tiers = df["Priority_Tier"].value_counts().to_dict() if len(df) else {}
-        return {"targets": len(df), "tiers": tiers, "cpi_max": round(float(np.nanmax(c)), 4)}
+                    "vectors/cpi_target_zones.geojson", "CPI tier bands")
+        tiers = zones["Priority_Tier"].value_counts().to_dict() if len(zones) else {}
+        return {"zones": len(zones), "zone_tiers": tiers, "zone_area_km2": round(float(zones["Area_km2"].sum()), 3)
+                if len(zones) else 0.0, "field_check_locations": len(df), "cpi_max": round(float(np.nanmax(c)), 4)}
 
     def step_maps(self) -> dict:
         from .report import render

geoscan/geoscan/prospectivity/targets.py

@@ -1,78 +1,183 @@
-"""Copper Prospectivity Index (CPI) and drill-target selection (methodology sections 5-6).
-
-    H   = 0.30 a_musc + 0.28 a_qtz + 0.22 a_goss + 0.20 a_chl
-    CPI = 1_block * (0.70 H + 0.30 S_prox),     S_prox = exp(-d_lineament / 250 m)
-
-CPI is not re-stretched, so the tier thresholds (0.70 / 0.50 / 0.28) are absolute.
-
-Targets: cells with CPI >= 0.25 (and usable EMIT data when ``require_data_support``) are
-sorted by CPI and accepted greedily if >= 250 m from every accepted collar, up to 50.
-"""
-
-from __future__ import annotations
-
-import numpy as np
-import pandas as pd
-from pyproj import Transformer
-
-from ..config import TargetConfig
-from ..grid import Grid
-
-
-def cpi(a: dict[str, np.ndarray], s_prox: np.ndarray, inside: np.ndarray, cfg: TargetConfig):
-    h = (cfg.w_muscovite * a["muscovite"] + cfg.w_quartz * a["quartz"] +
-         cfg.w_gossan * a["gossan"] + cfg.w_chlorite * a["chlorite"])
-    c = cfg.w_hydrothermal * h + cfg.w_structure * s_prox
-    return np.where(inside, c, np.nan).astype("float32"), np.where(inside, h, np.nan).astype("float32")
-
-
-def tier(value: float, cfg: TargetConfig) -> tuple[str, str]:
-    if value >= cfg.tier1:
-        return "Tier 1: High Priority", "Diamond core drilling (DDH)"
-    if value >= cfg.tier2:
-        return "Tier 2: Medium Priority", "RC drilling / trenching across strike"
-    if value >= cfg.tier3:
-        return "Tier 3: General Anomaly", "Geological field mapping & rock-chip geochemistry"
-    return "Below Tier 3", "Field verification"
-
-
-def target_name(rank: int) -> str:
-    if rank <= 26:
-        return f"Target {chr(64 + rank)}"
-    return f"Target A{chr(64 + rank - 26)}"
-
-
-def select_targets(c: np.ndarray, grid: Grid, layers: dict[str, np.ndarray], eligible: np.ndarray,
-                   cfg: TargetConfig) -> pd.DataFrame:
-    ok = eligible & np.isfinite(c) & (c >= cfg.min_cpi)
-    rows, cols = np.nonzero(ok)
-    order = np.argsort(-c[rows, cols], kind="stable")
-    rows, cols = rows[order], cols[order]
-    xs = grid.x0 + (cols + 0.5) * grid.res
-    ys = grid.y0 - (rows + 0.5) * grid.res
-
-    chosen: list[int] = []
-    cx, cy = np.empty(0), np.empty(0)
-    for i in range(len(rows)):
-        if cx.size and np.min((cx - xs[i]) ** 2 + (cy - ys[i]) ** 2) < cfg.min_spacing_m ** 2:
-            continue
-        chosen.append(i)
-        cx, cy = np.append(cx, xs[i]), np.append(cy, ys[i])
-        if len(chosen) >= cfg.n_targets:
-            break
-
-    lon, lat = Transformer.from_crs(grid.crs, "EPSG:4326", always_xy=True).transform(xs[chosen], ys[chosen])
-    recs = []
-    for rank, (i, lo, la) in enumerate(zip(chosen, lon, lat), start=1):
-        r, cc = rows[i], cols[i]
-        t, rec = tier(float(c[r, cc]), cfg)
-        row = {"Rank": rank, "Target_ID": f"UNM-TGT-{rank:02d}", "Target_Name": target_name(rank),
-               "Latitude": round(float(la), 6), "Longitude": round(float(lo), 6),
-               "Easting": round(float(xs[i]), 1), "Northing": round(float(ys[i]), 1),
-               "CPI": round(float(c[r, cc]), 4), "CPI_Percent": round(100 * float(c[r, cc]), 1),
-               "Priority_Tier": t}
-        for k, v in layers.items():
-            row[k] = round(float(v[r, cc]), 4) if np.isfinite(v[r, cc]) else None
-        row["Exploration_Recommendation"] = rec
-        recs.append(row)
-    return pd.DataFrame(recs)
+"""Copper Prospectivity Index (CPI), prospective zones and suggested field-check locations
+(methodology sections 5-6).
+
+    H   = 0.30 a_musc + 0.28 a_qtz + 0.22 a_goss + 0.20 a_chl
+    CPI = 1_block * (0.70 H + 0.30 S_prox),     S_prox = exp(-d_lineament / 250 m)
+
+CPI is not re-stretched, so the tier thresholds (0.70 / 0.50 / 0.28) are absolute.
+
+The result of this kind of work is a *region*, not a point. The data are 60-90 m pixels spread over a
+few hundred metres, and they describe the surface, not the ore. So the main product is the set of
+**prospective zones**: connected areas with CPI >= the Tier 2 threshold (plus isolated Tier 3 anomalies),
+ranked by tier and then by peak CPI. The Tier 3 contour around them is their outer halo.
+
+**Suggested field-check locations** are a convenience for planning traverses: the highest-CPI cells,
+kept >= 250 m apart so each anomaly gets about one. They mark where to start looking inside a zone.
+They are not drill collars, and their exact position is not significant.
+"""
+
+from __future__ import annotations
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from pyproj import Transformer
+from rasterio.features import shapes
+from scipy.ndimage import label
+from shapely.geometry import shape
+from shapely.ops import unary_union
+
+from ..config import TargetConfig
+from ..grid import Grid
+
+MINERALS = ("muscovite", "quartz", "gossan", "chlorite")
+TIER_LABELS = {1: "Tier 1: High Priority", 2: "Tier 2: Medium Priority", 3: "Tier 3: General Anomaly"}
+FOLLOW_UP = {
+    1: "Detailed geological mapping, systematic rock-chip / soil sampling and ground geophysics",
+    2: "Reconnaissance mapping and rock-chip sampling",
+    3: "Low priority: check during regional traverses",
+    0: "Field verification",
+}
+
+
+def cpi(a: dict[str, np.ndarray], s_prox: np.ndarray, inside: np.ndarray, cfg: TargetConfig):
+    h = (cfg.w_muscovite * a["muscovite"] + cfg.w_quartz * a["quartz"] +
+         cfg.w_gossan * a["gossan"] + cfg.w_chlorite * a["chlorite"])
+    c = cfg.w_hydrothermal * h + cfg.w_structure * s_prox
+    return np.where(inside, c, np.nan).astype("float32"), np.where(inside, h, np.nan).astype("float32")
+
+
+def tier_number(value: float, cfg: TargetConfig) -> int:
+    return 1 if value >= cfg.tier1 else 2 if value >= cfg.tier2 else 3 if value >= cfg.tier3 else 0
+
+
+def tier(value: float, cfg: TargetConfig) -> tuple[str, str]:
+    """(tier label, suggested follow-up). Follow-up is staged field work; nothing here justifies drilling."""
+    n = tier_number(value, cfg)
+    return TIER_LABELS.get(n, "Below Tier 3"), FOLLOW_UP[n]
+
+
+def location_name(rank: int) -> str:
+    if rank <= 26:
+        return f"Location {chr(64 + rank)}"
+    return f"Location A{chr(64 + rank - 26)}"
+
+
+def prospective_zones(c: np.ndarray, grid: Grid, a: dict[str, np.ndarray], s_prox: np.ndarray, cfg: TargetConfig,
+                      lineaments: gpd.GeoDataFrame | None = None, support: np.ndarray | None = None,
+                      min_support: float = 0.20):
+    """Ranked prospective zones.
+
+    A zone is a connected area with CPI >= tier2 (Tier 1 if it reaches tier1 somewhere, otherwise Tier 2).
+    A weak anomaly that is separate from every such zone and only reaches tier3 is a Tier 3 zone.
+    The tier3 contour around the Tier 1 / 2 zones is their outer halo; it is not part of the zone.
+    (Using tier3 as the boundary merges whole districts into one blob: at Thanewasna it covered 56 % of the
+    block for 74 % of the lode area, against 16.5 % of the block for 48.5 % of the lodes with tier2.)
+
+    Returns (GeoDataFrame in grid CRS, int raster with the zone rank per cell, 0 = no zone).
+    """
+    eight = np.ones((3, 3), int)
+    finite = np.isfinite(c)
+    core, n_core = label(finite & (c >= cfg.tier2), structure=eight)
+    halo, n_halo = label(finite & (c >= cfg.tier3), structure=eight)
+    masks = [core == k for k in range(1, n_core + 1)]
+    with_core = set(np.unique(halo[core > 0]))                       # halo components that contain a core
+    masks += [halo == k for k in range(1, n_halo + 1) if k not in with_core]
+
+    cell_km2 = grid.res ** 2 / 1e6
+    ll = Transformer.from_crs(grid.crs, "EPSG:4326", always_xy=True)
+    weights = {"muscovite": cfg.w_muscovite, "quartz": cfg.w_quartz, "gossan": cfg.w_gossan, "chlorite": cfg.w_chlorite}
+    lines = unary_union(list(lineaments.geometry)) if lineaments is not None and len(lineaments) else None
+
+    recs, geoms, kept = [], [], []
+    for m in masks:
+        area = float(m.sum()) * cell_km2
+        if area < cfg.zone_min_area_km2:
+            continue
+        geom = unary_union([shape(g) for g, v in shapes(m.astype("uint8"), mask=m, transform=grid.transform,
+                                                         connectivity=8)])
+        geom = geom.buffer(grid.res / 2).buffer(-grid.res / 2).simplify(grid.res / 4)   # soften the pixel steps
+        if geom.is_empty:
+            continue
+        cz = c[m]
+        peak = float(cz.max())
+        means = {k2: float(np.nanmean(a[k2][m])) for k2 in MINERALS}
+        contrib = sorted(((weights[k2] * means[k2], k2) for k2 in MINERALS), reverse=True)
+        struct = float(np.nanmean(s_prox[m]))
+        evidence = [k2 for _, k2 in contrib[:2]] + (["structure"] if struct >= 0.5 else [])
+        pr, pc = np.unravel_index(np.argmax(np.where(m, c, -1)), c.shape)          # the peak cell
+        lon, lat = ll.transform(grid.x0 + (pc + 0.5) * grid.res, grid.y0 - (pr + 0.5) * grid.res)
+        t = tier_number(peak, cfg)
+        # same rule as the map hatching: a cell is assessed if EMIT saw the ground there OR detected a mineral
+        emit = np.maximum.reduce([a["muscovite"][m], a["chlorite"][m], a["gossan"][m]])
+        seen = 1.0 if support is None else float(((np.nan_to_num(support[m]) >= min_support) | (emit >= 0.05)).mean())
+        basis = "EMIT alteration, quartz and structure" if seen >= 0.8 else \
+            "Partly assessed by EMIT; elsewhere quartz and structure only" if seen >= 0.2 else \
+            "Quartz and structure only (EMIT not assessed)"
+        recs.append({
+            "tier": t, "Priority_Tier": TIER_LABELS[t], "Area_km2": round(area, 3),
+            "CPI_Max_Pct": round(100 * peak, 1), "CPI_Mean_Pct": round(100 * float(cz.mean()), 1),
+            "Tier1_Area_km2": round(float((cz >= cfg.tier1).sum()) * cell_km2, 3),
+            **{f"{k2.capitalize()}_Pct": round(100 * means[k2], 1) for k2 in MINERALS},
+            "Structural_Proximity": round(struct, 2),
+            "Lineaments_km": round(geom.intersection(lines).length / 1000, 2) if lines is not None else 0.0,
+            "Main_Evidence": ", ".join(evidence), "Evidence_Basis": basis,
+            "Peak_Latitude": round(float(lat), 4), "Peak_Longitude": round(float(lon), 4),
+            "Suggested_Follow_Up": FOLLOW_UP[t],
+        })
+        geoms.append(geom)
+        kept.append(m)
+
+    order = sorted(range(len(recs)), key=lambda i: (recs[i]["tier"], -recs[i]["CPI_Max_Pct"], -recs[i]["Area_km2"]))
+    rank_raster = np.zeros(c.shape, "int32")
+    out = []
+    for rank, i in enumerate(order, start=1):
+        rank_raster[kept[i]] = rank
+        out.append({"Zone": rank, "Zone_ID": f"Z{rank:02d}", **{k: v for k, v in recs[i].items() if k != "tier"}})
+    gdf = gpd.GeoDataFrame(out, geometry=[geoms[i] for i in order], crs=grid.crs)
+    return gdf, rank_raster
+
+
+def select_locations(c: np.ndarray, grid: Grid, layers: dict[str, np.ndarray], eligible: np.ndarray,
+                     cfg: TargetConfig, zone_rank: np.ndarray | None = None) -> pd.DataFrame:
+    """Suggested field-check locations: highest-CPI cells, greedily kept >= min_spacing_m apart."""
+    ok = eligible & np.isfinite(c) & (c >= cfg.min_cpi)
+    rows, cols = np.nonzero(ok)
+    order = np.argsort(-c[rows, cols], kind="stable")
+    rows, cols = rows[order], cols[order]
+    xs = grid.x0 + (cols + 0.5) * grid.res
+    ys = grid.y0 - (rows + 0.5) * grid.res
+
+    chosen: list[int] = []
+    cx, cy = np.empty(0), np.empty(0)
+    for i in range(len(rows)):
+        if cx.size and np.min((cx - xs[i]) ** 2 + (cy - ys[i]) ** 2) < cfg.min_spacing_m ** 2:
+            continue
+        chosen.append(i)
+        cx, cy = np.append(cx, xs[i]), np.append(cy, ys[i])
+        if len(chosen) >= cfg.n_targets:
+            break
+
+    lon, lat = Transformer.from_crs(grid.crs, "EPSG:4326", always_xy=True).transform(xs[chosen], ys[chosen])
+    recs = []
+    for rank, (i, lo, la) in enumerate(zip(chosen, lon, lat), start=1):
+        r, cc = rows[i], cols[i]
+        t, follow = tier(float(c[r, cc]), cfg)
+        z = int(zone_rank[r, cc]) if zone_rank is not None else 0
+        where = f"Z{z:02d}" if z else "outer halo" if c[r, cc] >= cfg.tier3 else "outside zones"
+        row = {"Rank": rank, "Location_ID": f"FC-{rank:02d}", "Location_Name": location_name(rank),
+               "Zone": where,
+               "Latitude": round(float(la), 5), "Longitude": round(float(lo), 5),
+               "Easting": round(float(xs[i]), 1), "Northing": round(float(ys[i]), 1),
+               "CPI": round(float(c[r, cc]), 4), "CPI_Percent": round(100 * float(c[r, cc]), 1),
+               "Priority_Tier": t}
+        for k, v in layers.items():
+            row[k] = round(float(v[r, cc]), 4) if np.isfinite(v[r, cc]) else None
+        row["Check_Within_m"] = int(round(cfg.min_spacing_m))
+        row["Suggested_Follow_Up"] = follow
+        recs.append(row)
+    return pd.DataFrame(recs)
+
+
+# backwards-compatible name used by older scripts
+select_targets = select_locations

geoscan/geoscan/report/contour_maps.py

@@ -1,242 +1,253 @@
-"""Publication-style contour maps in longitude / latitude.
-
-Filled contours of a smooth surface, labelled isolines, clipped to the AOI, over an SRTM
-hillshade, with lineaments, scale bar and north arrow. Areas with no usable data are shaded
-and labelled rather than filled.
-
-Surfaces are resampled finer (bicubic) for drawing only; the GeoTIFFs keep native resolution.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-import matplotlib
-
-matplotlib.use("Agg")
-import matplotlib.patheffects as pe  # noqa: E402
-import matplotlib.pyplot as plt  # noqa: E402
-import numpy as np  # noqa: E402
-from matplotlib.lines import Line2D  # noqa: E402
-from matplotlib.patches import Patch, PathPatch  # noqa: E402
-from matplotlib.path import Path as MplPath  # noqa: E402
-from pyproj import Transformer  # noqa: E402
-from scipy.ndimage import distance_transform_edt, zoom  # noqa: E402
-
-from ..grid import Grid  # noqa: E402
-from .maps import save_figure  # noqa: E402
-
-STROKE = [pe.withStroke(linewidth=2.2, foreground="white")]
-matplotlib.rcParams["hatch.color"] = "#a8a8a8"
-matplotlib.rcParams["hatch.linewidth"] = 0.5
-
-
-def lonlat_mesh(grid: Grid, factor: int = 1):
-    """Cell-centre lon/lat arrays for ``grid`` subdivided by ``factor``."""
-    res = grid.res / factor
-    xs = grid.x0 + (np.arange(grid.width * factor) + 0.5) * res
-    ys = grid.y0 - (np.arange(grid.height * factor) + 0.5) * res
-    X, Y = np.meshgrid(xs, ys)
-    lon, lat = Transformer.from_crs(grid.crs, "EPSG:4326", always_xy=True).transform(X, Y)
-    return lon, lat
-
-
-def _fill_nearest(arr: np.ndarray) -> np.ndarray:
-    valid = np.isfinite(arr)
-    if valid.all() or not valid.any():
-        return np.where(valid, arr, 0.0)
-    _, (ri, ci) = distance_transform_edt(~valid, return_indices=True)
-    return arr[ri, ci]
-
-
-def upsample(arr: np.ndarray, factor: int, support: np.ndarray | None = None,
-             min_support: float | None = None) -> np.ndarray:
-    """Bicubic resampling for display. With ``support``, the no-data boundary is the
-    ``min_support`` isoline of the resampled support surface, so it is smooth too."""
-    valid = np.isfinite(arr)
-    if factor <= 1:
-        return arr
-    fine = zoom(_fill_nearest(arr), factor, order=3, grid_mode=True, mode="nearest")
-    if support is not None and min_support is not None:
-        fine_s = zoom(np.nan_to_num(support, nan=0.0), factor, order=3, grid_mode=True, mode="nearest")
-        inside = zoom(np.isfinite(support).astype(float), factor, order=1, grid_mode=True, mode="nearest") > 0.5
-        keep = (fine_s >= min_support) & inside
-    else:
-        keep = zoom(valid.astype(float), factor, order=1, grid_mode=True, mode="nearest") > 0.5
-    return np.where(keep, fine, np.nan)
-
-
-def _aoi_patch(aoi_wgs84, ax):
-    verts, codes = [], []
-    for poly in getattr(aoi_wgs84, "geoms", [aoi_wgs84]):
-        for ring in [poly.exterior, *poly.interiors]:
-            xy = np.asarray(ring.coords)[:, :2]
-            verts.extend(xy)
-            codes.extend([MplPath.MOVETO] + [MplPath.LINETO] * (len(xy) - 2) + [MplPath.CLOSEPOLY])
-    return PathPatch(MplPath(verts, codes), transform=ax.transData, facecolor="none", edgecolor="none")
-
-
-class ContourMap:
-    def __init__(self, aoi_wgs84, hillshade=None, lines_wgs84=None, figsize=(10, 8.6)):
-        self.aoi = aoi_wgs84
-        self.hillshade = hillshade          # (array, grid)
-        self.lines = lines_wgs84
-        self.figsize = figsize
-
-    def _frame(self, title: str, subtitle: str | None):
-        fig, ax = plt.subplots(figsize=self.figsize, dpi=250)
-        fig.patch.set_facecolor("white")
-        if self.hillshade is not None:
-            hs, g = self.hillshade
-            lon, lat = lonlat_mesh(g)
-            ax.pcolormesh(lon, lat, hs, cmap="gray", shading="gouraud", alpha=0.55, zorder=1, rasterized=True)
-        ax.set_title(title, fontsize=11.5, fontweight="bold", pad=22 if subtitle else 10)
-        if subtitle:
-            ax.text(0.5, 1.012, subtitle, transform=ax.transAxes, ha="center", va="bottom", fontsize=8.5,
-                    color="#444444")
-        return fig, ax
-
-    def _finish(self, fig, ax, path: Path, legend_handles=None, lines_label=True):
-        minx, miny, maxx, maxy = self.aoi.bounds
-        for poly in getattr(self.aoi, "geoms", [self.aoi]):
-            x, y = poly.exterior.xy
-            ax.plot(x, y, color="#111111", lw=1.6, zorder=8)
-        handles = list(legend_handles or [])
-        if self.lines is not None and len(self.lines):
-            for g in self.lines.geometry:
-                x, y = g.xy
-                ax.plot(x, y, color="#00b8d4", lw=1.1, ls="--", alpha=0.9, zorder=7)
-            if lines_label:
-                handles.append(Line2D([0], [0], color="#00b8d4", lw=1.3, ls="--",
-                                      label=f"Topographic lineaments (n={len(self.lines)})"))
-        pad_x, pad_y = 0.02 * (maxx - minx), 0.02 * (maxy - miny)
-        ax.set_xlim(minx - pad_x, maxx + pad_x)
-        ax.set_ylim(miny - pad_y, maxy + pad_y)
-        ax.set_aspect(1.0 / np.cos(np.radians((miny + maxy) / 2)))
-        ax.set_xlabel("Longitude (°E)", fontsize=10, fontweight="bold")
-        ax.set_ylabel("Latitude (°N)", fontsize=10, fontweight="bold")
-        ax.grid(True, alpha=0.25, ls=":")
-        ax.ticklabel_format(useOffset=False, style="plain")
-
-        # 1 km scale bar and north arrow
-        km_deg = 1.0 / (111.32 * np.cos(np.radians((miny + maxy) / 2)))
-        sx, sy = minx + 3 * pad_x, miny + 2.5 * pad_y
-        ax.plot([sx, sx + km_deg], [sy, sy], color="black", lw=3.5, solid_capstyle="butt", zorder=10)
-        ax.text(sx + km_deg / 2, sy + 1.2 * pad_y, "1 km", ha="center", fontsize=8.5, fontweight="bold",
-                path_effects=STROKE, zorder=10)
-        ax.annotate("N", xy=(1.035, 0.99), xytext=(1.035, 0.88), xycoords="axes fraction", ha="center", va="top",
-                    fontsize=12, fontweight="bold", arrowprops=dict(arrowstyle="-|>", color="black", lw=2),
-                    annotation_clip=False, zorder=10)
-        if handles:
-            ax.legend(handles=handles, loc="lower left", bbox_to_anchor=(1.01, 0.0), fontsize=8,
-                      framealpha=0.95, edgecolor="#cccccc")
-        fig.tight_layout()
-        path.parent.mkdir(parents=True, exist_ok=True)
-        save_figure(fig, path, bbox_inches="tight")
-        plt.close(fig)
-
-    def surface(self, path: Path, arr: np.ndarray, grid: Grid, title: str, cbar_label: str, *,
-                cmap="YlOrRd", vmin=0.0, vmax=100.0, levels=(30, 55, 75), fmt="%d%%", subtitle=None,
-                upsample_factor=4, support=None, min_support=None, contour_colors=None, alpha=0.82,
-                targets=None, n_labels=0, n_stars=10, hatch_mask=None, hatch_label=None,
-                nodata_label="Not assessed (no usable EMIT data)"):
-        fig, ax = self._frame(title, subtitle)
-        fine = upsample(arr, upsample_factor, support, min_support)
-        lon, lat = lonlat_mesh(grid, upsample_factor)
-        clip = _aoi_patch(self.aoi, ax)
-        ax.add_patch(clip)
-
-        handles = []
-        nodata = ~np.isfinite(fine)
-        # Only mark gaps that fall inside the AOI (outside it is clipped anyway).
-        step = max(1, lon.size // 40000)
-        sample = np.column_stack([lon.ravel()[::step], lat.ravel()[::step]])
-        in_aoi = clip.get_path().contains_points(sample)
-        gap_share = (nodata.ravel()[::step] & in_aoi).sum() / max(in_aoi.sum(), 1)
-        gaps_inside = gap_share > 0.01  # ignore slivers along the boundary
-        if gaps_inside:
-            nd = ax.contourf(lon, lat, nodata.astype(float), levels=[0.5, 1.5], colors=["#e6e6e6"],
-                             hatches=["///"], alpha=0.6, zorder=2)
-            nd.set_clip_path(clip)
-            handles.append(Patch(facecolor="#e6e6e6", hatch="///", edgecolor="#a8a8a8", label=nodata_label))
-
-        fill_levels = np.linspace(vmin, vmax, 41)
-        cf = ax.contourf(lon, lat, np.clip(fine, vmin, vmax), levels=fill_levels, cmap=cmap, alpha=alpha,
-                         extend="neither", zorder=3)
-        cf.set_clip_path(clip)
-        lv = [l for l in levels if np.nanmin(fine) < l < np.nanmax(fine)] if np.isfinite(fine).any() else []
-        if lv:
-            colors = [contour_colors[levels.index(l)] for l in lv] if contour_colors else "#1a1a1a"
-            cs = ax.contour(lon, lat, fine, levels=lv, colors=colors, linewidths=np.linspace(0.9, 1.5, len(lv)),
-                            alpha=0.9, zorder=5)
-            cs.set_clip_path(clip)
-            labels = ax.clabel(cs, inline=True, fontsize=7.5, fmt=fmt)
-            stroke = [pe.withStroke(linewidth=2.2, foreground="black")] if contour_colors else STROKE
-            plt.setp(labels, path_effects=stroke)
-        if hatch_mask is not None and np.any(hatch_mask):
-            fine_h = zoom(np.asarray(hatch_mask, float), upsample_factor, order=1, grid_mode=True, mode="nearest") \
-                if upsample_factor > 1 else np.asarray(hatch_mask, float)
-            hh = ax.contourf(lon, lat, fine_h, levels=[0.5, 1.5], colors=["none"], hatches=["\\\\\\\\"], zorder=4)
-            hh.set_clip_path(clip)
-            handles.append(Patch(facecolor="none", hatch="\\\\\\\\", edgecolor="#555555", label=hatch_label))
-        if targets is not None and len(targets):
-            top = targets.head(max(n_stars, n_labels))
-            if n_labels:
-                ax.scatter(top["Longitude"], top["Latitude"], s=70, marker="*", c="white", edgecolors="#d50000",
-                           linewidths=1.4, zorder=9)
-                span = self.aoi.bounds[2] - self.aoi.bounds[0]
-                minx, miny, maxx, maxy = self.aoi.bounds
-                r = 0.055 * span
-                dirs = [(np.cos(a), np.sin(a)) for a in np.radians([45, 135, 315, 225, 90, 270, 0, 180])]
-                placed = [(x, y) for x, y in zip(top["Longitude"], top["Latitude"])]  # avoid the stars too
-                for _, t in top.head(n_labels).iterrows():
-                    best, best_d = None, -1.0
-                    for dx, dy in dirs:
-                        for k in (1.0, 1.6):
-                            cx, cy = t["Longitude"] + k * r * dx, t["Latitude"] + k * r * dy * 0.8
-                            if not (minx <= cx <= maxx and miny <= cy <= maxy):
-                                continue
-                            d = min(np.hypot((cx - px) / 1.8, cy - py) for px, py in placed)
-                            if d > best_d:
-                                best, best_d = (cx, cy), d
-                    best = best or (t["Longitude"] + r, t["Latitude"] + r)
-                    placed.append(best)
-                    ax.annotate(f"{t['Target_Name']}\n({t['CPI_Percent']:.0f}%)", xy=(t["Longitude"], t["Latitude"]),
-                                xytext=best, ha="center", va="center",
-                                fontsize=6.8, fontweight="bold", color="white", zorder=11,
-                                bbox=dict(boxstyle="round,pad=0.2", fc="#d50000", ec="white", lw=0.8, alpha=0.95),
-                                arrowprops=dict(arrowstyle="->", color="black", lw=0.9))
-                handles.append(Line2D([0], [0], marker="*", color="w", markerfacecolor="white",
-                                      markeredgecolor="#d50000", markersize=11, label=f"Top {n_labels} targets"))
-            else:
-                ax.scatter(top["Longitude"], top["Latitude"], s=55, marker="*", c="#ffd600", edgecolors="black",
-                           linewidths=0.8, zorder=9)
-                handles.append(Line2D([0], [0], marker="*", color="w", markerfacecolor="#ffd600",
-                                      markeredgecolor="black", markersize=10, label=f"Top {len(top)} CPI targets"))
-        cb = fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.07, shrink=0.7,
-                          ticks=np.linspace(vmin, vmax, 6))
-        cb.set_label(cbar_label, fontsize=9.5, fontweight="bold")
-        self._finish(fig, ax, path, handles)
-
-    def lineaments(self, path: Path, lines_wgs84, title: str, subtitle=None):
-        fig, ax = self._frame(title, subtitle)
-        colors = {"N-S": "#d50000", "NE-SW": "#ff6d00", "E-W": "#2962ff", "NW-SE": "#00c853"}
-        lw = 1.0 + 2.5 * (lines_wgs84["length_m"] - lines_wgs84["length_m"].min()) / \
-            max(lines_wgs84["length_m"].max() - lines_wgs84["length_m"].min(), 1.0)
-        is_scarp = lines_wgs84.get("morphology", "").eq("scarp") if "morphology" in lines_wgs84 else \
-            np.zeros(len(lines_wgs84), bool)
-        for (_, row), w, scarp in zip(lines_wgs84.iterrows(), lw, is_scarp):
-            x, y = row.geometry.xy
-            if scarp:
-                ax.plot(x, y, color="#757575", lw=max(1.0, 0.7 * w), ls="--", zorder=5)
-            else:
-                ax.plot(x, y, color=colors[row["strike_class"]], lw=w, solid_capstyle="round", zorder=6)
-        structural = lines_wgs84[~np.asarray(is_scarp)]
-        counts = structural["strike_class"].value_counts()
-        handles = [Line2D([0], [0], color=c, lw=2.5, label=f"{k} (n={counts.get(k, 0)})") for k, c in colors.items()]
-        if np.any(is_scarp):
-            handles.append(Line2D([0], [0], color="#757575", lw=1.5, ls="--",
-                                  label=f"Scarp / escarpment edge (n={int(np.sum(is_scarp))}, not used in CPI)"))
-        saved, self.lines = self.lines, None
-        self._finish(fig, ax, path, handles)
-        self.lines = saved
+"""Publication-style contour maps in longitude / latitude.
+
+Filled contours of a smooth surface, labelled isolines, clipped to the AOI, over an SRTM
+hillshade, with lineaments, scale bar and north arrow. Areas with no usable data are shaded
+and labelled rather than filled.
+
+Surfaces are resampled finer (bicubic) for drawing only; the GeoTIFFs keep native resolution.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.patheffects as pe  # noqa: E402
+import matplotlib.pyplot as plt  # noqa: E402
+import numpy as np  # noqa: E402
+from matplotlib.lines import Line2D  # noqa: E402
+from matplotlib.patches import Patch, PathPatch  # noqa: E402
+from matplotlib.path import Path as MplPath  # noqa: E402
+from pyproj import Transformer  # noqa: E402
+from scipy.ndimage import distance_transform_edt, zoom  # noqa: E402
+
+from ..grid import Grid  # noqa: E402
+from .maps import save_figure  # noqa: E402
+
+STROKE = [pe.withStroke(linewidth=2.2, foreground="white")]
+matplotlib.rcParams["hatch.color"] = "#a8a8a8"
+matplotlib.rcParams["hatch.linewidth"] = 0.5
+
+
+def lonlat_mesh(grid: Grid, factor: int = 1):
+    """Cell-centre lon/lat arrays for ``grid`` subdivided by ``factor``."""
+    res = grid.res / factor
+    xs = grid.x0 + (np.arange(grid.width * factor) + 0.5) * res
+    ys = grid.y0 - (np.arange(grid.height * factor) + 0.5) * res
+    X, Y = np.meshgrid(xs, ys)
+    lon, lat = Transformer.from_crs(grid.crs, "EPSG:4326", always_xy=True).transform(X, Y)
+    return lon, lat
+
+
+def _fill_nearest(arr: np.ndarray) -> np.ndarray:
+    valid = np.isfinite(arr)
+    if valid.all() or not valid.any():
+        return np.where(valid, arr, 0.0)
+    _, (ri, ci) = distance_transform_edt(~valid, return_indices=True)
+    return arr[ri, ci]
+
+
+def upsample(arr: np.ndarray, factor: int, support: np.ndarray | None = None,
+             min_support: float | None = None) -> np.ndarray:
+    """Bicubic resampling for display. With ``support``, the no-data boundary is the
+    ``min_support`` isoline of the resampled support surface, so it is smooth too."""
+    valid = np.isfinite(arr)
+    if factor <= 1:
+        return arr
+    fine = zoom(_fill_nearest(arr), factor, order=3, grid_mode=True, mode="nearest")
+    if support is not None and min_support is not None:
+        fine_s = zoom(np.nan_to_num(support, nan=0.0), factor, order=3, grid_mode=True, mode="nearest")
+        inside = zoom(np.isfinite(support).astype(float), factor, order=1, grid_mode=True, mode="nearest") > 0.5
+        keep = (fine_s >= min_support) & inside
+    else:
+        keep = zoom(valid.astype(float), factor, order=1, grid_mode=True, mode="nearest") > 0.5
+    return np.where(keep, fine, np.nan)
+
+
+def _aoi_patch(aoi_wgs84, ax):
+    verts, codes = [], []
+    for poly in getattr(aoi_wgs84, "geoms", [aoi_wgs84]):
+        for ring in [poly.exterior, *poly.interiors]:
+            xy = np.asarray(ring.coords)[:, :2]
+            verts.extend(xy)
+            codes.extend([MplPath.MOVETO] + [MplPath.LINETO] * (len(xy) - 2) + [MplPath.CLOSEPOLY])
+    return PathPatch(MplPath(verts, codes), transform=ax.transData, facecolor="none", edgecolor="none")
+
+
+class ContourMap:
+    def __init__(self, aoi_wgs84, hillshade=None, lines_wgs84=None, figsize=(10, 8.6)):
+        self.aoi = aoi_wgs84
+        self.hillshade = hillshade          # (array, grid)
+        self.lines = lines_wgs84
+        self.figsize = figsize
+
+    def _frame(self, title: str, subtitle: str | None):
+        fig, ax = plt.subplots(figsize=self.figsize, dpi=250)
+        fig.patch.set_facecolor("white")
+        if self.hillshade is not None:
+            hs, g = self.hillshade
+            lon, lat = lonlat_mesh(g)
+            ax.pcolormesh(lon, lat, hs, cmap="gray", shading="gouraud", alpha=0.55, zorder=1, rasterized=True)
+        ax.set_title(title, fontsize=11.5, fontweight="bold", pad=22 if subtitle else 10)
+        if subtitle:
+            ax.text(0.5, 1.012, subtitle, transform=ax.transAxes, ha="center", va="bottom", fontsize=8.5,
+                    color="#444444")
+        return fig, ax
+
+    def _finish(self, fig, ax, path: Path, legend_handles=None, lines_label=True):
+        minx, miny, maxx, maxy = self.aoi.bounds
+        for poly in getattr(self.aoi, "geoms", [self.aoi]):
+            x, y = poly.exterior.xy
+            ax.plot(x, y, color="#111111", lw=1.6, zorder=8)
+        handles = list(legend_handles or [])
+        if self.lines is not None and len(self.lines):
+            for g in self.lines.geometry:
+                x, y = g.xy
+                ax.plot(x, y, color="#00b8d4", lw=1.1, ls="--", alpha=0.9, zorder=7)
+            if lines_label:
+                handles.append(Line2D([0], [0], color="#00b8d4", lw=1.3, ls="--",
+                                      label=f"Topographic lineaments (n={len(self.lines)})"))
+        pad_x, pad_y = 0.02 * (maxx - minx), 0.02 * (maxy - miny)
+        ax.set_xlim(minx - pad_x, maxx + pad_x)
+        ax.set_ylim(miny - pad_y, maxy + pad_y)
+        ax.set_aspect(1.0 / np.cos(np.radians((miny + maxy) / 2)))
+        ax.set_xlabel("Longitude (°E)", fontsize=10, fontweight="bold")
+        ax.set_ylabel("Latitude (°N)", fontsize=10, fontweight="bold")
+        ax.grid(True, alpha=0.25, ls=":")
+        ax.ticklabel_format(useOffset=False, style="plain")
+
+        # 1 km scale bar and north arrow
+        km_deg = 1.0 / (111.32 * np.cos(np.radians((miny + maxy) / 2)))
+        sx, sy = minx + 3 * pad_x, miny + 2.5 * pad_y
+        ax.plot([sx, sx + km_deg], [sy, sy], color="black", lw=3.5, solid_capstyle="butt", zorder=10)
+        ax.text(sx + km_deg / 2, sy + 1.2 * pad_y, "1 km", ha="center", fontsize=8.5, fontweight="bold",
+                path_effects=STROKE, zorder=10)
+        ax.annotate("N", xy=(1.035, 0.99), xytext=(1.035, 0.88), xycoords="axes fraction", ha="center", va="top",
+                    fontsize=12, fontweight="bold", arrowprops=dict(arrowstyle="-|>", color="black", lw=2),
+                    annotation_clip=False, zorder=10)
+        if handles:
+            ax.legend(handles=handles, loc="lower left", bbox_to_anchor=(1.01, 0.0), fontsize=8,
+                      framealpha=0.95, edgecolor="#cccccc")
+        fig.tight_layout()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        save_figure(fig, path, bbox_inches="tight")
+        plt.close(fig)
+
+    def surface(self, path: Path, arr: np.ndarray, grid: Grid, title: str, cbar_label: str, *,
+                cmap="YlOrRd", vmin=0.0, vmax=100.0, levels=(30, 55, 75), fmt="%d%%", subtitle=None,
+                upsample_factor=4, support=None, min_support=None, contour_colors=None, alpha=0.82,
+                targets=None, n_labels=0, n_stars=10, hatch_mask=None, hatch_label=None, zones=None, n_zones=12,
+                nodata_label="Not assessed (no usable EMIT data)"):
+        fig, ax = self._frame(title, subtitle)
+        fine = upsample(arr, upsample_factor, support, min_support)
+        lon, lat = lonlat_mesh(grid, upsample_factor)
+        clip = _aoi_patch(self.aoi, ax)
+        ax.add_patch(clip)
+
+        handles = []
+        nodata = ~np.isfinite(fine)
+        # Only mark gaps that fall inside the AOI (outside it is clipped anyway).
+        step = max(1, lon.size // 40000)
+        sample = np.column_stack([lon.ravel()[::step], lat.ravel()[::step]])
+        in_aoi = clip.get_path().contains_points(sample)
+        gap_share = (nodata.ravel()[::step] & in_aoi).sum() / max(in_aoi.sum(), 1)
+        gaps_inside = gap_share > 0.01  # ignore slivers along the boundary
+        if gaps_inside:
+            nd = ax.contourf(lon, lat, nodata.astype(float), levels=[0.5, 1.5], colors=["#e6e6e6"],
+                             hatches=["///"], alpha=0.6, zorder=2)
+            nd.set_clip_path(clip)
+            handles.append(Patch(facecolor="#e6e6e6", hatch="///", edgecolor="#a8a8a8", label=nodata_label))
+
+        fill_levels = np.linspace(vmin, vmax, 41)
+        cf = ax.contourf(lon, lat, np.clip(fine, vmin, vmax), levels=fill_levels, cmap=cmap, alpha=alpha,
+                         extend="neither", zorder=3)
+        cf.set_clip_path(clip)
+        lv = [l for l in levels if np.nanmin(fine) < l < np.nanmax(fine)] if np.isfinite(fine).any() else []
+        if lv:
+            colors = [contour_colors[levels.index(l)] for l in lv] if contour_colors else "#1a1a1a"
+            cs = ax.contour(lon, lat, fine, levels=lv, colors=colors, linewidths=np.linspace(0.9, 1.5, len(lv)),
+                            alpha=0.9, zorder=5)
+            cs.set_clip_path(clip)
+            labels = ax.clabel(cs, inline=True, fontsize=7.5, fmt=fmt)
+            stroke = [pe.withStroke(linewidth=2.2, foreground="black")] if contour_colors else STROKE
+            plt.setp(labels, path_effects=stroke)
+        if hatch_mask is not None and np.any(hatch_mask):
+            fine_h = zoom(np.asarray(hatch_mask, float), upsample_factor, order=1, grid_mode=True, mode="nearest") \
+                if upsample_factor > 1 else np.asarray(hatch_mask, float)
+            hh = ax.contourf(lon, lat, fine_h, levels=[0.5, 1.5], colors=["none"], hatches=["\\\\\\\\"], zorder=4)
+            hh.set_clip_path(clip)
+            handles.append(Patch(facecolor="none", hatch="\\\\\\\\", edgecolor="#555555", label=hatch_label))
+        if zones is not None and len(zones):          # zone numbers at each zone's peak (the zones are the result)
+            for _, z in zones.head(n_zones).iterrows():
+                ax.annotate(z["Zone_ID"], xy=(z["Peak_Longitude"], z["Peak_Latitude"]), xytext=(0, 9),
+                            textcoords="offset points", ha="center", va="center",
+                            fontsize=5.8, fontweight="bold", color="black", zorder=10,
+                            bbox=dict(boxstyle="round,pad=0.18", fc="white", ec="black", lw=0.7, alpha=0.92))
+            handles.append(Line2D([0], [0], marker="s", color="w", markerfacecolor="white", markeredgecolor="black",
+                                  markersize=8, label=f"Prospective zone = inside the {levels[1]:g} % line "
+                                                      f"(top {min(n_zones, len(zones))} numbered)"))
+            n_labels = 0                              # points stay as plain markers, without name boxes
+        if targets is not None and len(targets):
+            top = targets.head(max(n_stars, n_labels))
+            if n_labels:
+                ax.scatter(top["Longitude"], top["Latitude"], s=70, marker="*", c="white", edgecolors="#d50000",
+                           linewidths=1.4, zorder=9)
+                span = self.aoi.bounds[2] - self.aoi.bounds[0]
+                minx, miny, maxx, maxy = self.aoi.bounds
+                r = 0.055 * span
+                dirs = [(np.cos(a), np.sin(a)) for a in np.radians([45, 135, 315, 225, 90, 270, 0, 180])]
+                placed = [(x, y) for x, y in zip(top["Longitude"], top["Latitude"])]  # avoid the stars too
+                for _, t in top.head(n_labels).iterrows():
+                    best, best_d = None, -1.0
+                    for dx, dy in dirs:
+                        for k in (1.0, 1.6):
+                            cx, cy = t["Longitude"] + k * r * dx, t["Latitude"] + k * r * dy * 0.8
+                            if not (minx <= cx <= maxx and miny <= cy <= maxy):
+                                continue
+                            d = min(np.hypot((cx - px) / 1.8, cy - py) for px, py in placed)
+                            if d > best_d:
+                                best, best_d = (cx, cy), d
+                    best = best or (t["Longitude"] + r, t["Latitude"] + r)
+                    placed.append(best)
+                    ax.annotate(f"{t.get('Location_Name', t.get('Target_Name', ''))}\n({t['CPI_Percent']:.0f}%)", xy=(t["Longitude"], t["Latitude"]),
+                                xytext=best, ha="center", va="center",
+                                fontsize=6.8, fontweight="bold", color="white", zorder=11,
+                                bbox=dict(boxstyle="round,pad=0.2", fc="#d50000", ec="white", lw=0.8, alpha=0.95),
+                                arrowprops=dict(arrowstyle="->", color="black", lw=0.9))
+                handles.append(Line2D([0], [0], marker="*", color="w", markerfacecolor="white",
+                                      markeredgecolor="#d50000", markersize=11, label=f"Top {n_labels} field-check locations"))
+            else:
+                ax.scatter(top["Longitude"], top["Latitude"], s=55, marker="*", c="#ffd600", edgecolors="black",
+                           linewidths=0.8, zorder=9)
+                handles.append(Line2D([0], [0], marker="*", color="w", markerfacecolor="#ffd600",
+                                      markeredgecolor="black", markersize=10,
+                                      label=f"Suggested field-check locations (top {len(top)})"))
+        cb = fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.07, shrink=0.7,
+                          ticks=np.linspace(vmin, vmax, 6))
+        cb.set_label(cbar_label, fontsize=9.5, fontweight="bold")
+        self._finish(fig, ax, path, handles)
+
+    def lineaments(self, path: Path, lines_wgs84, title: str, subtitle=None):
+        fig, ax = self._frame(title, subtitle)
+        colors = {"N-S": "#d50000", "NE-SW": "#ff6d00", "E-W": "#2962ff", "NW-SE": "#00c853"}
+        lw = 1.0 + 2.5 * (lines_wgs84["length_m"] - lines_wgs84["length_m"].min()) / \
+            max(lines_wgs84["length_m"].max() - lines_wgs84["length_m"].min(), 1.0)
+        is_scarp = lines_wgs84.get("morphology", "").eq("scarp") if "morphology" in lines_wgs84 else \
+            np.zeros(len(lines_wgs84), bool)
+        for (_, row), w, scarp in zip(lines_wgs84.iterrows(), lw, is_scarp):
+            x, y = row.geometry.xy
+            if scarp:
+                ax.plot(x, y, color="#757575", lw=max(1.0, 0.7 * w), ls="--", zorder=5)
+            else:
+                ax.plot(x, y, color=colors[row["strike_class"]], lw=w, solid_capstyle="round", zorder=6)
+        structural = lines_wgs84[~np.asarray(is_scarp)]
+        counts = structural["strike_class"].value_counts()
+        handles = [Line2D([0], [0], color=c, lw=2.5, label=f"{k} (n={counts.get(k, 0)})") for k, c in colors.items()]
+        if np.any(is_scarp):
+            handles.append(Line2D([0], [0], color="#757575", lw=1.5, ls="--",
+                                  label=f"Scarp / escarpment edge (n={int(np.sum(is_scarp))}, not used in CPI)"))
+        saved, self.lines = self.lines, None
+        self._finish(fig, ax, path, handles)
+        self.lines = saved

geoscan/geoscan/report/render.py

@@ -56,8 +56,10 @@ def render_all(p) -> int:
     lines = gpd.read_file(lines_path) if lines_path.exists() else None
     lines_ll = lines.to_crs(4326) if lines is not None else None
     cmap_ = ContourMap(aoi_ll, bg, lines_ll)
-    targets_csv = out / "tables/top50_targets.csv"
+    targets_csv = out / "tables/field_check_locations.csv"
     targets = pd.read_csv(targets_csv) if targets_csv.exists() else None
+    zones_csv = out / "tables/prospective_zones.csv"
+    zones = pd.read_csv(zones_csv) if zones_csv.exists() else None
 
     def rec(path, title):
         nonlocal count
@@ -104,22 +106,23 @@ def render_all(p) -> int:
             emit_max = np.nanmax(np.stack([np.nan_to_num(_band(stack_path, k)[0]) for k in ("muscovite", "chlorite", "gossan")]), 0)
             no_emit = np.isfinite(sup) & (sup < ac.min_support) & (emit_max < 0.05)
         n = 0 if targets is None else len(targets)
-        tiers = targets["Priority_Tier"].value_counts().to_dict() if n else {}
+        nz = 0 if zones is None else len(zones)
+        tiers = zones["Priority_Tier"].value_counts().to_dict() if nz else {}
         path = m / "cpi_target_map.png"
         cmap_.surface(path, 100 * c, grid,
                       f"{block} Copper Exploration Block — Multi-Sensor Alteration & Targeting Model\n"
-                      "Integrated Copper Prospectivity Index (CPI) & Top Ranked Drill Targets",
+                      "Copper Prospectivity Index (CPI): Prospective Zones & Suggested Field-Check Locations",
                       "Integrated Copper Prospectivity Index (CPI, %)", cmap="plasma",
                       levels=(round(100 * tc.tier3), round(100 * tc.tier2), round(100 * tc.tier1)),
                       contour_colors=["#ffffff", "#ffeb3b", "#ff1744"],
                       subtitle=f"CPI = {tc.w_hydrothermal:.2f}·({tc.w_muscovite:.2f} musc + {tc.w_quartz:.2f} qtz + "
                                f"{tc.w_gossan:.2f} goss + {tc.w_chlorite:.2f} chl) + "
                                f"{tc.w_structure:.2f}·exp(−d/{tc.structure_lambda_m:.0f} m) · "
-                               f"{n} targets ≥ {tc.min_spacing_m:.0f} m apart · " + ", ".join(f"{k.split(':')[0]}: {v}"
-                                                                          for k, v in sorted(tiers.items())),
-                      upsample_factor=2, targets=targets, n_labels=min(15, n), hatch_mask=no_emit,
+                               f"{nz} zones (" + ", ".join(f"{k.split(':')[0]}: {v}" for k, v in sorted(tiers.items())) +
+                               f") · {n} field-check locations ≥ {tc.min_spacing_m:.0f} m apart",
+                      upsample_factor=2, targets=targets, n_labels=min(15, n), hatch_mask=no_emit, zones=zones,
                       hatch_label="Alteration not assessed here: CPI from quartz + structure only")
-        rec(path, "CPI target map with top-ranked drill targets")
+        rec(path, "CPI map with ranked prospective zones and suggested field-check locations")
 
     # ================= structure =================
     if lines_ll is not None and len(lines_ll):

geoscan/geoscan/validation.py

@@ -1,74 +1,91 @@
-"""Validation of prospectivity surfaces against known mineralisation.
-
-All metrics compare a score surface with ground truth inside the AOI:
-
-* ``auc``            Mann-Whitney AUC: probability that a random positive scores higher than a
-                     random negative (0.5 = no skill, 1.0 = perfect).
-* ``bootstrap_auc``  stratified bootstrap confidence interval and one-sided permutation p-value.
-* ``success_rate``   share of mineralised area captured when the AOI is ranked by score
-                     (Agterberg & Bonham-Carter 2005 style success-rate curve).
-* ``target_hits``    how many ranked targets fall within a distance of a lode, versus the number
-                     expected if the same number of points were placed at random in the AOI.
-"""
-
-from __future__ import annotations
-
-import numpy as np
-import pandas as pd
-from scipy.stats import rankdata
-
-
-def auc(pos: np.ndarray, neg: np.ndarray) -> float:
-    pos, neg = pos[np.isfinite(pos)], neg[np.isfinite(neg)]
-    if not pos.size or not neg.size:
-        return np.nan
-    r = rankdata(np.concatenate([pos, neg]))
-    return float((r[:pos.size].sum() - pos.size * (pos.size + 1) / 2) / (pos.size * neg.size))
-
-
-def bootstrap_auc(pos: np.ndarray, neg: np.ndarray, n: int = 2000, seed: int = 0) -> dict:
-    pos, neg = pos[np.isfinite(pos)], neg[np.isfinite(neg)]
-    rng = np.random.default_rng(seed)
-    a = auc(pos, neg)
-    boots = [auc(rng.choice(pos, pos.size), rng.choice(neg, neg.size)) for _ in range(n)]
-    allv = np.concatenate([pos, neg])
-    perm = []
-    for _ in range(n):
-        s = rng.permutation(allv)
-        perm.append(auc(s[:pos.size], s[pos.size:]))
-    return {"auc": round(a, 3), "ci_low": round(float(np.nanpercentile(boots, 2.5)), 3),
-            "ci_high": round(float(np.nanpercentile(boots, 97.5)), 3),
-            "p_value": round(float((np.sum(np.array(perm) >= a) + 1) / (n + 1)), 4),
-            "n_pos": int(pos.size), "n_neg": int(neg.size)}
-
-
-def success_rate(score: np.ndarray, positive: np.ndarray, valid: np.ndarray) -> pd.DataFrame:
-    """Cumulative share of positive cells vs share of AOI area, ranking cells by score (high first)."""
-    s, p = score[valid], positive[valid]
-    ok = np.isfinite(s)
-    s, p = s[ok], p[ok]
-    order = np.argsort(-s, kind="stable")
-    cum_pos = np.cumsum(p[order]) / max(p.sum(), 1)
-    area = np.arange(1, s.size + 1) / s.size
-    return pd.DataFrame({"area_fraction": area, "captured_fraction": cum_pos})
-
-
-def captured_at(curve: pd.DataFrame, fractions=(0.1, 0.2, 0.3)) -> dict:
-    return {f"captured_top{int(100 * f)}pct": round(float(np.interp(f, curve["area_fraction"],
-                                                                     curve["captured_fraction"])), 3)
-            for f in fractions}
-
-
-def target_hits(target_xy: np.ndarray, lodes_utm, aoi_utm, radii=(100.0, 200.0)) -> dict:
-    from shapely.geometry import Point
-    union = lodes_utm.union_all() if hasattr(lodes_utm, "union_all") else lodes_utm.unary_union
-    out = {"n_targets": int(len(target_xy))}
-    if not len(target_xy):
-        return out
-    d = np.array([union.distance(Point(x, y)) for x, y in target_xy])
-    out["median_distance_to_lode_m"] = round(float(np.median(d)), 1)
-    for r in radii:
-        frac_area = union.buffer(r).intersection(aoi_utm).area / aoi_utm.area
-        out[f"hits_within_{int(r)}m"] = int((d <= r).sum())
-        out[f"expected_random_{int(r)}m"] = round(float(frac_area * len(target_xy)), 1)
-    return out
+"""Validation of prospectivity surfaces against known mineralisation.
+
+All metrics compare a score surface with ground truth inside the AOI:
+
+* ``auc``            Mann-Whitney AUC: probability that a random positive scores higher than a
+                     random negative (0.5 = no skill, 1.0 = perfect).
+* ``bootstrap_auc``  stratified bootstrap confidence interval and one-sided permutation p-value.
+* ``success_rate``   share of mineralised area captured when the AOI is ranked by score
+                     (Agterberg & Bonham-Carter 2005 style success-rate curve).
+* ``target_hits``    how many ranked targets fall within a distance of a lode, versus the number
+                     expected if the same number of points were placed at random in the AOI.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from scipy.stats import rankdata
+
+
+def auc(pos: np.ndarray, neg: np.ndarray) -> float:
+    pos, neg = pos[np.isfinite(pos)], neg[np.isfinite(neg)]
+    if not pos.size or not neg.size:
+        return np.nan
+    r = rankdata(np.concatenate([pos, neg]))
+    return float((r[:pos.size].sum() - pos.size * (pos.size + 1) / 2) / (pos.size * neg.size))
+
+
+def bootstrap_auc(pos: np.ndarray, neg: np.ndarray, n: int = 2000, seed: int = 0) -> dict:
+    pos, neg = pos[np.isfinite(pos)], neg[np.isfinite(neg)]
+    rng = np.random.default_rng(seed)
+    a = auc(pos, neg)
+    boots = [auc(rng.choice(pos, pos.size), rng.choice(neg, neg.size)) for _ in range(n)]
+    allv = np.concatenate([pos, neg])
+    perm = []
+    for _ in range(n):
+        s = rng.permutation(allv)
+        perm.append(auc(s[:pos.size], s[pos.size:]))
+    return {"auc": round(a, 3), "ci_low": round(float(np.nanpercentile(boots, 2.5)), 3),
+            "ci_high": round(float(np.nanpercentile(boots, 97.5)), 3),
+            "p_value": round(float((np.sum(np.array(perm) >= a) + 1) / (n + 1)), 4),
+            "n_pos": int(pos.size), "n_neg": int(neg.size)}
+
+
+def success_rate(score: np.ndarray, positive: np.ndarray, valid: np.ndarray) -> pd.DataFrame:
+    """Cumulative share of positive cells vs share of AOI area, ranking cells by score (high first)."""
+    s, p = score[valid], positive[valid]
+    ok = np.isfinite(s)
+    s, p = s[ok], p[ok]
+    order = np.argsort(-s, kind="stable")
+    cum_pos = np.cumsum(p[order]) / max(p.sum(), 1)
+    area = np.arange(1, s.size + 1) / s.size
+    return pd.DataFrame({"area_fraction": area, "captured_fraction": cum_pos})
+
+
+def captured_at(curve: pd.DataFrame, fractions=(0.1, 0.2, 0.3)) -> dict:
+    return {f"captured_top{int(100 * f)}pct": round(float(np.interp(f, curve["area_fraction"],
+                                                                     curve["captured_fraction"])), 3)
+            for f in fractions}
+
+
+def target_hits(target_xy: np.ndarray, lodes_utm, aoi_utm, radii=(100.0, 200.0)) -> dict:
+    from shapely.geometry import Point
+    union = lodes_utm.union_all() if hasattr(lodes_utm, "union_all") else lodes_utm.unary_union
+    out = {"n_targets": int(len(target_xy))}
+    if not len(target_xy):
+        return out
+    d = np.array([union.distance(Point(x, y)) for x, y in target_xy])
+    out["median_distance_to_lode_m"] = round(float(np.median(d)), 1)
+    for r in radii:
+        frac_area = union.buffer(r).intersection(aoi_utm).area / aoi_utm.area
+        out[f"hits_within_{int(r)}m"] = int((d <= r).sum())
+        out[f"expected_random_{int(r)}m"] = round(float(frac_area * len(target_xy)), 1)
+    return out
+
+
+def zone_capture(zone_masks: dict[str, np.ndarray], truth: np.ndarray, inside: np.ndarray) -> pd.DataFrame:
+    """How much of the ground truth falls inside each set of zones, against the area the zones cover.
+
+    zone_masks: label -> boolean raster (e.g. "Tier 1 zones", "Tier 1 + 2 zones", ...).
+    enrichment = share of truth captured / share of the block covered (1.0 = no better than chance).
+    """
+    n_in, n_truth = int(inside.sum()), int((truth & inside).sum())
+    rows = []
+    for name, m in zone_masks.items():
+        m = m & inside
+        area, cap = m.sum() / max(n_in, 1), (m & truth).sum() / max(n_truth, 1)
+        rows.append({"zones": name, "pct_of_block": round(100 * float(area), 1),
+                     "pct_of_truth_captured": round(100 * float(cap), 1),
+                     "enrichment": round(float(cap / area), 1) if area > 0 else None})
+    return pd.DataFrame(rows)

geoscan/geoscan/webapp/catalog.py

@@ -45,22 +45,22 @@ def _p(key, label, group, step, tag, lo, hi, inc, unit="", help_="", kind="float
 
 # Adjustable parameters (numbers the method chose; tags as in the methodology).
 PARAMS = dict([
-    _p("targets.w_muscovite", "Weight: muscovite", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01,
+    _p("targets.w_muscovite", "Weight: muscovite", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01,
        help_="H = w_musc·musc + w_qtz·qtz + w_goss·goss + w_chl·chl. The four weights must add up to 1."),
-    _p("targets.w_quartz", "Weight: quartz", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.w_gossan", "Weight: gossan", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.w_chlorite", "Weight: chlorite", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.w_structure", "Structure share of CPI", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01,
+    _p("targets.w_quartz", "Weight: quartz", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.w_gossan", "Weight: gossan", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.w_chlorite", "Weight: chlorite", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.w_structure", "Structure share of CPI", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01,
        help_="CPI = (1 − s)·H + s·exp(−d/λ). s = 0.30 by default."),
-    _p("targets.structure_lambda_m", "Structural decay distance λ", "CPI and drill targets", "targets", "EXP",
+    _p("targets.structure_lambda_m", "Structural decay distance λ", "CPI, zones and field-check locations", "targets", "EXP",
        50, 2000, 10, "m", "Distance over which the structural score falls to 37 %."),
-    _p("targets.tier1", "Tier 1 threshold (CPI)", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.tier2", "Tier 2 threshold (CPI)", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.tier3", "Tier 3 threshold (CPI)", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.min_cpi", "Minimum CPI for a target", "CPI and drill targets", "targets", "EXP", 0, 1, 0.01),
-    _p("targets.min_spacing_m", "Minimum spacing between targets", "CPI and drill targets", "targets", "ASM",
+    _p("targets.tier1", "Tier 1 threshold (CPI)", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.tier2", "Tier 2 threshold = zone boundary (CPI)", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.tier3", "Tier 3 threshold (CPI)", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.min_cpi", "Minimum CPI for a field-check location", "CPI, zones and field-check locations", "targets", "EXP", 0, 1, 0.01),
+    _p("targets.min_spacing_m", "Minimum spacing between field-check locations", "CPI, zones and field-check locations", "targets", "ASM",
        30, 2000, 10, "m"),
-    _p("targets.n_targets", "Maximum number of targets", "CPI and drill targets", "targets", "ASM", 1, 200, 1,
+    _p("targets.n_targets", "Maximum number of field-check locations", "CPI, zones and field-check locations", "targets", "ASM", 1, 200, 1,
        kind="int"),
     _p("alteration.sigma_core_m", "Core kernel σ", "Alteration layers", "alteration", "EXP", 30, 500, 5, "m",
        "Gaussian kernel for the vent/core part of the potential field."),

geoscan/geoscan/webapp/exports.py

@@ -18,7 +18,7 @@ import pandas as pd
 from ..raster_io import read_raster, write_raster
 from . import catalog, geophysics, layers
 
-MAPS = {"cpi_target_map.png": "CPI target map with ranked targets",
+MAPS = {"cpi_target_map.png": "CPI map: prospective zones and suggested field-check locations",
         "alteration_muscovite_map.png": "Muscovite / sericite (phyllic) contour map",
         "alteration_chlorite_map.png": "Chlorite / epidote (propylitic) contour map",
         "alteration_gossan_map.png": "Gossan / iron oxide contour map",
@@ -36,11 +36,15 @@ RASTERS = {"targets/cpi.tif": "CPI, hydrothermal index, structural proximity",
            "terrain/dem.tif": "Elevation (m)", "terrain/hillshade.tif": "Hillshade", "terrain/slope.tif": "Slope (°)",
            "aster_ged/tir_indices.tif": "ASTER GED thermal indices"}
 DROP_BANDS = {"data_support", "ged_ndvi", "ged_num_obs"}
-TABLES = {"top50_targets.csv": "Ranked drill targets", "alteration_summary.csv": "Alteration layers and zone areas",
+TABLES = {"prospective_zones.csv": "Prospective zones, ranked (the main result)",
+          "field_check_locations.csv": "Suggested field-check locations (starting points, not drill collars)",
+          "top50_targets.csv": "Ranked locations (earlier naming)", "alteration_summary.csv": "Alteration layers and zone areas",
           "lineaments.csv": "Lineament attributes", "lineament_rose.csv": "Lineament strike histogram",
           "aster_ged_index_summary.csv": "ASTER GED index statistics"}
-VECTOR_LABELS = {"top50_targets.geojson": "Ranked drill targets (points)",
-                 "cpi_target_zones.geojson": "CPI target zones (polygons)",
+VECTOR_LABELS = {"prospective_zones.geojson": "Prospective zones, ranked (polygons, the main result)",
+                 "field_check_locations.geojson": "Suggested field-check locations (points)",
+                 "top50_targets.geojson": "Ranked locations (points, earlier naming)",
+                 "cpi_target_zones.geojson": "CPI tier bands (polygons)",
                  "lineaments.geojson": "Lineaments (lines)", "aoi.geojson": "Area of interest",
                  "alteration_muscovite_zones.geojson": "Muscovite zones (polygons)",
                  "alteration_chlorite_zones.geojson": "Chlorite zones (polygons)",

geoscan/geoscan/webapp/geophysics.py

@@ -1,295 +1,295 @@
-"""Reference geophysics layers (view and download only; never used in the CPI or target ranking).
-
-Source: GSI Bhukosh ground gravity / magnetic station exports placed in
-    data/<area>/ground_truth/bhukosh/GRAVITY_CLIP/   (field bouguer_an, mGal)
-    data/<area>/ground_truth/bhukosh/MAGNETIC_CLIP/  (field magnetic_a, nT)
-
-For each layer: the stations (duplicates removed), and - when there are enough stations - a surface
-interpolated between them (thin-plate spline), masked where no station is near, with contour lines.
-The surface is an interpolation of sparse points (stations are typically ~1 km apart): it shows the
-regional pattern only and must not be read at target scale.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import geopandas as gpd
-import numpy as np
-from matplotlib import colormaps
-from PIL import Image
-from rasterio.features import rasterize
-from scipy.interpolate import RBFInterpolator
-from scipy.spatial import cKDTree
-from shapely.geometry import LineString, MultiLineString
-from shapely.ops import unary_union
-from skimage.measure import find_contours
-
-from ..aoi import load_aoi
-from ..grid import Grid, grid_for_aoi
-from ..raster_io import write_raster
-from . import catalog
-from .layers import _to_mercator
-from rasterio.warp import Resampling
-
-LAYERS = {
-    "magnetic": {"folder": "MAGNETIC_CLIP", "field": "magnetic_a", "label": "Magnetic anomaly (ground stations)",
-                 "unit": "nT", "cmap": "RdBu_r", "diverging": True,
-                 "extra": {"observed_m": "observed_total_field_nT", "igrf_nt": "igrf_nT"},
-                 "what": "Ground magnetic anomaly: the measured total field minus the Earth's reference field (IGRF). "
-                         "Highs mark magnetite-rich rock (mafic units); lows can mark non-magnetic rock or zones where "
-                         "fluids destroyed magnetite."},
-    "gravity": {"folder": "GRAVITY_CLIP", "field": "bouguer_an", "label": "Bouguer gravity anomaly (ground stations)",
-                "unit": "mGal", "cmap": "viridis", "diverging": False,
-                "extra": {"elevation_": "elevation_m", "observed_g": "observed_gravity_mGal",
-                          "theoretica": "theoretical_gravity_mGal"},
-                "what": "Bouguer gravity anomaly: gravity corrected for latitude, height and terrain mass. "
-                        "Highs mark denser rock (mafic units, massive sulphide); lows mark lighter rock (granite, cover)."},
-}
-SOURCE = "Geological Survey of India, Bhukosh portal (ground gravity / magnetic stations)"
-CAVEAT = ("Reference only: not used in the CPI or the target ranking. The surface and contours are interpolated "
-          "between sparse stations and show the regional pattern only.")
-MIN_STATIONS_FOR_SURFACE = 6
-GRID_RES_M = 60.0
-
-
-def _dir(block: str, key: str) -> Path:
-    return catalog.DATA / block / "ground_truth" / "bhukosh" / LAYERS[key]["folder"]
-
-
-def _cache(block: str) -> Path:
-    p = catalog.OUTPUTS / "_reference_cache" / block
-    p.mkdir(parents=True, exist_ok=True)
-    return p
-
-
-def _aoi(block: str):
-    aoi = load_aoi(catalog.DATA / block / "aoi" / "aoi.geojson", block)
-    return aoi, grid_for_aoi(aoi, GRID_RES_M, 180.0)
-
-
-def stations(block: str, key: str) -> gpd.GeoDataFrame | None:
-    """Stations in the area's UTM zone, exact duplicates (within 10 m) removed, tidy column names."""
-    d = _dir(block, key)
-    if not d.exists() or not any(d.glob("*.shp")):
-        return None
-    spec = LAYERS[key]
-    aoi, grid = _aoi(block)
-    g = gpd.read_file(d).to_crs(grid.crs)
-    g = g[np.isfinite(g[spec["field"]].astype(float))].reset_index(drop=True)
-    if len(g) == 0:
-        return None
-    xy = np.c_[g.geometry.x, g.geometry.y]
-    tree, keep = cKDTree(xy), np.ones(len(g), bool)
-    for i in range(len(g)):
-        if keep[i]:
-            for j in tree.query_ball_point(xy[i], 10.0):
-                if j > i:
-                    keep[j] = False
-    g = g[keep].reset_index(drop=True)
-    out = gpd.GeoDataFrame({"station": np.arange(1, len(g) + 1), "value": g[spec["field"]].astype(float).round(3),
-                            "unit": spec["unit"]}, geometry=g.geometry, crs=grid.crs)
-    for src, name in spec["extra"].items():
-        if src in g:
-            out[name] = g[src].astype(float).round(3)
-    ll = out.geometry.to_crs(4326)
-    out["longitude"], out["latitude"] = ll.x.round(6), ll.y.round(6)
-    out["inside_area"] = out.within(aoi.to_crs(grid.crs))
-    return out
-
-
-def _spacing(g: gpd.GeoDataFrame) -> float:
-    xy = np.c_[g.geometry.x, g.geometry.y]
-    if len(xy) < 2:
-        return float("nan")
-    return float(np.median(cKDTree(xy).query(xy, 2)[0][:, 1]))
-
-
-def surface(block: str, key: str):
-    """Interpolated surface on a 60 m grid (NaN outside the area or far from any station), or (None, grid)."""
-    g = stations(block, key)
-    aoi, grid = _aoi(block)
-    if g is None or len(g) < MIN_STATIONS_FOR_SURFACE:
-        return None, grid
-    xy = np.c_[g.geometry.x, g.geometry.y]
-    xs = grid.x0 + (np.arange(grid.width) + 0.5) * grid.res
-    ys = grid.y0 - (np.arange(grid.height) + 0.5) * grid.res
-    X, Y = np.meshgrid(xs, ys)
-    pts = np.c_[X.ravel(), Y.ravel()]
-    centre, scale = xy.mean(0), float(xy.std(0).mean())      # spread of the stations (east and north separately)
-    rbf = RBFInterpolator((xy - centre) / scale, g["value"].values, kernel="thin_plate_spline", smoothing=1e-3)
-    z = rbf((pts - centre) / scale).reshape(grid.shape)
-    near = cKDTree(xy).query(pts)[0].reshape(grid.shape) <= 1.5 * _spacing(g)
-    inside = rasterize([(aoi.to_crs(grid.crs), 1)], out_shape=grid.shape, transform=grid.transform).astype(bool)
-    lo, hi = g["value"].min(), g["value"].max()
-    z = np.clip(z, lo - 0.1 * (hi - lo), hi + 0.1 * (hi - lo))      # no wild overshoot between stations
-    return np.where(near & inside, z, np.nan).astype("float32"), grid
-
-
-def _colour_range(g: gpd.GeoDataFrame) -> tuple[float, float]:
-    """Colour limits: the 2nd-98th percentile of the station values (relative lows to relative highs)."""
-    lo, hi = np.percentile(g["value"], [2, 98]) if len(g) >= 10 else (g["value"].min(), g["value"].max())
-    if hi <= lo:
-        lo, hi = lo - 1.0, hi + 1.0
-    return float(lo), float(hi)
-
-
-def _nice_step(span: float, target: int = 9) -> float:
-    raw = span / max(target, 1)
-    mag = 10 ** np.floor(np.log10(raw)) if raw > 0 else 1.0
-    return float(min((1, 2, 2.5, 5, 10), key=lambda m: abs(m * mag - raw)) * mag)
-
-
-def _levels(z: np.ndarray) -> list[float]:
-    lo, hi = float(np.nanmin(z)), float(np.nanmax(z))
-    if hi <= lo:
-        return []
-    step = _nice_step(hi - lo)
-    return [round(v, 6) for v in np.arange(np.ceil(lo / step) * step, hi, step)]
-
-
-def contours(block: str, key: str) -> gpd.GeoDataFrame | None:
-    z, grid = surface(block, key)
-    if z is None:
-        return None
-    filled = np.where(np.isfinite(z), z, np.nanmin(z) - 1e6)      # contours stop at the masked edge
-    recs, geoms = [], []
-    for lev in _levels(z):
-        lines = []
-        for path in find_contours(filled, lev):
-            ok = np.isfinite(z[np.clip(path[:, 0].round().astype(int), 0, grid.height - 1),
-                               np.clip(path[:, 1].round().astype(int), 0, grid.width - 1)])
-            xs = grid.x0 + (path[:, 1] + 0.5) * grid.res
-            ys = grid.y0 - (path[:, 0] + 0.5) * grid.res
-            seg = []
-            for x, y, k in zip(xs, ys, ok):
-                if k:
-                    seg.append((x, y))
-                else:
-                    if len(seg) > 2:
-                        lines.append(LineString(seg))
-                    seg = []
-            if len(seg) > 2:
-                lines.append(LineString(seg))
-        if lines:
-            m = unary_union(lines).simplify(grid.res / 3)
-            geoms.append(m if isinstance(m, (LineString, MultiLineString)) else MultiLineString(
-                [x for x in getattr(m, "geoms", []) if isinstance(x, LineString)]))
-            recs.append({"layer": key, "level": lev, "unit": LAYERS[key]["unit"]})
-    return gpd.GeoDataFrame(recs, geometry=geoms, crs=grid.crs) if recs else None
-
-
-def info(block: str) -> list[dict]:
-    """Layers available for an area, with the facts a reader needs to judge them."""
-    out = []
-    for key, spec in LAYERS.items():
-        g = stations(block, key)
-        if g is None:
-            continue
-        sp = _spacing(g)
-        out.append({"key": key, "label": spec["label"], "unit": spec["unit"], "stations": int(len(g)),
-                    "stations_inside": int(g["inside_area"].sum()),
-                    "spacing_m": None if np.isnan(sp) else round(sp),
-                    "min": float(g["value"].min()), "max": float(g["value"].max()),
-                    "has_surface": len(g) >= MIN_STATIONS_FOR_SURFACE, "what": spec["what"],
-                    "source": SOURCE, "caveat": CAVEAT})
-    return out
-
-
-def overlay(block: str, key: str) -> dict:
-    """Coloured surface PNG (EPSG:3857) + bounds + legend for the web map; {'none': True} without a surface."""
-    c = _cache(block)
-    png, meta = c / f"{key}.png", c / f"{key}.json"
-    src = next(_dir(block, key).glob("*.shp"))
-    if png.exists() and meta.exists() and png.stat().st_mtime >= src.stat().st_mtime:
-        return json.loads(meta.read_text())
-    spec = LAYERS[key]
-    z, grid = surface(block, key)
-    g = stations(block, key)
-    lo, hi = _colour_range(g)
-    stops = [colormaps[spec["cmap"]](t) for t in np.linspace(0, 1, 9)]
-    legend = {"label": spec["label"], "unit": spec["unit"], "min": round(lo, 1), "max": round(hi, 1), "kind": "ramp",
-              "colors": ["#%02x%02x%02x" % tuple(int(255 * v) for v in s[:3]) for s in stops],
-              "levels": [], "reference": True}
-    if z is None:
-        info_ = {"none": True, "bounds": None, "legend": legend}
-        png.write_bytes(b"")
-    else:
-        arr, bounds = _to_mercator(z, grid, 4, Resampling.bilinear)
-        x = np.clip((arr - lo) / (hi - lo + 1e-12), 0, 1)
-        rgba = (colormaps[spec["cmap"]](np.nan_to_num(x)) * 255).astype("uint8")
-        rgba[..., 3] = np.where(np.isfinite(arr), 205, 0)
-        Image.fromarray(rgba, "RGBA").save(png)
-        legend["contour_step"] = _nice_step(float(np.nanmax(z) - np.nanmin(z)))
-        info_ = {"bounds": bounds, "legend": legend}
-    meta.write_text(json.dumps(info_))
-    return info_
-
-
-def figure(block: str, key: str) -> Path:
-    """Publication-style PNG: surface, labelled contours and stations with their values."""
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-    from matplotlib.ticker import MaxNLocator
-    from pyproj import Transformer
-    out = _cache(block) / f"reference_{key}_map.png"
-    src = next(_dir(block, key).glob("*.shp"))
-    if out.exists() and out.stat().st_mtime >= src.stat().st_mtime:
-        return out
-    spec = LAYERS[key]
-    g = stations(block, key)
-    z, grid = surface(block, key)
-    aoi, _ = _aoi(block)
-    ov = overlay(block, key)["legend"]
-    fig, ax = plt.subplots(figsize=(11, 8), dpi=170)
-    if z is not None:
-        ll = Transformer.from_crs(grid.crs, 4326, always_xy=True)
-        xs = grid.x0 + (np.arange(grid.width) + 0.5) * grid.res
-        ys = grid.y0 - (np.arange(grid.height) + 0.5) * grid.res
-        LON, LAT = ll.transform(*np.meshgrid(xs, ys))
-        cf = ax.contourf(LON, LAT, z, levels=np.linspace(ov["min"], ov["max"], 41), cmap=spec["cmap"], extend="both")
-        lv = _levels(z)
-        if lv:
-            cs = ax.contour(LON, LAT, z, levels=lv, colors="black", linewidths=0.6)
-            ax.clabel(cs, fmt="%g", fontsize=7)
-        fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.08, shrink=0.6, ticks=MaxNLocator(8),
-                     label=f"{spec['label']} ({spec['unit']})")
-    sc = ax.scatter(g["longitude"], g["latitude"], c=g["value"], cmap=spec["cmap"], vmin=ov["min"], vmax=ov["max"],
-                    s=46, edgecolors="black", linewidths=0.8, zorder=5)
-    if z is None:
-        fig.colorbar(sc, ax=ax, orientation="horizontal", pad=0.08, shrink=0.6, ticks=MaxNLocator(8),
-                     label=f"{spec['label']} ({spec['unit']})")
-    span = float(g["value"].max() - g["value"].min())
-    for _, r in g.iterrows():
-        ax.annotate(f"{r['value']:.0f}" if span >= 50 else f"{r['value']:g}", (r["longitude"], r["latitude"]), xytext=(4, 4), textcoords="offset points", fontsize=6.5)
-    x, y = aoi.geometry.exterior.xy
-    ax.plot(x, y, color="black", lw=1.6)
-    ax.set_aspect(1 / np.cos(np.radians(np.mean(y))))
-    ax.ticklabel_format(useOffset=False, style="plain")
-    ax.set_xlabel("Longitude (°E)")
-    ax.set_ylabel("Latitude (°N)")
-    sp = _spacing(g)
-    ax.set_title(f"{block.capitalize()}: {spec['label']}\n"
-                 f"{len(g)} stations" + ("" if np.isnan(sp) else f", about {sp / 1000:.1f} km apart") +
-                 (" · surface interpolated between stations" if z is not None else " · too few stations for a surface") +
-                 "\nReference only: not used in the CPI or the target ranking", fontsize=10, fontweight="bold")
-    fig.text(0.01, 0.01, f"Source: {SOURCE}", fontsize=6.5, color="#555")
-    fig.tight_layout()
-    fig.savefig(out, bbox_inches="tight")
-    plt.close(fig)
-    return out
-
-
-def raster_file(block: str, key: str, path: Path) -> bool:
-    """Write the interpolated surface as a GeoTIFF (UTM). Returns False when there is no surface."""
-    z, grid = surface(block, key)
-    if z is None:
-        return False
-    g = stations(block, key)
-    write_raster(path, z[None], grid, [f"{key}_{LAYERS[key]['unit']}"],
-                 tags={"source": SOURCE, "stations": len(g), "median_station_spacing_m": round(_spacing(g)),
-                       "method": "thin-plate-spline interpolation of ground stations; masked beyond 1.5 x spacing",
-                       "note": CAVEAT})
-    return True
+"""Reference geophysics layers (view and download only; never used in the CPI or the zone ranking).
+
+Source: GSI Bhukosh ground gravity / magnetic station exports placed in
+    data/<area>/ground_truth/bhukosh/GRAVITY_CLIP/   (field bouguer_an, mGal)
+    data/<area>/ground_truth/bhukosh/MAGNETIC_CLIP/  (field magnetic_a, nT)
+
+For each layer: the stations (duplicates removed), and - when there are enough stations - a surface
+interpolated between them (thin-plate spline), masked where no station is near, with contour lines.
+The surface is an interpolation of sparse points (stations are typically ~1 km apart): it shows the
+regional pattern only and must not be read at the scale of a single zone.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import geopandas as gpd
+import numpy as np
+from matplotlib import colormaps
+from PIL import Image
+from rasterio.features import rasterize
+from scipy.interpolate import RBFInterpolator
+from scipy.spatial import cKDTree
+from shapely.geometry import LineString, MultiLineString
+from shapely.ops import unary_union
+from skimage.measure import find_contours
+
+from ..aoi import load_aoi
+from ..grid import Grid, grid_for_aoi
+from ..raster_io import write_raster
+from . import catalog
+from .layers import _to_mercator
+from rasterio.warp import Resampling
+
+LAYERS = {
+    "magnetic": {"folder": "MAGNETIC_CLIP", "field": "magnetic_a", "label": "Magnetic anomaly (ground stations)",
+                 "unit": "nT", "cmap": "RdBu_r", "diverging": True,
+                 "extra": {"observed_m": "observed_total_field_nT", "igrf_nt": "igrf_nT"},
+                 "what": "Ground magnetic anomaly: the measured total field minus the Earth's reference field (IGRF). "
+                         "Highs mark magnetite-rich rock (mafic units); lows can mark non-magnetic rock or zones where "
+                         "fluids destroyed magnetite."},
+    "gravity": {"folder": "GRAVITY_CLIP", "field": "bouguer_an", "label": "Bouguer gravity anomaly (ground stations)",
+                "unit": "mGal", "cmap": "viridis", "diverging": False,
+                "extra": {"elevation_": "elevation_m", "observed_g": "observed_gravity_mGal",
+                          "theoretica": "theoretical_gravity_mGal"},
+                "what": "Bouguer gravity anomaly: gravity corrected for latitude, height and terrain mass. "
+                        "Highs mark denser rock (mafic units, massive sulphide); lows mark lighter rock (granite, cover)."},
+}
+SOURCE = "Geological Survey of India, Bhukosh portal (ground gravity / magnetic stations)"
+CAVEAT = ("Reference only: not used in the CPI or the zone ranking. The surface and contours are interpolated "
+          "between sparse stations and show the regional pattern only.")
+MIN_STATIONS_FOR_SURFACE = 6
+GRID_RES_M = 60.0
+
+
+def _dir(block: str, key: str) -> Path:
+    return catalog.DATA / block / "ground_truth" / "bhukosh" / LAYERS[key]["folder"]
+
+
+def _cache(block: str) -> Path:
+    p = catalog.OUTPUTS / "_reference_cache" / block
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def _aoi(block: str):
+    aoi = load_aoi(catalog.DATA / block / "aoi" / "aoi.geojson", block)
+    return aoi, grid_for_aoi(aoi, GRID_RES_M, 180.0)
+
+
+def stations(block: str, key: str) -> gpd.GeoDataFrame | None:
+    """Stations in the area's UTM zone, exact duplicates (within 10 m) removed, tidy column names."""
+    d = _dir(block, key)
+    if not d.exists() or not any(d.glob("*.shp")):
+        return None
+    spec = LAYERS[key]
+    aoi, grid = _aoi(block)
+    g = gpd.read_file(d).to_crs(grid.crs)
+    g = g[np.isfinite(g[spec["field"]].astype(float))].reset_index(drop=True)
+    if len(g) == 0:
+        return None
+    xy = np.c_[g.geometry.x, g.geometry.y]
+    tree, keep = cKDTree(xy), np.ones(len(g), bool)
+    for i in range(len(g)):
+        if keep[i]:
+            for j in tree.query_ball_point(xy[i], 10.0):
+                if j > i:
+                    keep[j] = False
+    g = g[keep].reset_index(drop=True)
+    out = gpd.GeoDataFrame({"station": np.arange(1, len(g) + 1), "value": g[spec["field"]].astype(float).round(3),
+                            "unit": spec["unit"]}, geometry=g.geometry, crs=grid.crs)
+    for src, name in spec["extra"].items():
+        if src in g:
+            out[name] = g[src].astype(float).round(3)
+    ll = out.geometry.to_crs(4326)
+    out["longitude"], out["latitude"] = ll.x.round(6), ll.y.round(6)
+    out["inside_area"] = out.within(aoi.to_crs(grid.crs))
+    return out
+
+
+def _spacing(g: gpd.GeoDataFrame) -> float:
+    xy = np.c_[g.geometry.x, g.geometry.y]
+    if len(xy) < 2:
+        return float("nan")
+    return float(np.median(cKDTree(xy).query(xy, 2)[0][:, 1]))
+
+
+def surface(block: str, key: str):
+    """Interpolated surface on a 60 m grid (NaN outside the area or far from any station), or (None, grid)."""
+    g = stations(block, key)
+    aoi, grid = _aoi(block)
+    if g is None or len(g) < MIN_STATIONS_FOR_SURFACE:
+        return None, grid
+    xy = np.c_[g.geometry.x, g.geometry.y]
+    xs = grid.x0 + (np.arange(grid.width) + 0.5) * grid.res
+    ys = grid.y0 - (np.arange(grid.height) + 0.5) * grid.res
+    X, Y = np.meshgrid(xs, ys)
+    pts = np.c_[X.ravel(), Y.ravel()]
+    centre, scale = xy.mean(0), float(xy.std(0).mean())      # spread of the stations (east and north separately)
+    rbf = RBFInterpolator((xy - centre) / scale, g["value"].values, kernel="thin_plate_spline", smoothing=1e-3)
+    z = rbf((pts - centre) / scale).reshape(grid.shape)
+    near = cKDTree(xy).query(pts)[0].reshape(grid.shape) <= 1.5 * _spacing(g)
+    inside = rasterize([(aoi.to_crs(grid.crs), 1)], out_shape=grid.shape, transform=grid.transform).astype(bool)
+    lo, hi = g["value"].min(), g["value"].max()
+    z = np.clip(z, lo - 0.1 * (hi - lo), hi + 0.1 * (hi - lo))      # no wild overshoot between stations
+    return np.where(near & inside, z, np.nan).astype("float32"), grid
+
+
+def _colour_range(g: gpd.GeoDataFrame) -> tuple[float, float]:
+    """Colour limits: the 2nd-98th percentile of the station values (relative lows to relative highs)."""
+    lo, hi = np.percentile(g["value"], [2, 98]) if len(g) >= 10 else (g["value"].min(), g["value"].max())
+    if hi <= lo:
+        lo, hi = lo - 1.0, hi + 1.0
+    return float(lo), float(hi)
+
+
+def _nice_step(span: float, target: int = 9) -> float:
+    raw = span / max(target, 1)
+    mag = 10 ** np.floor(np.log10(raw)) if raw > 0 else 1.0
+    return float(min((1, 2, 2.5, 5, 10), key=lambda m: abs(m * mag - raw)) * mag)
+
+
+def _levels(z: np.ndarray) -> list[float]:
+    lo, hi = float(np.nanmin(z)), float(np.nanmax(z))
+    if hi <= lo:
+        return []
+    step = _nice_step(hi - lo)
+    return [round(v, 6) for v in np.arange(np.ceil(lo / step) * step, hi, step)]
+
+
+def contours(block: str, key: str) -> gpd.GeoDataFrame | None:
+    z, grid = surface(block, key)
+    if z is None:
+        return None
+    filled = np.where(np.isfinite(z), z, np.nanmin(z) - 1e6)      # contours stop at the masked edge
+    recs, geoms = [], []
+    for lev in _levels(z):
+        lines = []
+        for path in find_contours(filled, lev):
+            ok = np.isfinite(z[np.clip(path[:, 0].round().astype(int), 0, grid.height - 1),
+                               np.clip(path[:, 1].round().astype(int), 0, grid.width - 1)])
+            xs = grid.x0 + (path[:, 1] + 0.5) * grid.res
+            ys = grid.y0 - (path[:, 0] + 0.5) * grid.res
+            seg = []
+            for x, y, k in zip(xs, ys, ok):
+                if k:
+                    seg.append((x, y))
+                else:
+                    if len(seg) > 2:
+                        lines.append(LineString(seg))
+                    seg = []
+            if len(seg) > 2:
+                lines.append(LineString(seg))
+        if lines:
+            m = unary_union(lines).simplify(grid.res / 3)
+            geoms.append(m if isinstance(m, (LineString, MultiLineString)) else MultiLineString(
+                [x for x in getattr(m, "geoms", []) if isinstance(x, LineString)]))
+            recs.append({"layer": key, "level": lev, "unit": LAYERS[key]["unit"]})
+    return gpd.GeoDataFrame(recs, geometry=geoms, crs=grid.crs) if recs else None
+
+
+def info(block: str) -> list[dict]:
+    """Layers available for an area, with the facts a reader needs to judge them."""
+    out = []
+    for key, spec in LAYERS.items():
+        g = stations(block, key)
+        if g is None:
+            continue
+        sp = _spacing(g)
+        out.append({"key": key, "label": spec["label"], "unit": spec["unit"], "stations": int(len(g)),
+                    "stations_inside": int(g["inside_area"].sum()),
+                    "spacing_m": None if np.isnan(sp) else round(sp),
+                    "min": float(g["value"].min()), "max": float(g["value"].max()),
+                    "has_surface": len(g) >= MIN_STATIONS_FOR_SURFACE, "what": spec["what"],
+                    "source": SOURCE, "caveat": CAVEAT})
+    return out
+
+
+def overlay(block: str, key: str) -> dict:
+    """Coloured surface PNG (EPSG:3857) + bounds + legend for the web map; {'none': True} without a surface."""
+    c = _cache(block)
+    png, meta = c / f"{key}.png", c / f"{key}.json"
+    src = next(_dir(block, key).glob("*.shp"))
+    if png.exists() and meta.exists() and png.stat().st_mtime >= src.stat().st_mtime:
+        return json.loads(meta.read_text())
+    spec = LAYERS[key]
+    z, grid = surface(block, key)
+    g = stations(block, key)
+    lo, hi = _colour_range(g)
+    stops = [colormaps[spec["cmap"]](t) for t in np.linspace(0, 1, 9)]
+    legend = {"label": spec["label"], "unit": spec["unit"], "min": round(lo, 1), "max": round(hi, 1), "kind": "ramp",
+              "colors": ["#%02x%02x%02x" % tuple(int(255 * v) for v in s[:3]) for s in stops],
+              "levels": [], "reference": True}
+    if z is None:
+        info_ = {"none": True, "bounds": None, "legend": legend}
+        png.write_bytes(b"")
+    else:
+        arr, bounds = _to_mercator(z, grid, 4, Resampling.bilinear)
+        x = np.clip((arr - lo) / (hi - lo + 1e-12), 0, 1)
+        rgba = (colormaps[spec["cmap"]](np.nan_to_num(x)) * 255).astype("uint8")
+        rgba[..., 3] = np.where(np.isfinite(arr), 205, 0)
+        Image.fromarray(rgba, "RGBA").save(png)
+        legend["contour_step"] = _nice_step(float(np.nanmax(z) - np.nanmin(z)))
+        info_ = {"bounds": bounds, "legend": legend}
+    meta.write_text(json.dumps(info_))
+    return info_
+
+
+def figure(block: str, key: str) -> Path:
+    """Publication-style PNG: surface, labelled contours and stations with their values."""
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from matplotlib.ticker import MaxNLocator
+    from pyproj import Transformer
+    out = _cache(block) / f"reference_{key}_map.png"
+    src = next(_dir(block, key).glob("*.shp"))
+    if out.exists() and out.stat().st_mtime >= src.stat().st_mtime:
+        return out
+    spec = LAYERS[key]
+    g = stations(block, key)
+    z, grid = surface(block, key)
+    aoi, _ = _aoi(block)
+    ov = overlay(block, key)["legend"]
+    fig, ax = plt.subplots(figsize=(11, 8), dpi=170)
+    if z is not None:
+        ll = Transformer.from_crs(grid.crs, 4326, always_xy=True)
+        xs = grid.x0 + (np.arange(grid.width) + 0.5) * grid.res
+        ys = grid.y0 - (np.arange(grid.height) + 0.5) * grid.res
+        LON, LAT = ll.transform(*np.meshgrid(xs, ys))
+        cf = ax.contourf(LON, LAT, z, levels=np.linspace(ov["min"], ov["max"], 41), cmap=spec["cmap"], extend="both")
+        lv = _levels(z)
+        if lv:
+            cs = ax.contour(LON, LAT, z, levels=lv, colors="black", linewidths=0.6)
+            ax.clabel(cs, fmt="%g", fontsize=7)
+        fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.08, shrink=0.6, ticks=MaxNLocator(8),
+                     label=f"{spec['label']} ({spec['unit']})")
+    sc = ax.scatter(g["longitude"], g["latitude"], c=g["value"], cmap=spec["cmap"], vmin=ov["min"], vmax=ov["max"],
+                    s=46, edgecolors="black", linewidths=0.8, zorder=5)
+    if z is None:
+        fig.colorbar(sc, ax=ax, orientation="horizontal", pad=0.08, shrink=0.6, ticks=MaxNLocator(8),
+                     label=f"{spec['label']} ({spec['unit']})")
+    span = float(g["value"].max() - g["value"].min())
+    for _, r in g.iterrows():
+        ax.annotate(f"{r['value']:.0f}" if span >= 50 else f"{r['value']:g}", (r["longitude"], r["latitude"]), xytext=(4, 4), textcoords="offset points", fontsize=6.5)
+    x, y = aoi.geometry.exterior.xy
+    ax.plot(x, y, color="black", lw=1.6)
+    ax.set_aspect(1 / np.cos(np.radians(np.mean(y))))
+    ax.ticklabel_format(useOffset=False, style="plain")
+    ax.set_xlabel("Longitude (°E)")
+    ax.set_ylabel("Latitude (°N)")
+    sp = _spacing(g)
+    ax.set_title(f"{block.capitalize()}: {spec['label']}\n"
+                 f"{len(g)} stations" + ("" if np.isnan(sp) else f", about {sp / 1000:.1f} km apart") +
+                 (" · surface interpolated between stations" if z is not None else " · too few stations for a surface") +
+                 "\nReference only: not used in the CPI or the zone ranking", fontsize=10, fontweight="bold")
+    fig.text(0.01, 0.01, f"Source: {SOURCE}", fontsize=6.5, color="#555")
+    fig.tight_layout()
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    return out
+
+
+def raster_file(block: str, key: str, path: Path) -> bool:
+    """Write the interpolated surface as a GeoTIFF (UTM). Returns False when there is no surface."""
+    z, grid = surface(block, key)
+    if z is None:
+        return False
+    g = stations(block, key)
+    write_raster(path, z[None], grid, [f"{key}_{LAYERS[key]['unit']}"],
+                 tags={"source": SOURCE, "stations": len(g), "median_station_spacing_m": round(_spacing(g)),
+                       "method": "thin-plate-spline interpolation of ground stations; masked beyond 1.5 x spacing",
+                       "note": CAVEAT})
+    return True

geoscan/geoscan/webapp/help_text.py

@@ -1,275 +1,287 @@
-"""Plain-language explanations shown by the (i) buttons in the web app.
-
-Each entry: what (what it is), how (how the method uses it, formula), up / down (effect of raising /
-lowering it), why (why the default), evidence (what validation says, optional). Keep these in step with
-the methodology document.
-"""
-
-INFO = {
-    # ------------------------------------------------------------------ method options
-    "structure.dem_source": {
-        "what": "The elevation model (terrain map) that lineaments are traced from.",
-        "how": "Hillshades from 8 sun directions and valley/ridge axes are computed from this elevation model, "
-               "then straight edges are found and joined into lines.",
-        "choices": "ALOS AW3D30 (JAXA, from stereo optical images, 2006-2011). "
-                   "SRTM (NASA radar, February 2000; used in the 24 September version). "
-                   "Copernicus GLO-30 (TanDEM-X radar, 2011-2015).",
-        "why": "AW3D30 was the most accurate model at the 47 Thanewasna borehole collars (1.4 m error, against "
-               "3.1 m for SRTM). It also gave the best results at both blocks when the complete map was rebuilt.",
-        "evidence": "Thanewasna, structure layer against Cu lodes: AUC 0.77 with AW3D30, 0.71 with SRTM. "
-                    "Against boreholes: 0.85 and 0.72.",
-    },
-    "structure.canny_tile_m": {
-        "what": "How the 'is this a strong edge?' threshold is set when lines are traced.",
-        "how": "An edge counts when its contrast is in the top 20 % (to extend a line) or top 5 % (to start one). "
-               "'Whole area' ranks every pixel of the area together. 'Per 3 km tile' ranks each 3 km square on its own.",
-        "up": "Per 3 km tile: flat ground gets its own fair share of edges, so subtle structures in plains are found.",
-        "down": "Whole area: hilly parts use up the top-5 % edges and flat parts get almost none.",
-        "why": "Per-tile thresholds found more of the ore-parallel structure at Thanewasna. At Kelipur they also "
-               "found more lines parallel to the mapped foliation.",
-    },
-    # ------------------------------------------------------------------ CPI and targets
-    "targets.w_muscovite": {
-        "what": "How much muscovite / sericite (phyllic alteration) counts in the hydrothermal score H.",
-        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
-               "The four weights must add up to 1.",
-        "up": "Areas with strong white mica rise in the ranking.",
-        "down": "White-mica areas count less; the other three minerals decide more.",
-        "why": "Expert-assigned, following porphyry-style zoning. The sericite (phyllic) zone sits closest to the "
-               "ore, so it gets the largest weight. This is a judgement, not a measured value.",
-        "evidence": "Thanewasna: muscovite layer AUC 0.62 at lodes, 0.76 at boreholes.",
-    },
-    "targets.w_quartz": {
-        "what": "How much quartz / silicification counts in the hydrothermal score H.",
-        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
-               "The four weights must add up to 1.",
-        "up": "Silica-rich areas, from ASTER thermal data at 90 m, rise in the ranking.",
-        "down": "Quartz counts less.",
-        "why": "Expert-assigned; silicification often accompanies the phyllic zone.",
-        "evidence": "Thanewasna: the quartz layer shows no skill at the lodes (AUC 0.51) and some at boreholes (0.68). "
-                    "The ASTER pixels (90 m) are coarse for a 2 km block.",
-    },
-    "targets.w_gossan": {
-        "what": "How much gossan / iron oxide counts in the hydrothermal score H.",
-        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
-               "The four weights must add up to 1.",
-        "up": "Iron-stained, oxidised ground rises in the ranking.",
-        "down": "Iron oxide counts less. Useful where laterite or ferruginous soil (not gossan) is widespread.",
-        "why": "Expert-assigned. A gossan is the weathered cap of sulphides.",
-        "evidence": "Thanewasna: the strongest single layer (AUC 0.77 at lodes, 0.83 at boreholes). Two independent "
-                    "satellites (ASTER, Sentinel-2) show the same iron-oxide pattern.",
-    },
-    "targets.w_chlorite": {
-        "what": "How much chlorite / epidote (propylitic alteration) counts in the hydrothermal score H.",
-        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
-               "The four weights must add up to 1.",
-        "up": "Chlorite-rich areas rise in the ranking.",
-        "down": "Chlorite counts less.",
-        "why": "Expert-assigned and smallest, because the propylitic zone is the outer halo, not the ore.",
-        "evidence": "Thanewasna: chlorite is lower at lode-intersecting boreholes than at halo boreholes (AUC 0.29). "
-                    "In this deposit it behaves as a distal indicator, so a lower weight is worth testing.",
-    },
-    "targets.w_structure": {
-        "what": "How much the nearness to a lineament counts in the final score, compared with the minerals.",
-        "how": "CPI = (1 − s)·H + s·S_prox, where S_prox = exp(−distance to nearest lineament / λ).",
-        "up": "Targets are pulled towards mapped lineaments. Areas with no mapped line score lower.",
-        "down": "The minerals decide almost alone.",
-        "why": "Expert-assigned: alteration is the main evidence (70 %) and structure supports it (30 %).",
-        "evidence": "Thanewasna: structure layer alone AUC 0.77 at lodes, 0.85 at boreholes. Remember that "
-                    "lineaments come from terrain and miss buried structures.",
-    },
-    "targets.structure_lambda_m": {
-        "what": "How quickly the benefit of being near a lineament fades with distance.",
-        "how": "S_prox = exp(−d / λ). At d = λ the structural score is 37 %, at 2λ it is 14 %, at 3λ 5 %.",
-        "up": "Lineaments influence a wider strip. The map gets smoother and more ground benefits.",
-        "down": "Only ground right next to a lineament benefits.",
-        "why": "Assumed width of fracture-controlled alteration around a structure (a few hundred metres).",
-        "evidence": "Thanewasna: λ = 400 m gave lode AUC 0.74, against 0.73 with 250 m. The difference is small.",
-    },
-    "targets.tier1": {
-        "what": "Score needed for a Tier 1 (high-priority) target.",
-        "how": "CPI ≥ Tier 1 → 'Tier 1: High Priority' (recommendation: diamond core drilling). "
-               "CPI is not re-stretched, so these are absolute values.",
-        "up": "Fewer targets are called Tier 1.",
-        "down": "More targets are called Tier 1.",
-        "why": "Expert-assigned class boundaries. Changing tiers only changes labels and contour lines, "
-               "not which spots are chosen.",
-    },
-    "targets.tier2": {
-        "what": "Score needed for a Tier 2 (medium-priority) target.",
-        "how": "Tier 2 ≤ CPI < Tier 1 → 'Tier 2: Medium Priority' (recommendation: RC drilling / trenching across strike).",
-        "up": "Fewer Tier 2, more Tier 3.", "down": "More Tier 2.",
-        "why": "Expert-assigned class boundary; labels only.",
-    },
-    "targets.tier3": {
-        "what": "Score needed for a Tier 3 (general anomaly) target.",
-        "how": "Tier 3 ≤ CPI < Tier 2 → 'Tier 3: General Anomaly' (recommendation: field mapping and rock-chip geochemistry). "
-               "It is also the lowest contour on the CPI map.",
-        "up": "Fewer anomalies are labelled.", "down": "More weak anomalies are labelled.",
-        "why": "Expert-assigned class boundary.",
-    },
-    "targets.min_cpi": {
-        "what": "No target is placed where the score is below this value.",
-        "how": "Only spots with CPI ≥ this value are considered when picking targets.",
-        "up": "Fewer targets, all in strong anomalies.",
-        "down": "More targets, reaching into weak anomalies (still at most the maximum number).",
-        "why": "Expert-assigned, just below the Tier 3 boundary.",
-    },
-    "targets.min_spacing_m": {
-        "what": "The minimum distance between two targets.",
-        "how": "Spots are taken from the highest score down. A spot closer than this to an already chosen target is "
-               "skipped. It is the weaker neighbour of that target, part of the same anomaly.",
-        "up": "Fewer, more spread-out targets: roughly one per anomaly.",
-        "down": "Several targets can sit on one large anomaly. Use this to test lodes that lie close together.",
-        "why": "Assumed: about the size of one drill fence / anomaly, so one anomaly does not take all the top ranks.",
-    },
-    "targets.n_targets": {
-        "what": "The largest number of targets listed.",
-        "how": "Picking stops when this many targets are found (or when no spot above the minimum score is left).",
-        "up": "A longer list.", "down": "A shorter list.",
-        "why": "A practical list length for field planning.",
-    },
-    # ------------------------------------------------------------------ alteration layers
-    "alteration.sigma_core_m": {
-        "what": "Size of the sharp 'hot spot' drawn around each EMIT detection.",
-        "how": "Every detection (a 60 m pixel) is spread with a Gaussian of this σ. The core keeps the peak where "
-               "the mineral was actually seen.",
-        "up": "Hot spots are blurred and nearby detections merge.",
-        "down": "Hot spots stay pixel-sharp and spotty.",
-        "why": "Expert choice: about 1.5 EMIT pixels, enough to remove pixel noise but keep detail.",
-    },
-    "alteration.sigma_halo_m": {
-        "what": "Size of the wider zone drawn around each detection, standing for the alteration halo.",
-        "how": "A second, wider Gaussian of this σ is combined with the core. It decides how far a zone reaches "
-               "beyond the detected pixels.",
-        "up": "Wider, more continuous zones; isolated detections spread further.",
-        "down": "Tighter zones that hug the detections.",
-        "why": "Expert choice: alteration halos around a mineralised system are typically a few hundred metres wide.",
-    },
-    "alteration.theta_decay": {
-        "what": "How many detections must be close together before a halo is believed.",
-        "how": "confidence = 1 − exp(−W / θ), where W is the share of detections within the halo around a pixel.",
-        "up": "A single lonely detection fades away (treated as noise); only clusters show strongly.",
-        "down": "Even one detection shows at full strength.",
-        "why": "Expert choice.",
-    },
-    "alteration.reference_percentile": {
-        "what": "Which value is shown as 100 % on the mineral maps.",
-        "how": "Intensity = field / (value of the field at this percentile inside the area), capped at 100 %.",
-        "up": "Fewer pixels reach 100 %; the strongest areas stand out more.",
-        "down": "More of the map looks saturated at 100 %.",
-        "why": "The 98th percentile ignores the most extreme 2 % of pixels. Percentages are relative to "
-               "this area, so 80 % here is not comparable with 80 % in another area.",
-    },
-    "alteration.sericite_min_nm": {
-        "what": "Shortest wavelength of the Al-OH absorption that is accepted as white mica (muscovite / sericite).",
-        "how": "Muscovite has its main absorption near 2200 nm. Detections whose absorption minimum falls outside "
-               "the window are not counted as muscovite.",
-        "up": "Excludes sodic micas (paragonite, near 2190 nm).",
-        "down": "Accepts more sodic micas.",
-        "why": "From spectral-library positions of the muscovite family. Kaolinite and smectite absorb at similar "
-               "positions, so the window cannot exclude them completely.",
-    },
-    "alteration.sericite_max_nm": {
-        "what": "Longest wavelength of the Al-OH absorption that is accepted as white mica.",
-        "how": "Muscovite has its main absorption near 2200 nm. Detections whose absorption minimum falls outside "
-               "the window are not counted as muscovite.",
-        "up": "Accepts phengitic (Fe/Mg-rich) micas, which absorb at 2215-2225 nm.",
-        "down": "Keeps only classic muscovite / sericite.",
-        "why": "From spectral-library positions of the muscovite family.",
-    },
-    "alteration.quartz_qi_weight": {
-        "what": "Balance between the two ASTER thermal indices in the quartz layer.",
-        "how": "QSI = w·QI + (1 − w)·SI. QI = B11² / (B10·B12) is the published quartz index (Ninomiya 2003). "
-               "SI = B13 / B12 is a silica ratio inherited from earlier work with no verified primary source.",
-        "up": "Relies more on the published quartz index.",
-        "down": "Relies more on the unverified silica ratio.",
-        "why": "Expert choice. This weighting is one of the review points in the methodology.",
-    },
-    "alteration.quartz_background_percentile": {
-        "what": "How much of the weakest quartz signal is treated as ordinary rock (0 %).",
-        "how": "Quartz intensity = (QSI − P_background) / (P98 − P_background), clipped to 0-100 %.",
-        "up": "Only the strongest quartz shows; more of the area becomes 0 %.",
-        "down": "More of the area shows some quartz.",
-        "why": "Project assumption: the lowest 15 % of the area is background.",
-    },
-    # ------------------------------------------------------------------ lineaments
-    "structure.min_length_m": {
-        "what": "Lineaments shorter than this are dropped.",
-        "how": "After the line pieces are joined, any line shorter than this is removed.",
-        "up": "Only major structures remain.",
-        "down": "More short lines, including drainage and noise.",
-        "why": "Expert choice: a structure that guides fluids over a deposit is usually at least ~1 km long.",
-    },
-    "structure.min_segment_m": {
-        "what": "Shortest straight piece the line finder will accept before joining pieces.",
-        "how": "A Hough transform finds straight pieces on the edge map; pieces shorter than this are ignored.",
-        "up": "Fewer, cleaner pieces.", "down": "More fragments.",
-        "why": "Project assumption.",
-    },
-    "structure.max_gap_m": {
-        "what": "Largest break that is bridged inside one straight piece.",
-        "how": "Edges along the same line with a gap up to this size are treated as one piece.",
-        "up": "Broken lines are joined more easily.", "down": "Lines break at small gaps.",
-        "why": "Project assumption (3 pixels at 30 m).",
-    },
-    "structure.canny_low_quantile": {
-        "what": "How weak an edge may be and still extend a line.",
-        "how": "Edges in the top (1 − value) of contrast can continue a line that a strong edge started.",
-        "up": "Fewer, shorter lines.", "down": "Lines run further through weak edges.",
-        "why": "Project assumption (top 20 %).",
-    },
-    "structure.canny_high_quantile": {
-        "what": "How strong an edge must be to start a line.",
-        "how": "Only edges in the top (1 − value) of contrast can start a line.",
-        "up": "Only the sharpest features start lines.", "down": "More lines start.",
-        "why": "Project assumption (top 5 %).",
-    },
-    "structure.scarp_min_step_m": {
-        "what": "When a line is called a scarp (a cliff or plateau edge) instead of a valley or ridge.",
-        "how": "The terrain is compared 90 m either side of the line. If one side is consistently higher by at "
-               "least this much, the line is a scarp.",
-        "up": "Fewer lines are called scarps.", "down": "More lines are called scarps.",
-        "why": "Expert choice. Erosional scarps (such as the Deccan plateau edge) are not fluid pathways.",
-    },
-    "structure.exclude_scarps": {
-        "what": "Whether scarps are left out of the CPI.",
-        "how": "Scarps always stay in the lineament map and vectors. When this is on, they are not used for the "
-               "structural score or density.",
-        "up": "On: cliff edges do not attract targets.", "down": "Off: every line counts.",
-        "why": "Project assumption, checked at both blocks.",
-    },
-    # ------------------------------------------------------------------ EMIT detection
-    "spectral.detect_sigma": {
-        "what": "How sure we must be that an absorption is real before calling it a detection.",
-        "how": "Detected when band depth > k × its uncertainty. The uncertainty comes from EMIT's own per-band "
-               "error, propagated with 64 Monte-Carlo draws. k = 2 is about 95 % confidence.",
-        "up": "Fewer, more certain detections.", "down": "More, less certain detections.",
-        "why": "Project assumption: the usual 2σ significance level.",
-    },
-    "spectral.min_depth": {
-        "what": "Weakest absorption that can count as a detection, however precise it is.",
-        "how": "Detected only when band depth is also above this value (0.01 = a 1 % dip).",
-        "up": "Shallow absorptions are ignored.", "down": "Very shallow dips can count.",
-        "why": "Project assumption.",
-    },
-    "spectral.min_albedo": {
-        "what": "Pixels darker than this are skipped.",
-        "how": "Pixels with reflectance below this value are masked before band depths are measured.",
-        "up": "More dark ground (shadow, water, burnt areas) is skipped.", "down": "Darker pixels are used.",
-        "why": "Project assumption: band depths are unreliable on very dark surfaces.",
-    },
-}
-
-LAYER_INFO = {
-    "cpi": "Copper Prospectivity Index: (1 − s) × hydrothermal score + s × nearness to lineaments. "
-           "0-100 %; contours at the Tier 3 / 2 / 1 thresholds.",
-    "muscovite": "White mica (sericite, phyllic alteration) from the EMIT Al-OH absorption near 2200 nm. "
-                 "Relative intensity: 100 % = strongest 2 % of this area.",
-    "chlorite": "Chlorite / epidote (propylitic alteration) from the EMIT Fe-OH (2250 nm) and Mg-OH (2330 nm) "
-                "absorptions, with carbonate-dominated pixels excluded using EMIT L2B.",
-    "gossan": "Iron oxide (Fe³⁺) from the EMIT 900 nm absorption. It cannot separate gossan from laterite or "
-              "ferruginous soil.",
-    "quartz": "Quartz / silicification from ASTER thermal emissivity (90 m): QSI = w·QI + (1 − w)·SI.",
-    "lineament_density": "Length of lineaments (km) per km² within 1 km.",
-}
+"""Plain-language explanations shown by the (i) buttons in the web app.
+
+Each entry: what (what it is), how (how the method uses it, formula), up / down (effect of raising /
+lowering it), why (why the default), evidence (what validation says, optional). Keep these in step with
+the methodology document.
+"""
+
+INFO = {
+    # ------------------------------------------------------------------ method options
+    "structure.dem_source": {
+        "what": "The elevation model (terrain map) that lineaments are traced from.",
+        "how": "Hillshades from 8 sun directions and valley/ridge axes are computed from this elevation model, "
+               "then straight edges are found and joined into lines.",
+        "choices": "ALOS AW3D30 (JAXA, from stereo optical images, 2006-2011). "
+                   "SRTM (NASA radar, February 2000; used in the 24 September version). "
+                   "Copernicus GLO-30 (TanDEM-X radar, 2011-2015).",
+        "why": "AW3D30 was the most accurate model at the 47 Thanewasna borehole collars (1.4 m error, against "
+               "3.1 m for SRTM). It also gave the best results at both blocks when the complete map was rebuilt.",
+        "evidence": "Thanewasna, structure layer against Cu lodes: AUC 0.77 with AW3D30, 0.71 with SRTM. "
+                    "Against boreholes: 0.85 and 0.72.",
+    },
+    "structure.canny_tile_m": {
+        "what": "How the 'is this a strong edge?' threshold is set when lines are traced.",
+        "how": "An edge counts when its contrast is in the top 20 % (to extend a line) or top 5 % (to start one). "
+               "'Whole area' ranks every pixel of the area together. 'Per 3 km tile' ranks each 3 km square on its own.",
+        "up": "Per 3 km tile: flat ground gets its own fair share of edges, so subtle structures in plains are found.",
+        "down": "Whole area: hilly parts use up the top-5 % edges and flat parts get almost none.",
+        "why": "Per-tile thresholds found more of the ore-parallel structure at Thanewasna. At Kelipur they also "
+               "found more lines parallel to the mapped foliation.",
+    },
+    # ------------------------------------------------------------------ CPI and targets
+    "targets.w_muscovite": {
+        "what": "How much muscovite / sericite (phyllic alteration) counts in the hydrothermal score H.",
+        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
+               "The four weights must add up to 1.",
+        "up": "Areas with strong white mica rise in the ranking.",
+        "down": "White-mica areas count less; the other three minerals decide more.",
+        "why": "Expert-assigned, following porphyry-style zoning. The sericite (phyllic) zone sits closest to the "
+               "ore, so it gets the largest weight. This is a judgement, not a measured value.",
+        "evidence": "Thanewasna: muscovite layer AUC 0.62 at lodes, 0.76 at boreholes.",
+    },
+    "targets.w_quartz": {
+        "what": "How much quartz / silicification counts in the hydrothermal score H.",
+        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
+               "The four weights must add up to 1.",
+        "up": "Silica-rich areas, from ASTER thermal data at 90 m, rise in the ranking.",
+        "down": "Quartz counts less.",
+        "why": "Expert-assigned; silicification often accompanies the phyllic zone.",
+        "evidence": "Thanewasna: the quartz layer shows no skill at the lodes (AUC 0.51) and some at boreholes (0.68). "
+                    "The ASTER pixels (90 m) are coarse for a 2 km block.",
+    },
+    "targets.w_gossan": {
+        "what": "How much gossan / iron oxide counts in the hydrothermal score H.",
+        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
+               "The four weights must add up to 1.",
+        "up": "Iron-stained, oxidised ground rises in the ranking.",
+        "down": "Iron oxide counts less. Useful where laterite or ferruginous soil (not gossan) is widespread.",
+        "why": "Expert-assigned. A gossan is the weathered cap of sulphides.",
+        "evidence": "Thanewasna: the strongest single layer (AUC 0.77 at lodes, 0.83 at boreholes). Two independent "
+                    "satellites (ASTER, Sentinel-2) show the same iron-oxide pattern.",
+    },
+    "targets.w_chlorite": {
+        "what": "How much chlorite / epidote (propylitic alteration) counts in the hydrothermal score H.",
+        "how": "H = w_musc·muscovite + w_qtz·quartz + w_goss·gossan + w_chl·chlorite, each layer 0-1. "
+               "The four weights must add up to 1.",
+        "up": "Chlorite-rich areas rise in the ranking.",
+        "down": "Chlorite counts less.",
+        "why": "Expert-assigned and smallest, because the propylitic zone is the outer halo, not the ore.",
+        "evidence": "Thanewasna: chlorite is lower at lode-intersecting boreholes than at halo boreholes (AUC 0.29). "
+                    "In this deposit it behaves as a distal indicator, so a lower weight is worth testing.",
+    },
+    "targets.w_structure": {
+        "what": "How much the nearness to a lineament counts in the final score, compared with the minerals.",
+        "how": "CPI = (1 − s)·H + s·S_prox, where S_prox = exp(−distance to nearest lineament / λ).",
+        "up": "Zones are pulled towards mapped lineaments. Areas with no mapped line score lower.",
+        "down": "The minerals decide almost alone.",
+        "why": "Expert-assigned: alteration is the main evidence (70 %) and structure supports it (30 %).",
+        "evidence": "Thanewasna: structure layer alone AUC 0.77 at lodes, 0.85 at boreholes. Remember that "
+                    "lineaments come from terrain and miss buried structures.",
+    },
+    "targets.structure_lambda_m": {
+        "what": "How quickly the benefit of being near a lineament fades with distance.",
+        "how": "S_prox = exp(−d / λ). At d = λ the structural score is 37 %, at 2λ it is 14 %, at 3λ 5 %.",
+        "up": "Lineaments influence a wider strip. The map gets smoother and more ground benefits.",
+        "down": "Only ground right next to a lineament benefits.",
+        "why": "Assumed width of fracture-controlled alteration around a structure (a few hundred metres).",
+        "evidence": "Thanewasna: λ = 400 m gave lode AUC 0.74, against 0.73 with 250 m. The difference is small.",
+    },
+    "targets.tier1": {
+        "what": "Score a zone must reach somewhere inside it to be a Tier 1 (high-priority) zone.",
+        "how": "A prospective zone is Tier 1 when its peak CPI >= this value. It is also the highest contour on the "
+               "CPI map. CPI is not re-stretched, so these are absolute values.",
+        "up": "Fewer zones are called Tier 1.",
+        "down": "More zones are called Tier 1.",
+        "why": "Expert-assigned class boundary. It changes labels and suggested follow-up, not the zone outlines.",
+        "evidence": "Thanewasna: the Tier 1 zone covers 17.5 % of the block and holds 53 % of the known lode area "
+                    "(3.1 times chance) and 6 of the 8 boreholes that intersect a lode.",
+    },
+    "targets.tier2": {
+        "what": "The outline of a prospective zone: all connected ground with CPI at or above this value.",
+        "how": "Zones are the connected areas with CPI >= this value. A zone is Tier 1 if it reaches the Tier 1 "
+               "threshold somewhere, otherwise Tier 2. This is the middle contour on the CPI map.",
+        "up": "Smaller, tighter zones: less ground to check, but more of the mineralisation is left outside.",
+        "down": "Larger zones that hold more of the mineralisation but give less focus. Very low values merge "
+                "whole districts into one zone.",
+        "why": "Expert-assigned. Tested against the Tier 3 line as the boundary, which was too loose.",
+        "evidence": "Thanewasna, share of block covered -> share of lode area inside: CPI >= 28 %: 56 % -> 74 % "
+                    "(1.3 times chance); CPI >= 50 %: 16.5 % -> 48.5 % (2.9 times); CPI >= 70 %: 7 % -> 35 % (5 times).",
+    },
+    "targets.tier3": {
+        "what": "The outer halo around the zones, and the score an isolated weak anomaly needs to be listed as a Tier 3 zone.",
+        "how": "Ground with CPI >= this value around a Tier 1 / 2 zone is its outer halo (lowest contour on the map). "
+               "An anomaly that reaches this value but never the Tier 2 threshold, and is separate from every "
+               "Tier 1 / 2 zone, is listed as a Tier 3 zone.",
+        "up": "Narrower halos and fewer Tier 3 zones.", "down": "Wider halos and more weak Tier 3 zones.",
+        "why": "Expert-assigned class boundary.",
+    },
+    "targets.min_cpi": {
+        "what": "No field-check location is suggested where the score is below this value.",
+        "how": "Only cells with CPI >= this value are considered when the suggested field-check locations are picked.",
+        "up": "Fewer locations, all in strong anomalies.",
+        "down": "More locations, reaching into weak anomalies (still at most the maximum number).",
+        "why": "Expert-assigned, just below the Tier 3 boundary.",
+    },
+    "targets.min_spacing_m": {
+        "what": "The minimum distance between two suggested field-check locations.",
+        "how": "Cells are taken from the highest score down. A cell closer than this to an already chosen location is "
+               "skipped: it is the weaker neighbour of that location, part of the same anomaly. The same distance is "
+               "given as the 'check within' radius of each location.",
+        "up": "Fewer, more spread-out locations: roughly one per anomaly.",
+        "down": "Several locations can sit on one large zone.",
+        "why": "Assumed: about the size of one anomaly, so one zone does not take all the top ranks. The locations are "
+               "starting points for field work. Their exact position is not significant, and they are not drill collars.",
+        "evidence": "Thanewasna: only 3 of the top 10 locations lie within 100 m of a lode (1.9 expected by chance). "
+                    "The method predicts zones far better than points.",
+    },
+    "targets.n_targets": {
+        "what": "The largest number of suggested field-check locations listed.",
+        "how": "Picking stops when this many locations are found (or when no cell above the minimum score is left).",
+        "up": "A longer list.", "down": "A shorter list.",
+        "why": "A practical list length for planning field traverses.",
+    },
+    # ------------------------------------------------------------------ alteration layers
+    "alteration.sigma_core_m": {
+        "what": "Size of the sharp 'hot spot' drawn around each EMIT detection.",
+        "how": "Every detection (a 60 m pixel) is spread with a Gaussian of this σ. The core keeps the peak where "
+               "the mineral was actually seen.",
+        "up": "Hot spots are blurred and nearby detections merge.",
+        "down": "Hot spots stay pixel-sharp and spotty.",
+        "why": "Expert choice: about 1.5 EMIT pixels, enough to remove pixel noise but keep detail.",
+    },
+    "alteration.sigma_halo_m": {
+        "what": "Size of the wider zone drawn around each detection, standing for the alteration halo.",
+        "how": "A second, wider Gaussian of this σ is combined with the core. It decides how far a zone reaches "
+               "beyond the detected pixels.",
+        "up": "Wider, more continuous zones; isolated detections spread further.",
+        "down": "Tighter zones that hug the detections.",
+        "why": "Expert choice: alteration halos around a mineralised system are typically a few hundred metres wide.",
+    },
+    "alteration.theta_decay": {
+        "what": "How many detections must be close together before a halo is believed.",
+        "how": "confidence = 1 − exp(−W / θ), where W is the share of detections within the halo around a pixel.",
+        "up": "A single lonely detection fades away (treated as noise); only clusters show strongly.",
+        "down": "Even one detection shows at full strength.",
+        "why": "Expert choice.",
+    },
+    "alteration.reference_percentile": {
+        "what": "Which value is shown as 100 % on the mineral maps.",
+        "how": "Intensity = field / (value of the field at this percentile inside the area), capped at 100 %.",
+        "up": "Fewer pixels reach 100 %; the strongest areas stand out more.",
+        "down": "More of the map looks saturated at 100 %.",
+        "why": "The 98th percentile ignores the most extreme 2 % of pixels. Percentages are relative to "
+               "this area, so 80 % here is not comparable with 80 % in another area.",
+    },
+    "alteration.sericite_min_nm": {
+        "what": "Shortest wavelength of the Al-OH absorption that is accepted as white mica (muscovite / sericite).",
+        "how": "Muscovite has its main absorption near 2200 nm. Detections whose absorption minimum falls outside "
+               "the window are not counted as muscovite.",
+        "up": "Excludes sodic micas (paragonite, near 2190 nm).",
+        "down": "Accepts more sodic micas.",
+        "why": "From spectral-library positions of the muscovite family. Kaolinite and smectite absorb at similar "
+               "positions, so the window cannot exclude them completely.",
+    },
+    "alteration.sericite_max_nm": {
+        "what": "Longest wavelength of the Al-OH absorption that is accepted as white mica.",
+        "how": "Muscovite has its main absorption near 2200 nm. Detections whose absorption minimum falls outside "
+               "the window are not counted as muscovite.",
+        "up": "Accepts phengitic (Fe/Mg-rich) micas, which absorb at 2215-2225 nm.",
+        "down": "Keeps only classic muscovite / sericite.",
+        "why": "From spectral-library positions of the muscovite family.",
+    },
+    "alteration.quartz_qi_weight": {
+        "what": "Balance between the two ASTER thermal indices in the quartz layer.",
+        "how": "QSI = w·QI + (1 − w)·SI. QI = B11² / (B10·B12) is the published quartz index (Ninomiya 2003). "
+               "SI = B13 / B12 is a silica ratio inherited from earlier work with no verified primary source.",
+        "up": "Relies more on the published quartz index.",
+        "down": "Relies more on the unverified silica ratio.",
+        "why": "Expert choice. This weighting is one of the review points in the methodology.",
+    },
+    "alteration.quartz_background_percentile": {
+        "what": "How much of the weakest quartz signal is treated as ordinary rock (0 %).",
+        "how": "Quartz intensity = (QSI − P_background) / (P98 − P_background), clipped to 0-100 %.",
+        "up": "Only the strongest quartz shows; more of the area becomes 0 %.",
+        "down": "More of the area shows some quartz.",
+        "why": "Project assumption: the lowest 15 % of the area is background.",
+    },
+    # ------------------------------------------------------------------ lineaments
+    "structure.min_length_m": {
+        "what": "Lineaments shorter than this are dropped.",
+        "how": "After the line pieces are joined, any line shorter than this is removed.",
+        "up": "Only major structures remain.",
+        "down": "More short lines, including drainage and noise.",
+        "why": "Expert choice: a structure that guides fluids over a deposit is usually at least ~1 km long.",
+    },
+    "structure.min_segment_m": {
+        "what": "Shortest straight piece the line finder will accept before joining pieces.",
+        "how": "A Hough transform finds straight pieces on the edge map; pieces shorter than this are ignored.",
+        "up": "Fewer, cleaner pieces.", "down": "More fragments.",
+        "why": "Project assumption.",
+    },
+    "structure.max_gap_m": {
+        "what": "Largest break that is bridged inside one straight piece.",
+        "how": "Edges along the same line with a gap up to this size are treated as one piece.",
+        "up": "Broken lines are joined more easily.", "down": "Lines break at small gaps.",
+        "why": "Project assumption (3 pixels at 30 m).",
+    },
+    "structure.canny_low_quantile": {
+        "what": "How weak an edge may be and still extend a line.",
+        "how": "Edges in the top (1 − value) of contrast can continue a line that a strong edge started.",
+        "up": "Fewer, shorter lines.", "down": "Lines run further through weak edges.",
+        "why": "Project assumption (top 20 %).",
+    },
+    "structure.canny_high_quantile": {
+        "what": "How strong an edge must be to start a line.",
+        "how": "Only edges in the top (1 − value) of contrast can start a line.",
+        "up": "Only the sharpest features start lines.", "down": "More lines start.",
+        "why": "Project assumption (top 5 %).",
+    },
+    "structure.scarp_min_step_m": {
+        "what": "When a line is called a scarp (a cliff or plateau edge) instead of a valley or ridge.",
+        "how": "The terrain is compared 90 m either side of the line. If one side is consistently higher by at "
+               "least this much, the line is a scarp.",
+        "up": "Fewer lines are called scarps.", "down": "More lines are called scarps.",
+        "why": "Expert choice. Erosional scarps (such as the Deccan plateau edge) are not fluid pathways.",
+    },
+    "structure.exclude_scarps": {
+        "what": "Whether scarps are left out of the CPI.",
+        "how": "Scarps always stay in the lineament map and vectors. When this is on, they are not used for the "
+               "structural score or density.",
+        "up": "On: cliff edges do not attract targets.", "down": "Off: every line counts.",
+        "why": "Project assumption, checked at both blocks.",
+    },
+    # ------------------------------------------------------------------ EMIT detection
+    "spectral.detect_sigma": {
+        "what": "How sure we must be that an absorption is real before calling it a detection.",
+        "how": "Detected when band depth > k × its uncertainty. The uncertainty comes from EMIT's own per-band "
+               "error, propagated with 64 Monte-Carlo draws. k = 2 is about 95 % confidence.",
+        "up": "Fewer, more certain detections.", "down": "More, less certain detections.",
+        "why": "Project assumption: the usual 2σ significance level.",
+    },
+    "spectral.min_depth": {
+        "what": "Weakest absorption that can count as a detection, however precise it is.",
+        "how": "Detected only when band depth is also above this value (0.01 = a 1 % dip).",
+        "up": "Shallow absorptions are ignored.", "down": "Very shallow dips can count.",
+        "why": "Project assumption.",
+    },
+    "spectral.min_albedo": {
+        "what": "Pixels darker than this are skipped.",
+        "how": "Pixels with reflectance below this value are masked before band depths are measured.",
+        "up": "More dark ground (shadow, water, burnt areas) is skipped.", "down": "Darker pixels are used.",
+        "why": "Project assumption: band depths are unreliable on very dark surfaces.",
+    },
+}
+
+LAYER_INFO = {
+    "cpi": "Copper Prospectivity Index: (1 − s) × hydrothermal score + s × nearness to lineaments. "
+           "0-100 %; contours at the Tier 3 / 2 / 1 thresholds. The Tier 2 contour is the outline of the "
+           "prospective zones.",
+    "muscovite": "White mica (sericite, phyllic alteration) from the EMIT Al-OH absorption near 2200 nm. "
+                 "Relative intensity: 100 % = strongest 2 % of this area.",
+    "chlorite": "Chlorite / epidote (propylitic alteration) from the EMIT Fe-OH (2250 nm) and Mg-OH (2330 nm) "
+                "absorptions, with carbonate-dominated pixels excluded using EMIT L2B.",
+    "gossan": "Iron oxide (Fe³⁺) from the EMIT 900 nm absorption. It cannot separate gossan from laterite or "
+              "ferruginous soil.",
+    "quartz": "Quartz / silicification from ASTER thermal emissivity (90 m): QSI = w·QI + (1 − w)·SI.",
+    "lineament_density": "Length of lineaments (km) per km² within 1 km.",
+}

geoscan/geoscan/webapp/jobs.py

@@ -1,168 +1,168 @@
-"""Background analysis jobs: one at a time (Earth Engine downloads are the bottleneck)."""
-
-from __future__ import annotations
-
-import json
-import logging
-import queue
-import shutil
-import subprocess
-import sys
-import threading
-import traceback
-import uuid
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from pathlib import Path
-
-from ..pipeline import STEPS, Pipeline
-from . import accounts, catalog
-
-VALIDATED_BLOCKS = ("kelipur", "thanewasna")       # blocks with ground truth handled by scripts/validate.py
-STEP_LABELS = {"acquire": "Downloading satellite data (EMIT, DEM, ASTER)", "emit_l2a": "EMIT mineral absorption features",
-               "emit_l2b": "EMIT L2B mineral identification", "aster": "ASTER thermal indices (quartz)",
-               "structure": "Lineaments", "alteration": "Alteration layers", "targets": "CPI and drill targets",
-               "maps": "Contour maps", "validation": "Validation against ground truth"}
-
-
-def _now():
-    return datetime.now(timezone.utc).isoformat(timespec="seconds")
-
-
-@dataclass
-class Job:
-    job_id: str
-    block: str
-    options: dict            # all option and parameter values
-    output_name: str
-    status: str = "queued"          # queued | running | done | failed
-    step: str = ""
-    log: list = field(default_factory=list)
-    error: str = ""
-    run_id: str = ""
-    created: str = field(default_factory=_now)
-    user: str = ""
-    extra: dict = field(default_factory=dict)
-
-    def to_dict(self):
-        steps = list(self.extra.get("steps", STEPS)) + (["validation"] if self.block in VALIDATED_BLOCKS else [])
-        idx = steps.index(self.step) if self.step in steps else -1
-        return {"job_id": self.job_id, "block": self.block, "label": catalog.option_label(self.options),
-                "options": {k: v for k, v in self.options.items() if k in catalog.OPTIONS},
-                "params": {k: v for k, v in self.options.items() if k in catalog.PARAMS}, "status": self.status, "step": self.step,
-                "step_label": STEP_LABELS.get(self.step, self.step), "progress": (idx + (self.status == "done")) / len(steps)
-                if idx >= 0 else (1.0 if self.status == "done" else 0.0),
-                "log": self.log[-200:], "error": self.error, "run_id": self.run_id, "created": self.created, "user": self.user}
-
-
-class _LogHandler(logging.Handler):
-    def __init__(self, job: Job):
-        super().__init__(logging.INFO)
-        self.job = job
-
-    def emit(self, record):
-        if record.name.startswith("geoscan"):
-            self.job.log.append(f"{datetime.now():%H:%M:%S}  {record.getMessage()}")
-
-
-class JobManager:
-    def __init__(self):
-        self.jobs: dict[str, Job] = {}
-        self.q: queue.Queue = queue.Queue()
-        threading.Thread(target=self._worker, daemon=True).start()
-
-    def submit(self, block: str, options: dict, user: str = "") -> Job:
-        for j in self.jobs.values():
-            if j.block == block and j.options == options and j.status in ("queued", "running"):
-                return j
-        vid = catalog.variant_id(options)
-        out = block if not vid else f"{block}__{vid}"
-        job = Job(uuid.uuid4().hex[:10], block, options, out, user=user)
-        accounts.record(user, "run_started", area=block, settings=catalog.option_label(options),
-                        changed_parameters=catalog.changed(options), recompute_from=catalog.first_step(options))
-        self.jobs[job.job_id] = job
-        self.q.put(job.job_id)
-        return job
-
-    def _worker(self):
-        while True:
-            job = self.jobs[self.q.get()]
-            job.status = "running"
-            h = _LogHandler(job)
-            logging.getLogger("geoscan").addHandler(h)
-            logging.getLogger("geoscan").setLevel(logging.INFO)
-            try:
-                self._run(job)
-                self._save(job, results=True)
-                job.status = "done"
-                accounts.record(job.user, "run_finished", area=job.block, results=job.run_id)
-            except Exception as e:                           # report, keep the worker alive
-                job.status = "failed"
-                job.error = f"{type(e).__name__}: {e}"
-                accounts.record(job.user, "run_failed", area=job.block, step=job.step, error=job.error[:300])
-                job.log.extend(traceback.format_exc().splitlines()[-16:])   # innermost frames
-                self._save(job, results=False)               # keep the downloaded satellite data at least
-            finally:
-                logging.getLogger("geoscan").removeHandler(h)
-
-    def _save(self, job: Job, results: bool):
-        """Copy new files to permanent storage when the app runs on a host with a temporary disk."""
-        from . import persist
-        if not persist.enabled():
-            return
-        try:
-            job.log.append(f"{datetime.now():%H:%M:%S}  Saving to permanent storage ...")
-            persist.save_area(job.block)
-            if results:
-                persist.save_run(job.output_name)
-            job.log.append(f"{datetime.now():%H:%M:%S}  Saved.")
-        except Exception as e:                               # never fail an analysis because of storage
-            job.log.append(f"WARNING: could not save to permanent storage: {e}")
-
-    def _run(self, job: Job):
-        def progress(step, msg):
-            job.step = step
-            job.log.append(f"{datetime.now():%H:%M:%S}  [{STEP_LABELS.get(step, step)}] {msg}")
-
-        settings = catalog.settings_for(job.options)
-        aoi = catalog.DATA / job.block / "aoi" / "aoi.geojson"
-        p = Pipeline(aoi, job.block, catalog.ROOT, settings, progress=progress, output_name=job.output_name)
-        start = catalog.first_step(job.options)
-        base = catalog.base_run(job.block, job.options)
-        out = catalog.OUTPUTS / job.output_name
-        if base is not None and base.path.resolve() != out.resolve():
-            # re-use everything computed before the first changed step
-            steps = STEPS[STEPS.index(start):]
-            job.extra["steps"] = steps
-            job.log.append(f"Re-using results up to '{start}' from {base.run_id}; running {', '.join(steps)}")
-            if out.exists():
-                shutil.rmtree(out)
-            shutil.copytree(base.path, out, ignore=shutil.ignore_patterns("_webapp_cache", "maps"))
-            if STEPS.index(start) <= STEPS.index("structure"):
-                from ..acquire import gee
-                src = settings.structure.dem_source
-                path = gee.dem_path(p.ws.raw(""), src)
-                if not path.exists():
-                    progress("structure", f"downloading {gee.dem_label(src)} DEM")
-                    gee.initialize(settings.acquire.ee_project)
-                    gee.download_dem(src, p.grid_dem, path, settings.acquire.max_request_mb, settings.acquire.retries)
-            p.run(tuple(steps), clean=False)
-        else:
-            p.run(STEPS, clean=True)
-        if job.block in VALIDATED_BLOCKS:
-            progress("validation", "started")
-            script = Path(__file__).resolve().parents[2] / "scripts" / "validate.py"
-            args = [sys.executable, str(script), "--name", job.block]
-            if job.output_name != job.block:
-                args += ["--output", job.output_name]
-            r = subprocess.run(args, capture_output=True, text=True, encoding="utf-8", errors="replace")
-            if r.returncode != 0:
-                job.log.append(r.stderr[-2000:])
-                raise RuntimeError("validation failed")
-            progress("validation", "done")
-        (catalog.OUTPUTS / job.output_name / "created_by.json").write_text(
-            json.dumps({"user": job.user, "time": _now()}), encoding="utf-8")
-        run = catalog.find_run(job.block, job.options)
-        if run is None:
-            raise RuntimeError("run finished but its results were not found")
-        job.run_id = run.run_id
+"""Background analysis jobs: one at a time (Earth Engine downloads are the bottleneck)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import queue
+import shutil
+import subprocess
+import sys
+import threading
+import traceback
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from ..pipeline import STEPS, Pipeline
+from . import accounts, catalog
+
+VALIDATED_BLOCKS = ("kelipur", "thanewasna")       # blocks with ground truth handled by scripts/validate.py
+STEP_LABELS = {"acquire": "Downloading satellite data (EMIT, DEM, ASTER)", "emit_l2a": "EMIT mineral absorption features",
+               "emit_l2b": "EMIT L2B mineral identification", "aster": "ASTER thermal indices (quartz)",
+               "structure": "Lineaments", "alteration": "Alteration layers", "targets": "CPI, zones and field-check locations",
+               "maps": "Contour maps", "validation": "Validation against ground truth"}
+
+
+def _now():
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+@dataclass
+class Job:
+    job_id: str
+    block: str
+    options: dict            # all option and parameter values
+    output_name: str
+    status: str = "queued"          # queued | running | done | failed
+    step: str = ""
+    log: list = field(default_factory=list)
+    error: str = ""
+    run_id: str = ""
+    created: str = field(default_factory=_now)
+    user: str = ""
+    extra: dict = field(default_factory=dict)
+
+    def to_dict(self):
+        steps = list(self.extra.get("steps", STEPS)) + (["validation"] if self.block in VALIDATED_BLOCKS else [])
+        idx = steps.index(self.step) if self.step in steps else -1
+        return {"job_id": self.job_id, "block": self.block, "label": catalog.option_label(self.options),
+                "options": {k: v for k, v in self.options.items() if k in catalog.OPTIONS},
+                "params": {k: v for k, v in self.options.items() if k in catalog.PARAMS}, "status": self.status, "step": self.step,
+                "step_label": STEP_LABELS.get(self.step, self.step), "progress": (idx + (self.status == "done")) / len(steps)
+                if idx >= 0 else (1.0 if self.status == "done" else 0.0),
+                "log": self.log[-200:], "error": self.error, "run_id": self.run_id, "created": self.created, "user": self.user}
+
+
+class _LogHandler(logging.Handler):
+    def __init__(self, job: Job):
+        super().__init__(logging.INFO)
+        self.job = job
+
+    def emit(self, record):
+        if record.name.startswith("geoscan"):
+            self.job.log.append(f"{datetime.now():%H:%M:%S}  {record.getMessage()}")
+
+
+class JobManager:
+    def __init__(self):
+        self.jobs: dict[str, Job] = {}
+        self.q: queue.Queue = queue.Queue()
+        threading.Thread(target=self._worker, daemon=True).start()
+
+    def submit(self, block: str, options: dict, user: str = "") -> Job:
+        for j in self.jobs.values():
+            if j.block == block and j.options == options and j.status in ("queued", "running"):
+                return j
+        vid = catalog.variant_id(options)
+        out = block if not vid else f"{block}__{vid}"
+        job = Job(uuid.uuid4().hex[:10], block, options, out, user=user)
+        accounts.record(user, "run_started", area=block, settings=catalog.option_label(options),
+                        changed_parameters=catalog.changed(options), recompute_from=catalog.first_step(options))
+        self.jobs[job.job_id] = job
+        self.q.put(job.job_id)
+        return job
+
+    def _worker(self):
+        while True:
+            job = self.jobs[self.q.get()]
+            job.status = "running"
+            h = _LogHandler(job)
+            logging.getLogger("geoscan").addHandler(h)
+            logging.getLogger("geoscan").setLevel(logging.INFO)
+            try:
+                self._run(job)
+                self._save(job, results=True)
+                job.status = "done"
+                accounts.record(job.user, "run_finished", area=job.block, results=job.run_id)
+            except Exception as e:                           # report, keep the worker alive
+                job.status = "failed"
+                job.error = f"{type(e).__name__}: {e}"
+                accounts.record(job.user, "run_failed", area=job.block, step=job.step, error=job.error[:300])
+                job.log.extend(traceback.format_exc().splitlines()[-16:])   # innermost frames
+                self._save(job, results=False)               # keep the downloaded satellite data at least
+            finally:
+                logging.getLogger("geoscan").removeHandler(h)
+
+    def _save(self, job: Job, results: bool):
+        """Copy new files to permanent storage when the app runs on a host with a temporary disk."""
+        from . import persist
+        if not persist.enabled():
+            return
+        try:
+            job.log.append(f"{datetime.now():%H:%M:%S}  Saving to permanent storage ...")
+            persist.save_area(job.block)
+            if results:
+                persist.save_run(job.output_name)
+            job.log.append(f"{datetime.now():%H:%M:%S}  Saved.")
+        except Exception as e:                               # never fail an analysis because of storage
+            job.log.append(f"WARNING: could not save to permanent storage: {e}")
+
+    def _run(self, job: Job):
+        def progress(step, msg):
+            job.step = step
+            job.log.append(f"{datetime.now():%H:%M:%S}  [{STEP_LABELS.get(step, step)}] {msg}")
+
+        settings = catalog.settings_for(job.options)
+        aoi = catalog.DATA / job.block / "aoi" / "aoi.geojson"
+        p = Pipeline(aoi, job.block, catalog.ROOT, settings, progress=progress, output_name=job.output_name)
+        start = catalog.first_step(job.options)
+        base = catalog.base_run(job.block, job.options)
+        out = catalog.OUTPUTS / job.output_name
+        if base is not None and base.path.resolve() != out.resolve():
+            # re-use everything computed before the first changed step
+            steps = STEPS[STEPS.index(start):]
+            job.extra["steps"] = steps
+            job.log.append(f"Re-using results up to '{start}' from {base.run_id}; running {', '.join(steps)}")
+            if out.exists():
+                shutil.rmtree(out)
+            shutil.copytree(base.path, out, ignore=shutil.ignore_patterns("_webapp_cache", "maps"))
+            if STEPS.index(start) <= STEPS.index("structure"):
+                from ..acquire import gee
+                src = settings.structure.dem_source
+                path = gee.dem_path(p.ws.raw(""), src)
+                if not path.exists():
+                    progress("structure", f"downloading {gee.dem_label(src)} DEM")
+                    gee.initialize(settings.acquire.ee_project)
+                    gee.download_dem(src, p.grid_dem, path, settings.acquire.max_request_mb, settings.acquire.retries)
+            p.run(tuple(steps), clean=False)
+        else:
+            p.run(STEPS, clean=True)
+        if job.block in VALIDATED_BLOCKS:
+            progress("validation", "started")
+            script = Path(__file__).resolve().parents[2] / "scripts" / "validate.py"
+            args = [sys.executable, str(script), "--name", job.block]
+            if job.output_name != job.block:
+                args += ["--output", job.output_name]
+            r = subprocess.run(args, capture_output=True, text=True, encoding="utf-8", errors="replace")
+            if r.returncode != 0:
+                job.log.append(r.stderr[-2000:])
+                raise RuntimeError("validation failed")
+            progress("validation", "done")
+        (catalog.OUTPUTS / job.output_name / "created_by.json").write_text(
+            json.dumps({"user": job.user, "time": _now()}), encoding="utf-8")
+        run = catalog.find_run(job.block, job.options)
+        if run is None:
+            raise RuntimeError("run finished but its results were not found")
+        job.run_id = run.run_id

geoscan/geoscan/webapp/layers.py

@@ -31,8 +31,9 @@ RASTER_LAYERS = {
                           "cmap": "viridis", "range": None},
 }
 DROP_COLUMNS = {"EMIT_Data_Support"}
-VECTORS = {"targets": "top50_targets.geojson", "lineaments": "lineaments.geojson",
-           "cpi_zones": "cpi_target_zones.geojson", "aoi": "aoi.geojson"}
+VECTORS = {"targets": "field_check_locations.geojson", "zones": "prospective_zones.geojson",
+           "lineaments": "lineaments.geojson", "cpi_zones": "cpi_target_zones.geojson", "aoi": "aoi.geojson"}
+OLD_NAMES = {"field_check_locations.geojson": "top50_targets.geojson"}      # results made before zones existed
 
 
 def _cache(run_dir: Path) -> Path:
@@ -160,7 +161,10 @@ def contours(run_dir: Path, key: str) -> gpd.GeoDataFrame:
 
 def vector(run_dir: Path, key: str) -> gpd.GeoDataFrame:
     name = VECTORS.get(key) or f"{key}.geojson"
-    g = gpd.read_file(run_dir / "vectors" / name)
+    path = run_dir / "vectors" / name
+    if not path.exists() and name in OLD_NAMES:
+        path = run_dir / "vectors" / OLD_NAMES[name]
+    g = gpd.read_file(path)
     return g.drop(columns=[c for c in g.columns if c in DROP_COLUMNS])
 
 

geoscan/geoscan/webapp/persist.py

@@ -51,13 +51,15 @@ def restore() -> int:
     return n
 
 
-def _upload(folder, message: str) -> bool:
+def _upload(folder, message: str, mirror: bool = False) -> bool:
+    """mirror=True also deletes stored files that no longer exist locally (results folders are rebuilt whole)."""
     if not enabled() or not folder.exists():
         return False
     rel = folder.relative_to(catalog.ROOT).as_posix()
     with _lock:
         _api().upload_folder(repo_id=repo(), repo_type="dataset", folder_path=str(folder), path_in_repo=rel,
-                             commit_message=message, ignore_patterns=IGNORE)
+                             commit_message=message, ignore_patterns=IGNORE,
+                             delete_patterns=["*"] if mirror else None)
     log.info("Saved %s to %s", rel, repo())
     return True
 
@@ -67,8 +69,8 @@ def save_area(area: str) -> bool:
 
 
 def save_run(output_name: str) -> bool:
-    ok = _upload(catalog.OUTPUTS / output_name, f"results: {output_name}")
-    _upload(catalog.OUTPUTS / f"{output_name}_validation", f"validation: {output_name}")
+    ok = _upload(catalog.OUTPUTS / output_name, f"results: {output_name}", mirror=True)
+    _upload(catalog.OUTPUTS / f"{output_name}_validation", f"validation: {output_name}", mirror=True)
     return ok
 
 

geoscan/geoscan/webapp/server.py

@@ -371,9 +371,21 @@ def map_png(run_id: str, name: str):
 @app.get("/api/runs/{run_id}/targets")
 def targets(run_id: str):
     r = _run(run_id)
-    df = pd.read_csv(r.path / "tables" / "top50_targets.csv")
+    path = r.path / "tables" / "field_check_locations.csv"
+    df = pd.read_csv(path if path.exists() else r.path / "tables" / "top50_targets.csv")
     df = df.drop(columns=[c for c in df.columns if c in layers.DROP_COLUMNS])
-    return df.where(pd.notna(df), None).to_dict(orient="records")
+    return df.astype(object).where(pd.notna(df), None).to_dict(orient="records")
+
+
+@app.get("/api/runs/{run_id}/zones")
+def zones(run_id: str):
+    """Ranked prospective zones (empty for results made before zones existed)."""
+    r = _run(run_id)
+    path = r.path / "tables" / "prospective_zones.csv"
+    if not path.exists():
+        return []
+    df = pd.read_csv(path)
+    return df.astype(object).where(pd.notna(df), None).to_dict(orient="records")
 
 
 @app.get("/api/runs/{run_id}/validation")

geoscan/geoscan/webapp/static/app.js

@@ -1,774 +1,816 @@
-"use strict";
-const $ = (s) => document.querySelector(s);
-const api = async (url, opts) => {
-  const r = await fetch(url, opts);
-  if (!r.ok) {
-    let msg = r.statusText;
-    try { msg = (await r.json()).detail || msg; } catch (e) { /* not JSON */ }
-    throw new Error(msg);
-  }
-  return r;
-};
-const getJSON = async (url) => (await api(url)).json();
-const esc = (s) => String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
-
-const S = { config: null, blocks: [], block: null, options: {}, params: {}, run: null, layer: "cpi", jobTimer: null, fitted: null };
-const CONTOUR_COLORS = ["#ffffff", "#ffeb3b", "#ff1744"];
-const TIER_COLORS = { "1": "#d50000", "2": "#ff9100", "3": "#9e9e9e" };
-
-/* ---------------- map ---------------- */
-const map = L.map("map", { zoomControl: true, preferCanvas: true }).setView([21, 79], 6);
-const bases = {
-  sat: L.tileLayer("https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
-    { maxZoom: 19, attribution: "Imagery © Esri, Maxar, Earthstar Geographics" }),
-  topo: L.tileLayer("https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png",
-    { maxZoom: 17, attribution: "© OpenStreetMap contributors, SRTM | © OpenTopoMap (CC-BY-SA)" }),
-};
-bases.sat.addTo(map);
-L.control.scale({ imperial: false }).addTo(map);
-const G = { overlay: null, na: null, contours: null, stations: null, targets: null, lineaments: null, zones: null, aoi: null, targetMarkers: {} };
-
-function clearLayer(k) { if (G[k]) { map.removeLayer(G[k]); G[k] = null; } }
-
-async function drawMap() {
-  const run = S.run;
-  ["overlay", "na", "contours", "stations", "targets", "lineaments", "zones", "aoi"].forEach(clearLayer);
-  if (!run) { renderLegend(null); return; }
-  const id = run.run_id;
-  const aoi = await getJSON(`/api/runs/${id}/vector/aoi.geojson`);
-  G.aoi = L.geoJSON(aoi, { style: { color: "#00e5ff", weight: 2, fill: false }, interactive: false }).addTo(map);
-  if (S.fitted !== run.block) { map.fitBounds(G.aoi.getBounds(), { padding: [30, 30] }); S.fitted = run.block; }
-  await drawRaster();
-  await drawVectors();
-}
-
-const refOf = (layer) => layer.startsWith("ref:") ? S.run.reference.find((r) => r.key === layer.slice(4)) : null;
-
-function rampColour(colors, t) {
-  return colors[Math.max(0, Math.min(colors.length - 1, Math.round(t * (colors.length - 1))))];
-}
-
-/* reference geophysics: surface (if any), black contours, stations coloured by value; never part of the CPI */
-async function drawReference(ref) {
-  const base = `/api/blocks/${S.run.block}/reference/${ref.key}`;
-  const info = await getJSON(`${base}/overlay`);
-  const lg = info.legend;
-  if (!info.none) {
-    G.overlay = L.imageOverlay(info.url, info.bounds, { opacity: +$("#opacity").value, interactive: false }).addTo(map);
-    if ($("#show-contours").checked) {
-      G.contours = L.geoJSON(await getJSON(`${base}/contours.geojson`), {
-        style: { color: "#111", weight: 1.2, opacity: 0.85 },
-        onEachFeature: (f, l) => l.bindTooltip(`${f.properties.level} ${f.properties.unit}`, { sticky: true }),
-      }).addTo(map);
-    }
-  }
-  G.stations = L.geoJSON(await getJSON(`${base}/stations.geojson`), {
-    // diamonds, so stations are not mistaken for drill targets (circles)
-    pointToLayer: (f, ll) => L.marker(ll, { icon: L.divIcon({ className: "", iconSize: [14, 14], iconAnchor: [7, 7],
-      html: `<span class="stn" style="background:${rampColour(lg.colors, (f.properties.value - lg.min) / (lg.max - lg.min || 1))}"></span>` }) }),
-    onEachFeature: (f, l) => l.bindTooltip(`<b>${f.properties.value} ${esc(f.properties.unit)}</b><br>station ${f.properties.station}` +
-      (f.properties.elevation_m != null ? `<br>elevation ${f.properties.elevation_m} m` : "")),
-  }).addTo(map);
-  return { ...lg, stations: ref.stations, spacing_m: ref.spacing_m, has_surface: ref.has_surface };
-}
-
-async function drawRaster() {
-  clearLayer("overlay"); clearLayer("contours"); clearLayer("na"); clearLayer("stations");
-  const run = S.run; if (!run) return;
-  let legend = null;
-  const ref = refOf(S.layer);
-  if (ref) {
-    legend = await drawReference(ref);
-    S.hatchShown = false;
-    S.legend = legend;
-    renderLegend(legend);
-    G.aoi && G.aoi.bringToFront();
-    G.targets && G.targets.bringToFront();
-    return;
-  }
-  if (S.layer !== "none") {
-    const info = await getJSON(`/api/runs/${run.run_id}/overlay/${S.layer}`);
-    G.overlay = L.imageOverlay(info.url, info.bounds, { opacity: +$("#opacity").value, interactive: false }).addTo(map);
-    legend = info.legend;
-    if ($("#show-contours").checked && info.legend.levels && info.legend.levels.length) {
-      const gj = await getJSON(`/api/runs/${run.run_id}/contours/${S.layer}.geojson`);
-      const lv = info.legend.levels;
-      G.contours = L.geoJSON(gj, {
-        style: (f) => ({ color: CONTOUR_COLORS[lv.indexOf(f.properties.level)] || "#fff", weight: 2, opacity: 0.95 }),
-        onEachFeature: (f, l) => l.bindTooltip(`${f.properties.level} ${f.properties.unit}`, { sticky: true }),
-      }).addTo(map);
-    }
-  }
-  S.hatchShown = false;
-  if ($("#show-na").checked && S.layer !== "none") {
-    // per layer: only EMIT-based layers can be "not assessed", and only where nothing was detected
-    const na = await getJSON(`/api/runs/${run.run_id}/overlay/na_${S.layer}`);
-    if (!na.none) {
-      G.na = L.imageOverlay(na.url, na.bounds, { opacity: 1, interactive: false }).addTo(map);
-      S.hatchShown = true;
-    }
-  }
-  S.legend = legend;
-  renderLegend(legend);
-  G.aoi && G.aoi.bringToFront();
-}
-
-async function drawVectors() {
-  ["targets", "lineaments", "zones"].forEach(clearLayer);
-  const id = S.run.run_id;
-  if ($("#show-zones").checked) {
-    const gj = await getJSON(`/api/runs/${id}/vector/cpi_zones.geojson`);
-    G.zones = L.geoJSON(gj, { style: (f) => ({ color: TIER_COLORS[(f.properties.class || "").match(/Tier (\d)/)?.[1]] || "#999",
-      weight: 1, fillOpacity: 0.25 }), onEachFeature: (f, l) => l.bindTooltip(f.properties.class) }).addTo(map);
-  }
-  if ($("#show-lineaments").checked) {
-    const gj = await getJSON(`/api/runs/${id}/vector/lineaments.geojson`);
-    G.lineaments = L.geoJSON(gj, {
-      style: (f) => f.properties.morphology === "scarp" ? { color: "#bdbdbd", weight: 1.5, dashArray: "5 4" }
-        : { color: "#00e676", weight: 2 },
-      onEachFeature: (f, l) => l.bindTooltip(`${f.properties.line_id || ""} · strike ${f.properties.strike_deg}° · ` +
-        `${Math.round(f.properties.length_m)} m · ${f.properties.morphology}` +
-        (f.properties.morphology === "scarp" ? " (not used for CPI)" : "")),
-    }).addTo(map);
-  }
-  if ($("#show-targets").checked) {
-    const gj = await getJSON(`/api/runs/${id}/vector/targets.geojson`);
-    G.targetMarkers = {};
-    G.targets = L.geoJSON(gj, {
-      pointToLayer: (f, ll) => {
-        const t = String(f.properties.Priority_Tier || "").match(/(\d)/)?.[1];
-        const m = L.circleMarker(ll, { radius: f.properties.Rank <= 10 ? 8 : 6, color: "#000", weight: 1,
-          fillColor: TIER_COLORS[t] || "#999", fillOpacity: 0.95 });
-        G.targetMarkers[f.properties.Rank] = m;
-        return m;
-      },
-      onEachFeature: (f, l) => l.bindPopup(targetPopup(f.properties)),
-    }).addTo(map);
-  }
-  G.aoi && G.aoi.bringToFront();
-}
-
-function targetPopup(p) {
-  const rows = [["CPI", `${(+p.CPI_Percent).toFixed(1)} %`], ["Tier", p.Priority_Tier], ["Muscovite", `${p.Muscovite_Pct} %`],
-    ["Quartz", `${p.Quartz_Pct} %`], ["Gossan", `${p.Gossan_Pct} %`], ["Chlorite", `${p.Chlorite_Pct} %`],
-    ["To lineament", `${p.Distance_to_Lineament_m} m`], ["Lat / Lon", `${(+p.Latitude).toFixed(5)}, ${(+p.Longitude).toFixed(5)}`]];
-  return `<b>#${p.Rank} ${esc(p.Target_Name || p.Target_ID)}</b><table>${rows.map(([k, v]) =>
-    `<tr><td>${k}</td><td><b>${esc(v)}</b></td></tr>`).join("")}</table>` +
-    (p.Exploration_Recommendation ? `<div class="small muted">${esc(p.Exploration_Recommendation)}</div>` : "");
-}
-
-function renderLegend(lg) {
-  const el = $("#legend");
-  let h = "";
-  if (lg && lg.kind === "ramp") {
-    h += `<b>${esc(lg.label)}</b><div class="ramp" style="background:linear-gradient(90deg,${lg.colors.join(",")})"></div>
-      <div class="ticks"><span>${lg.min}</span><span>${lg.unit}</span><span>${lg.max}</span></div>`;
-    if (lg.reference) {
-      h += `<div class="row"><span class="stn" style="background:#fff;margin:0 3px"></span>
-        ${lg.stations} stations${lg.spacing_m ? `, about ${(lg.spacing_m / 1000).toFixed(1)} km apart` : ""}</div>` +
-        (lg.has_surface ? ($("#show-contours").checked && lg.contour_step ? `<div class="row"><span class="sw" style="background:#111"></span>contours every ${lg.contour_step} ${lg.unit}</div>` : "") +
-          `<div class="small muted">Surface interpolated between stations.</div>`
-          : `<div class="small muted">Too few stations for a surface: points only.</div>`) +
-        `<div class="small" style="color:#b5532a"><b>Reference only</b>: not used in the CPI.</div>`;
-    }
-    if ($("#show-contours").checked && lg.levels.length)
-      h += lg.levels.map((v, i) => `<div class="row"><span class="sw" style="background:${CONTOUR_COLORS[i]};outline:1px solid #888"></span>${v} ${lg.unit} contour</div>`).join("");
-  }
-  if ($("#show-targets").checked)
-    h += `<div class="row"><span class="sw" style="background:${TIER_COLORS[1]};height:10px;width:10px;border-radius:50%"></span>Tier 1
-      <span class="sw" style="background:${TIER_COLORS[2]};height:10px;width:10px;border-radius:50%"></span>Tier 2
-      <span class="sw" style="background:${TIER_COLORS[3]};height:10px;width:10px;border-radius:50%"></span>Tier 3 targets</div>`;
-  if ($("#show-lineaments").checked)
-    h += `<div class="row"><span class="sw" style="background:#00e676"></span>Lineament
-      <span class="sw" style="background:repeating-linear-gradient(90deg,#bdbdbd 0 5px,transparent 5px 9px)"></span>Scarp</div>`;
-  if ($("#show-na").checked && S.hatchShown) h += `<div class="row"><span class="hatch"></span>Not assessed (no usable EMIT data)</div>`;
-  el.innerHTML = h;
-  el.hidden = !h;
-}
-
-/* ---------------- info pop-ups ---------------- */
-const TAG_TEXT = { EXP: "Expert choice (no external source)", ASM: "Project assumption", LIB: "Spectral library",
-  LIT: "Published literature", TEST: "Tested against ground truth" };
-
-function showInfo(key) {
-  const p = S.config.params[key], o = S.config.options[key];
-  const d = (p || o || {}).info || {};
-  const meta = [];
-  if (p) {
-    const dflt = p.kind === "bool" ? (p.default ? "yes" : "no") : `${p.default}${p.unit ? " " + p.unit : ""}`;
-    meta.push(`Default: <b>${esc(dflt)}</b>`);
-    if (p.kind !== "bool") meta.push(`Allowed: ${p.min} – ${p.max}${p.unit ? " " + esc(p.unit) : ""}`);
-    meta.push(`Source: <b>${p.tag}</b> · ${esc(TAG_TEXT[p.tag] || "")}`);
-    meta.push(`Group: ${esc(p.group)}`);
-  } else if (o) {
-    const c = o.choices.find((x) => String(x.value) === String(o.default));
-    meta.push(`Recommended: <b>${esc(c ? c.label : o.default)}</b>`);
-  }
-  const sec = (title, text, cls = "") => text ? `<div class="info-sec ${cls}"><h4>${title}</h4><p>${esc(text)}</p></div>` : "";
-  let body = `<div class="info-meta">${meta.map((m) => `<span>${m}</span>`).join("")}</div>`;
-  body += sec("What it is", d.what);
-  body += sec("How the method uses it", d.how, "formula");
-  if (d.choices) body += sec("The choices", d.choices);
-  if (d.up || d.down) {
-    const upLabel = p && p.kind === "bool" ? "When on" : o ? "Effect" : "If you raise it";
-    const downLabel = p && p.kind === "bool" ? "When off" : o ? "Otherwise" : "If you lower it";
-    body += `<div class="info-sec"><div class="updown"><div><b>${upLabel}</b>${esc(d.up || "")}</div>
-      <div><b>${downLabel}</b>${esc(d.down || "")}</div></div></div>`;
-  }
-  body += sec("Why this default", d.why);
-  body += sec("What our tests show", d.evidence, "evidence");
-  if (p && p.help && !d.how) body += sec("Note", p.help);
-  $("#info-title").textContent = (p || o).label;
-  $("#info-body").innerHTML = body;
-  $("#info").showModal();
-}
-
-function showLayerInfo(key) {
-  const ref = S.run && key.startsWith("ref:") ? refOf(key) : null;
-  if (ref) {
-    $("#info-title").textContent = ref.label;
-    $("#info-body").innerHTML = `<div class="info-meta"><span><b>${ref.stations}</b> stations</span>
-      ${ref.spacing_m ? `<span>about <b>${(ref.spacing_m / 1000).toFixed(1)} km</b> apart</span>` : ""}
-      <span>range <b>${ref.min} to ${ref.max} ${esc(ref.unit)}</b></span></div>
-      <div class="info-sec"><h4>What it is</h4><p>${esc(ref.what)}</p></div>
-      <div class="info-sec"><h4>What you see on the map</h4><p>${ref.has_surface
-        ? "The dots are the measured stations (hover for the value). The coloured surface and the contour lines are interpolated between them."
-        : "Only the measured stations are shown: there are too few to draw a surface."}</p></div>
-      <div class="info-sec evidence"><h4>How to read it</h4><p>${esc(ref.caveat)} A drill target is about 250 m across, so a pattern drawn from stations ${ref.spacing_m ? "about " + (ref.spacing_m / 1000).toFixed(1) + " km" : "this far"} apart cannot confirm or reject a single target.</p></div>
-      <div class="info-sec"><h4>Source</h4><p>${esc(ref.source)}</p></div>`;
-    $("#info").showModal();
-    return;
-  }
-  $("#info-title").textContent = S.config.layers[key];
-  $("#info-body").innerHTML = `<div class="info-sec"><p>${esc(S.config.layer_info[key] || "")}</p></div>`;
-  $("#info").showModal();
-}
-
-function infoButton(key, kind = "param") {
-  return `<button type="button" class="ibtn" data-info="${esc(key)}" data-kind="${kind}" title="What is this?" aria-label="Explain">i</button>`;
-}
-
-document.addEventListener("click", (ev) => {
-  const b = ev.target.closest(".ibtn[data-info]");
-  if (!b) return;
-  ev.preventDefault();
-  ev.stopPropagation();
-  if (b.dataset.kind === "layer") showLayerInfo(b.dataset.info);
-  else showInfo(b.dataset.info);
-}, true);
-$("#info-close").onclick = () => $("#info").close();
-$("#info").addEventListener("click", (ev) => { if (ev.target.id === "info") $("#info").close(); });
-
-/* ---------------- sidebar ---------------- */
-function renderOptions() {
-  const box = $("#options");
-  box.innerHTML = "";
-  for (const [key, o] of Object.entries(S.config.options)) {
-    const id = "opt-" + key.replace(/\./g, "-");
-    const d = document.createElement("div");
-    d.className = "opt";
-    d.innerHTML = `<label for="${id}">${esc(o.label)}${infoButton(key, "option")}</label><select id="${id}">${o.choices.map((c) =>
-      `<option value="${esc(c.value)}">${esc(c.label)}${c.value === o.default ? " ★" : ""}</option>`).join("")}</select>`;
-    box.appendChild(d);
-    const sel = d.querySelector("select");
-    sel.value = String(S.options[key]);
-    sel.onchange = () => {
-      const c = o.choices.find((x) => String(x.value) === sel.value);
-      S.options[key] = c.value;
-      selectRun();
-    };
-  }
-}
-
-function sameOptions(a, b) { return Object.keys(S.config.options).every((k) => String(a[k]) === String(b[k])); }
-function sameParams(a, b) { return Object.keys(S.config.params).every((k) => Number(a[k]) === Number(b[k])); }
-function sameRun(r) { return sameOptions(r.options, S.options) && sameParams(r.params, S.params); }
-function defaults(obj) { return Object.fromEntries(Object.entries(obj).map(([k, o]) => [k, o.default])); }
-
-const STEPS = ["acquire", "emit_l2a", "emit_l2b", "aster", "structure", "alteration", "targets", "maps"];
-const RERUN_TEXT = {
-  targets: "Only the CPI, targets and maps are recomputed (seconds).",
-  alteration: "Alteration layers, CPI, targets and maps are recomputed (about a minute).",
-  structure: "Lineaments, alteration, CPI, targets and maps are recomputed (a few minutes).",
-  emit_l2a: "EMIT detection is redone from the downloaded scenes (several minutes to an hour, depending on area size).",
-  acquire: "Full analysis including data download.",
-};
-
-function firstStep() {
-  const steps = [];
-  for (const [k, o] of Object.entries(S.config.options)) if (String(S.options[k]) !== String(o.default)) steps.push(o.step);
-  for (const [k, p] of Object.entries(S.config.params)) if (Number(S.params[k]) !== Number(p.default)) steps.push(p.step);
-  return steps.sort((a, b) => STEPS.indexOf(a) - STEPS.indexOf(b))[0] || null;
-}
-
-function weightSum() {
-  return ["muscovite", "quartz", "gossan", "chlorite"].reduce((a, m) => a + Number(S.params["targets.w_" + m]), 0);
-}
-
-function ruleProblems() {
-  const v = S.params, out = [];
-  const w = weightSum();
-  if (Math.abs(w - 1) > 0.005) out.push(`Mineral weights add up to ${w.toFixed(2)} (must be 1.00).`);
-  if (!(v["targets.tier1"] > v["targets.tier2"] && v["targets.tier2"] > v["targets.tier3"])) out.push("Tiers must decrease: Tier 1 > Tier 2 > Tier 3.");
-  if (!(v["alteration.sigma_halo_m"] > v["alteration.sigma_core_m"])) out.push("Halo σ must be larger than core σ.");
-  if (!(v["alteration.sericite_max_nm"] > v["alteration.sericite_min_nm"])) out.push("White-mica window: 'to' must be above 'from'.");
-  if (!(v["structure.canny_high_quantile"] > v["structure.canny_low_quantile"])) out.push("High edge quantile must be above the low one.");
-  if (!(v["structure.min_length_m"] >= v["structure.min_segment_m"])) out.push("Minimum lineament length must be at least the minimum Hough segment.");
-  for (const [k, p] of Object.entries(S.config.params)) {
-    if (p.kind !== "bool" && !(Number(v[k]) >= p.min && Number(v[k]) <= p.max)) out.push(`${p.label} must be between ${p.min} and ${p.max}.`);
-  }
-  return out;
-}
-
-function renderParams() {
-  const box = $("#params");
-  const groups = {};
-  for (const [k, p] of Object.entries(S.config.params)) (groups[p.group] = groups[p.group] || []).push([k, p]);
-  const first = !box.querySelector("details");
-  const open = new Set([...box.querySelectorAll("details[open]")].map((d) => d.dataset.group));
-  if (first) open.add(Object.keys(groups)[0]);
-  box.innerHTML = Object.entries(groups).map(([g, ps]) => {
-    const rows = ps.map(([k, p]) => {
-      const val = S.params[k], ch = Number(val) !== Number(p.default);
-      const input = p.kind === "bool" ? `<input type="checkbox" data-k="${k}"${val ? " checked" : ""}>`
-        : `<input type="number" data-k="${k}" value="${val}" min="${p.min}" max="${p.max}" step="${p.step_size}">`;
-      const dflt = p.kind === "bool" ? (p.default ? "yes" : "no") : p.default;
-      return `<div class="prow${ch ? " changed" : ""}" title="${esc(p.help || "")}">
-        <div class="pl">${esc(p.label)}<span class="tag">${p.tag}</span>${infoButton(k)}<span class="def">default ${dflt}${p.unit ? " " + esc(p.unit) : ""}</span></div>
-        ${input}${ch ? `<button type="button" class="reset" data-reset="${k}">reset</button>` : ""}</div>`;
-    }).join("");
-    const sum = g.startsWith("CPI") ? '<div id="wsum" class="psum"></div>' : "";
-    return `<details class="pgroup" data-group="${esc(g)}"${open.has(g) ? " open" : ""}><summary>${esc(g)}</summary>${sum}${rows}</details>`;
-  }).join("");
-  box.querySelectorAll("input[data-k]").forEach((i) => i.onchange = () => {
-    const p = S.config.params[i.dataset.k];
-    S.params[i.dataset.k] = p.kind === "bool" ? i.checked : Number(i.value);
-    renderParams();
-    selectRun();
-  });
-  box.querySelectorAll("[data-reset]").forEach((b) => b.onclick = () => {
-    S.params[b.dataset.reset] = S.config.params[b.dataset.reset].default;
-    renderParams();
-    selectRun();
-  });
-  const w = weightSum(), ws = $("#wsum");
-  if (ws) { ws.className = "psum " + (Math.abs(w - 1) <= 0.005 ? "ok" : "bad"); ws.textContent = `Mineral weights sum: ${w.toFixed(2)} (must be 1.00)`; }
-  const n = Object.entries(S.config.params).filter(([k, p]) => Number(S.params[k]) !== Number(p.default)).length;
-  $("#params-changed").hidden = !n;
-  $("#params-changed").textContent = `${n} changed`;
-}
-
-async function refreshBlocks(selectName) {
-  S.blocks = await getJSON("/api/blocks");
-  const sel = $("#block-select");
-  sel.innerHTML = S.blocks.map((b) => `<option value="${esc(b.block)}">${esc(b.block)}${b.area_km2 ? ` · ${b.area_km2} km²` : ""}</option>`).join("");
-  const name = selectName || (S.block && S.block.block) || (S.blocks[0] && S.blocks[0].block);
-  if (name) sel.value = name;
-  S.block = S.blocks.find((b) => b.block === sel.value) || null;
-}
-
-function renderBlockInfo() {
-  const b = S.block;
-  $("#block-info").textContent = b ? `${b.runs.length} result set(s)` + (b.has_ground_truth ? " · ground truth available" : "") +
-    (b.uploaded_by ? ` · uploaded by ${b.uploaded_by}` : "") : "";
-  const box = $("#computed");
-  if (!b || !b.runs.length) { box.innerHTML = ""; return; }
-  box.innerHTML = `<div class="title">Already computed for this area</div>` + b.runs.map((r) =>
-    `<button class="chip${S.run && S.run.run_id === r.run_id ? " active" : ""}" data-run="${esc(r.run_id)}" title="${esc(r.label)}">
-      ${r.recommended ? '<span class="rec">Recommended · </span>' : ""}${esc(Object.entries(r.options).map(([k, v]) =>
-        (S.config.options[k].choices.find((c) => String(c.value) === String(v)) || { label: v }).label).join(" · "))}
-      ${r.custom ? `<br><span class="small muted">Custom: ${esc(r.label.split("Custom parameters: ")[1] || "")}</span>` : ""}
-      ${r.created_by ? `<br><span class="small muted">by ${esc(r.created_by)}</span>` : ""}</button>`).join("");
-  box.querySelectorAll(".chip").forEach((c) => c.onclick = () => {
-    const r = b.runs.find((x) => x.run_id === c.dataset.run);
-    Object.assign(S.options, r.options);
-    Object.assign(S.params, r.params);
-    renderOptions();
-    renderParams();
-    selectRun();
-  });
-}
-
-async function selectRun() {
-  const b = S.block;
-  const st = $("#run-status"), btn = $("#run-btn"), bar = $("#run-bar");
-  const match = b && b.runs.find(sameRun);
-  const job = await activeJob();
-  if (match) {
-    st.className = "status ready";
-    st.textContent = match.recommended ? "Results ready (recommended method)." : match.custom ? "Results ready (custom parameters)." : "Results ready.";
-    bar.hidden = true;
-    // remember what is being viewed, so "Discard changes" can come back to it
-    S.last = { block: b.block, options: { ...S.options }, params: { ...S.params } };
-    if (!S.run || S.run.run_id !== match.run_id) await loadRun(match.run_id);
-  } else {
-    // keep showing the results that were on screen while settings are being edited
-    const keep = S.run && S.run.block === b.block;
-    if (!keep) S.run = null;
-    const running = job && job.block === b.block && sameOptions(job.options, S.options) && sameParams(job.params, S.params);
-    const probs = ruleProblems();
-    const fs = firstStep();
-    const note = b.runs.length && fs ? (RERUN_TEXT[fs] || RERUN_TEXT.acquire) : RERUN_TEXT.acquire;
-    st.className = "status " + (running ? "running" : "missing");
-    st.textContent = running ? "These settings are being computed now." : "Not computed yet for these settings. Use the bar at the bottom to run them.";
-    // the run bar stays fixed at the bottom of the side panel, wherever the panel is scrolled
-    const last = S.last && S.last.block === b.block ? S.last : null;
-    const n = last ? Object.keys(S.config.options).filter((k) => String(S.options[k]) !== String(last.options[k])).length +
-      Object.keys(S.config.params).filter((k) => Number(S.params[k]) !== Number(last.params[k])).length : 0;
-    $("#run-bar-text").innerHTML = (n ? `<b>${n} setting${n > 1 ? "s" : ""} changed.</b> ` : "<b>Not computed yet.</b> ") +
-      (probs.length ? `<div class="error">${probs.map(esc).join("<br>")}</div>` : esc(note)) +
-      (keep ? `<div class="muted">The map and tabs still show the previous results until you run.</div>` : "");
-    $("#run-discard").hidden = !last;
-    bar.hidden = !!running;
-    btn.disabled = probs.length > 0;
-    if (!keep) clearViews();
-  }
-  renderBlockInfo();
-}
-
-function clearViews() {
-  drawMap();
-  $("#gallery").innerHTML = `<div class="empty">No results for these options yet.</div>`;
-  $("#targets-table").innerHTML = "";
-  $("#validation").innerHTML = `<div class="empty">No results for these options yet.</div>`;
-  $("#download-groups").innerHTML = `<div class="empty">No results for these options yet.</div>`;
-}
-
-async function loadRun(runId) {
-  S.run = await getJSON(`/api/runs/${runId}`);
-  const known = [...S.run.layers, ...S.run.reference.map((r) => "ref:" + r.key), "none"];
-  if (!known.includes(S.layer)) S.layer = S.run.layers[0] || "none";
-  renderLayerRadios();
-  await Promise.all([drawMap(), renderGallery(), renderTargets(), renderValidation()]);
-  renderDownloads();
-}
-
-function renderLayerRadios() {
-  const box = $("#layer-radios");
-  const radio = (k, text) => `<label><input type="radio" name="layer" value="${k}"${k === S.layer ? " checked" : ""}> ${text}</label>`;
-  box.innerHTML = S.run.layers.map((k) => radio(k, esc(S.config.layers[k]) + infoButton(k, "layer"))).join("") +
-    (S.run.reference.length ? `<div class="ref-head">Reference geophysics <span>view only · not in the CPI</span></div>` +
-      S.run.reference.map((r) => radio("ref:" + r.key, esc(r.label) + infoButton("ref:" + r.key, "layer"))).join("") : "") +
-    radio("none", "None");
-  box.querySelectorAll("input").forEach((i) => i.onchange = () => { S.layer = i.value; drawRaster(); });
-}
-
-/* ---------------- tabs ---------------- */
-function renderGallery() {
-  const run = S.run;
-  const maps = [...run.maps.map((m) => ({ url: `/api/runs/${run.run_id}/map/${m.file}`, label: m.label, file: m.file })),
-    ...run.reference.map((r) => ({ url: `/api/blocks/${run.block}/reference/${r.key}/map.png`, file: `reference_${r.key}_map.png`,
-      label: `Reference (not in the CPI): ${r.label}` }))];
-  $("#gallery").innerHTML = maps.map((m) => `<figure><img src="${m.url}" alt="${esc(m.label)}" loading="lazy" data-full="${m.url}">
-      <figcaption><span>${esc(m.label)}</span><a href="${m.url}" download="${run.block}_${m.file}">Download PNG</a></figcaption></figure>`).join("");
-  $("#gallery").querySelectorAll("img").forEach((i) => i.onclick = () => { $("#lightbox-img").src = i.dataset.full; $("#lightbox").showModal(); });
-}
-
-async function renderTargets() {
-  const rows = await getJSON(`/api/runs/${S.run.run_id}/targets`);
-  const cols = [["Rank", "#"], ["Target_Name", "Target"], ["Priority_Tier", "Tier"], ["CPI_Percent", "CPI %"], ["Muscovite_Pct", "Musc %"],
-    ["Quartz_Pct", "Qtz %"], ["Gossan_Pct", "Goss %"], ["Chlorite_Pct", "Chl %"], ["Distance_to_Lineament_m", "To lineament (m)"],
-    ["Latitude", "Lat"], ["Longitude", "Lon"], ["Exploration_Recommendation", "Recommendation"]].filter(([k]) => rows.length && k in rows[0]);
-  const fmt = (k, v) => k === "Latitude" || k === "Longitude" ? (+v).toFixed(5) : k === "CPI_Percent" ? (+v).toFixed(1) : v;
-  $("#targets-table").innerHTML = `<thead><tr>${cols.map(([, h]) => `<th>${h}</th>`).join("")}</tr></thead><tbody>${rows.map((r) =>
-    `<tr data-rank="${r.Rank}" data-lat="${r.Latitude}" data-lon="${r.Longitude}">${cols.map(([k]) => {
-      const t = k === "Priority_Tier" ? ` class="tier${String(r[k]).match(/(\d)/)?.[1]}"` : typeof r[k] === "number" ? ' class="num"' : "";
-      return `<td${t}>${esc(fmt(k, r[k]))}</td>`;
-    }).join("")}</tr>`).join("")}</tbody>`;
-  $("#targets-table").querySelectorAll("tbody tr").forEach((tr) => tr.onclick = () => {
-    showTab("map");
-    map.setView([+tr.dataset.lat, +tr.dataset.lon], 16);
-    const m = G.targetMarkers[tr.dataset.rank];
-    if (m) m.openPopup();
-  });
-}
-
-async function renderValidation() {
-  const run = S.run, el = $("#validation");
-  if (!run.has_validation) {
-    el.innerHTML = `<div class="empty">No ground truth (boreholes, lodes or explored blocks) is available for this area,
-      so there is no validation. The maps and targets are still produced.</div>`;
-    return;
-  }
-  const v = await getJSON(`/api/runs/${run.run_id}/validation`);
-  el.innerHTML = marked.parse(v.summary) + run.validation_maps.map((m) =>
-    `<img src="/api/runs/${run.run_id}/validation/${m}" alt="">`).join("");
-}
-
-function renderDownloads() {
-  const run = S.run;
-  const groups = {};
-  run.downloads.forEach((d) => (groups[d.group] = groups[d.group] || []).push(d));
-  $("#download-groups").innerHTML = Object.entries(groups).map(([g, items]) => `<div class="dgroup"><h3>${esc(g)}
-    <button type="button" data-all>Select all</button></h3>${items.map((d) =>
-    `<label><input type="checkbox" value="${esc(d.id)}"${/^(map|vector):/.test(d.id) || d.id === "contour:cpi" ? " checked" : ""}> ${esc(d.label)}</label>`).join("")}</div>`).join("");
-  $("#download-groups").querySelectorAll("[data-all]").forEach((b) => b.onclick = () => {
-    const boxes = b.closest(".dgroup").querySelectorAll("input");
-    const all = [...boxes].every((x) => x.checked);
-    boxes.forEach((x) => (x.checked = !all));
-  });
-}
-
-function renderFormats() {
-  $("#formats").innerHTML = "Vector format:" + Object.entries(S.config.formats).map(([k, v]) =>
-    `<label><input type="checkbox" value="${k}"${k === "shp" ? " checked" : ""}> ${v}</label>`).join("");
-}
-
-$("#download-btn").onclick = async () => {
-  if (!S.run) return;
-  const items = [...document.querySelectorAll("#download-groups input:checked")].map((i) => i.value);
-  const formats = [...document.querySelectorAll("#formats input:checked")].map((i) => i.value);
-  if (!items.length) { alert("Select at least one item."); return; }
-  const btn = $("#download-btn");
-  btn.disabled = true; btn.textContent = "Preparing…";
-  try {
-    const r = await api(`/api/runs/${S.run.run_id}/download`, { method: "POST", headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ items, formats }) });
-    const blob = await r.blob();
-    const name = (r.headers.get("Content-Disposition") || "").match(/filename="(.+)"/)?.[1] || "geoscan.zip";
-    const a = document.createElement("a");
-    a.href = URL.createObjectURL(blob); a.download = name; a.click();
-    setTimeout(() => URL.revokeObjectURL(a.href), 5000);
-  } catch (e) { alert("Download failed: " + e.message); }
-  btn.disabled = false; btn.textContent = "Download selected (.zip)";
-};
-
-function showTab(name) {
-  document.querySelectorAll("#tabs button").forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
-  document.querySelectorAll(".tab-panel").forEach((p) => p.classList.toggle("active", p.id === "tab-" + name));
-  if (name === "map") setTimeout(() => map.invalidateSize(), 50);
-  if (name === "admin") renderAdmin();
-}
-document.querySelectorAll("#tabs button").forEach((b) => b.onclick = () => { showTab(b.dataset.tab); history.replaceState(null, "", "#" + b.dataset.tab); });
-
-/* ---------------- jobs ---------------- */
-async function activeJob() {
-  const js = await getJSON("/api/jobs");
-  return js.reverse().find((j) => j.status === "running" || j.status === "queued") || null;
-}
-
-function showJob(j) {
-  $("#job-card").hidden = false;
-  $("#job-title").textContent = `${j.block} · ${j.label}`;
-  $("#job-bar").style.width = `${Math.round(100 * j.progress)}%`;
-  $("#job-step").textContent = j.status === "failed" ? `Failed: ${j.error}` : j.status === "done" ? "Finished." :
-    j.status === "queued" ? "Waiting for another analysis to finish…" : j.step_label || "Starting…";
-  $("#job-log").textContent = j.log.join("\n");
-}
-
-function pollJob(jobId) {
-  clearInterval(S.jobTimer);
-  S.jobTimer = setInterval(async () => {
-    const j = await getJSON(`/api/jobs/${jobId}`);
-    showJob(j);
-    if (j.status === "done" || j.status === "failed") {
-      clearInterval(S.jobTimer);
-      if (j.status === "done") {
-        await refreshBlocks(j.block);
-        S.block = S.blocks.find((b) => b.block === j.block);
-        $("#block-select").value = j.block;
-        Object.assign(S.options, j.options);
-        Object.assign(S.params, j.params);
-        renderOptions();
-        renderParams();
-        await selectRun();
-      }
-    }
-  }, 3000);
-}
-
-$("#run-discard").onclick = () => {
-  if (!S.last) return;
-  S.options = { ...S.last.options };
-  S.params = { ...S.last.params };
-  renderOptions();
-  renderParams();
-  selectRun();
-};
-
-$("#run-btn").onclick = async () => {
-  const btn = $("#run-btn");
-  if (ruleProblems().length) return;
-  btn.disabled = true;
-  try {
-    const opts = {}, params = {};
-    Object.keys(S.config.options).forEach((k) => (opts[k] = S.options[k]));
-    Object.keys(S.config.params).forEach((k) => (params[k] = S.params[k]));
-    const r = await (await api("/api/runs", { method: "POST", headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ block: S.block.block, options: opts, params }) })).json();
-    if (r.run) { await refreshBlocks(); await selectRun(); }
-    else { showJob(r.job); pollJob(r.job.job_id); await selectRun(); }
-  } catch (e) { alert(e.message); }
-  btn.disabled = false;
-};
-
-/* ---------------- new area ---------------- */
-$("#new-area-btn").onclick = () => { $("#area-error").textContent = ""; $("#new-area").showModal(); };
-$("#area-cancel").onclick = () => $("#new-area").close();
-$("#new-area-form").onsubmit = async (ev) => {
-  ev.preventDefault();
-  const f = $("#area-file").files[0];
-  if (!f) return;
-  const fd = new FormData();
-  fd.append("file", f);
-  fd.append("name", $("#area-name").value);
-  $("#area-upload").disabled = true;
-  try {
-    const r = await (await api("/api/blocks", { method: "POST", body: fd })).json();
-    $("#new-area").close();
-    await refreshBlocks(r.block);
-    S.options = defaults(S.config.options);
-    S.params = defaults(S.config.params);
-    renderOptions();
-    renderParams();
-    S.run = null;
-    await selectRun();
-    if (!S.block.runs.length) $("#run-status").textContent = `New area uploaded (${r.area_km2} km²). Choose options and press Run.`;
-  } catch (e) { $("#area-error").textContent = e.message; }
-  $("#area-upload").disabled = false;
-};
-
-$("#block-select").onchange = async () => {
-  S.block = S.blocks.find((b) => b.block === $("#block-select").value);
-  S.run = null;
-  S.fitted = null;
-  await selectRun();
-};
-$("#opacity").oninput = () => G.overlay && G.overlay.setOpacity(+$("#opacity").value);
-["#show-contours", "#show-na"].forEach((s) => $(s).onchange = drawRaster);
-["#show-targets", "#show-lineaments", "#show-zones"].forEach((s) => $(s).onchange = async () => { await drawVectors(); renderLegend(S.legend || null); });
-document.querySelectorAll('input[name="base"]').forEach((r) => r.onchange = () => {
-  Object.values(bases).forEach((b) => map.removeLayer(b));
-  bases[r.value].addTo(map).bringToBack();
-});
-$("#lightbox-close").onclick = () => $("#lightbox").close();
-
-/* ---------------- accounts and admin ---------------- */
-const ACTION_TEXT = { session_start: "Signed in", upload_area: "Uploaded area", run_started: "Started analysis",
-  run_finished: "Analysis finished", run_failed: "Analysis failed", open_results: "Opened results", download: "Downloaded",
-  signed_out: "Signed out", user_added: "Added user", user_removed: "Removed user" };
-
-function logDetails(e) {
-  const d = [];
-  if (e.file) d.push(`file <b>${esc(e.file)}</b>${e.bytes ? ` (${(e.bytes / 1024).toFixed(1)} kB)` : ""}`);
-  if (e.area) d.push(`area <b>${esc(e.area)}</b>${e.area_km2 ? ` (${e.area_km2} km²)` : ""}`);
-  if (e.centre_lat) d.push(`centre ${e.centre_lat}, ${e.centre_lon}`);
-  if (e.result) d.push(esc(e.result));
-  if (e.settings) d.push(esc(e.settings));
-  if (e.changed_parameters) d.push("changed: " + Object.entries(e.changed_parameters).map(([k, v]) =>
-    `${esc((S.config.params[k] || { label: k }).label)} = ${esc(v)}`).join(", "));
-  if (e.recompute_from && e.action === "run_started") d.push(`recomputed from: ${esc(e.recompute_from)}`);
-  if (e.results && e.action !== "open_results") d.push(`results: ${esc(e.results)}`);
-  if (e.items) d.push(`${e.items.length} item(s): ${esc(e.items.join(", "))}${e.megabytes ? ` · ${e.megabytes} MB` : ""}`);
-  if (e.formats && e.action === "download") d.push(`formats: ${esc(e.formats.join(", "))}`);
-  if (e.error) d.push(`<span class="error">${esc(e.error)}</span>`);
-  if (e.account) d.push(`account <b>${esc(e.account)}</b>${e.note ? ` (${esc(e.note)})` : ""}`);
-  if (e.ip) d.push(`from ${esc(e.ip)}`);
-  if (e.browser) d.push(`<span class="muted">${esc(e.browser)}</span>`);
-  return d.join(" · ");
-}
-
-const localTime = (t) => t ? new Date(t).toLocaleString() : "";
-
-async function renderAdmin() {
-  const panel = $("#tab-admin");
-  if (!panel.firstElementChild) {
-    panel.appendChild($("#admin-template").content.cloneNode(true));
-    $("#user-form").onsubmit = async (ev) => {
-      ev.preventDefault();
-      $("#user-error").textContent = "";
-      try {
-        await api("/api/admin/users", { method: "POST", headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ user: $("#new-user").value, password: $("#new-pass").value, note: $("#new-note").value }) });
-        $("#user-form").reset();
-        renderAdmin();
-      } catch (e) { $("#user-error").textContent = e.message; }
-    };
-    $("#log-refresh").onclick = renderAdmin;
-    $("#log-user").onchange = () => drawLog();
-    $("#log-action").onchange = () => drawLog();
-  }
-  const [users, log] = await Promise.all([getJSON("/api/admin/users"), getJSON("/api/admin/log?limit=2000")]);
-  S.log = log;
-  $("#users-table").innerHTML = `<thead><tr><th>User</th><th>Role</th><th>Note</th><th>Created</th><th>Last active</th><th></th></tr></thead><tbody>` +
-    users.map((u) => `<tr><td><b>${esc(u.user)}</b></td><td>${esc(u.role)}</td><td>${esc(u.note)}</td>
-      <td class="nowrap">${esc(localTime(u.created))}</td><td class="nowrap">${esc(localTime(u.last_active))}</td>
-      <td>${u.role === "user" ? `<button class="linkbtn" data-remove="${esc(u.user)}">Remove</button>` : ""}</td></tr>`).join("") + "</tbody>";
-  $("#users-table").querySelectorAll("[data-remove]").forEach((b) => b.onclick = async () => {
-    if (!confirm(`Remove user "${b.dataset.remove}"? They will no longer be able to sign in.`)) return;
-    await api(`/api/admin/users/${encodeURIComponent(b.dataset.remove)}`, { method: "DELETE" });
-    renderAdmin();
-  });
-  const keep = (sel, values, all, label) => {
-    const cur = sel.value;
-    sel.innerHTML = `<option value="">${all}</option>` + values.map((v) => `<option value="${esc(v)}">${esc(label(v))}</option>`).join("");
-    sel.value = values.includes(cur) ? cur : "";
-  };
-  keep($("#log-user"), [...new Set(log.map((e) => e.user))].sort(), "All users", (v) => v);
-  keep($("#log-action"), [...new Set(log.map((e) => e.action))].sort(), "All actions", (v) => ACTION_TEXT[v] || v);
-  drawLog();
-}
-
-function drawLog() {
-  const u = $("#log-user").value, a = $("#log-action").value;
-  const rows = (S.log || []).filter((e) => (!u || e.user === u) && (!a || e.action === a));
-  $("#log-table").innerHTML = `<thead><tr><th>Time</th><th>User</th><th>Action</th><th>Details</th></tr></thead><tbody>` +
-    (rows.length ? rows.map((e) => `<tr style="cursor:default"><td class="nowrap">${esc(localTime(e.time))}</td><td><b>${esc(e.user)}</b></td>
-      <td class="nowrap"><span class="act ${esc(e.action)}">${esc(ACTION_TEXT[e.action] || e.action)}</span></td><td>${logDetails(e)}</td></tr>`).join("")
-      : `<tr><td colspan="4" class="muted">No activity recorded yet.</td></tr>`) + "</tbody>";
-}
-
-async function signOut(ev) {
-  ev.preventDefault();
-  try { await api("/api/signout", { method: "POST" }); } catch (e) { /* still sign out */ }
-  // Browsers keep a Basic-auth password until told otherwise: send wrong credentials on purpose so the
-  // stored ones are replaced, then show a signed-out page.
-  await new Promise((done) => {
-    const x = new XMLHttpRequest();
-    x.open("GET", "/api/logout", true, "signed-out", "signed-out");
-    x.onloadend = done;
-    x.send();
-  });
-  document.body.innerHTML = `<div class="signed-out"><h1>You are signed out</h1>
-    <p>Close this tab, or <a href="/">sign in again</a>.</p>
-    <p class="muted small">If the app opens without asking for a password, close all browser windows to finish signing out.</p></div>`;
-}
-
-async function initAccount() {
-  S.me = await getJSON("/api/me");
-  if (S.me.login) {
-    $("#whoami").hidden = false;
-    $("#whoami").innerHTML = `Signed in as <b>${esc(S.me.user)}</b> · activity is recorded · <a href="#" id="signout">Sign out</a>`;
-    $("#signout").onclick = signOut;
-  }
-  if (S.me.admin) $("#admin-tab-btn").hidden = false;
-}
-
-/* ---------------- start ---------------- */
-(async function init() {
-  S.config = await getJSON("/api/config");
-  await initAccount();
-  S.options = defaults(S.config.options);
-  S.params = defaults(S.config.params);
-  renderOptions();
-  renderParams();
-  renderFormats();
-  $("#params-reset").onclick = () => { S.params = defaults(S.config.params); renderParams(); selectRun(); };
-  await refreshBlocks();
-  await selectRun();
-  const j = await activeJob();
-  if (j) { showJob(j); pollJob(j.job_id); }
-  if (location.hash.includes("params")) $("#params-box").open = true;
-  // links can pre-set parameters, e.g. #params&set=targets.min_spacing_m:400
-  let preset = false;
-  for (const m of location.hash.matchAll(/set=([\w.]+):([\d.]+)/g)) {
-    if (S.config.params[m[1]]) { S.params[m[1]] = Number(m[2]); preset = true; }
-  }
-  if (preset) { renderParams(); await selectRun(); }
-  const lm = location.hash.match(/layer=([\w:]+)/);
-  if (lm && S.run && (S.run.layers.includes(lm[1]) || refOf(lm[1]))) { S.layer = lm[1]; renderLayerRadios(); await drawRaster(); }
-  const im = location.hash.match(/info=([\w.]+)/);
-  if (im && (S.config.params[im[1]] || S.config.options[im[1]])) showInfo(im[1]);
-  const tab = location.hash.slice(1).split("&")[0];
-  if (["map", "contours", "targets", "validation", "download", "guide", "admin"].includes(tab)) showTab(tab);
-})();
+"use strict";
+const $ = (s) => document.querySelector(s);
+const api = async (url, opts) => {
+  const r = await fetch(url, opts);
+  if (!r.ok) {
+    let msg = r.statusText;
+    try { msg = (await r.json()).detail || msg; } catch (e) { /* not JSON */ }
+    throw new Error(msg);
+  }
+  return r;
+};
+const getJSON = async (url) => (await api(url)).json();
+const esc = (s) => String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
+
+const S = { config: null, blocks: [], block: null, options: {}, params: {}, run: null, layer: "cpi", jobTimer: null, fitted: null };
+const CONTOUR_COLORS = ["#ffffff", "#ffeb3b", "#ff1744"];
+const TIER_COLORS = { "1": "#d50000", "2": "#ff9100", "3": "#9e9e9e" };
+
+/* ---------------- map ---------------- */
+const map = L.map("map", { zoomControl: true, preferCanvas: true }).setView([21, 79], 6);
+const bases = {
+  sat: L.tileLayer("https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
+    { maxZoom: 19, attribution: "Imagery © Esri, Maxar, Earthstar Geographics" }),
+  topo: L.tileLayer("https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png",
+    { maxZoom: 17, attribution: "© OpenStreetMap contributors, SRTM | © OpenTopoMap (CC-BY-SA)" }),
+};
+bases.sat.addTo(map);
+L.control.scale({ imperial: false }).addTo(map);
+const G = { overlay: null, na: null, contours: null, stations: null, targets: null, lineaments: null, zones: null, aoi: null, targetMarkers: {} };
+
+function clearLayer(k) { if (G[k]) { map.removeLayer(G[k]); G[k] = null; } }
+
+async function drawMap() {
+  const run = S.run;
+  ["overlay", "na", "contours", "stations", "targets", "lineaments", "zones", "aoi"].forEach(clearLayer);
+  if (!run) { renderLegend(null); return; }
+  const id = run.run_id;
+  const aoi = await getJSON(`/api/runs/${id}/vector/aoi.geojson`);
+  G.aoi = L.geoJSON(aoi, { style: { color: "#00e5ff", weight: 2, fill: false }, interactive: false }).addTo(map);
+  if (S.fitted !== run.block) { map.fitBounds(G.aoi.getBounds(), { padding: [30, 30] }); S.fitted = run.block; }
+  await drawRaster();
+  await drawVectors();
+}
+
+const refOf = (layer) => layer.startsWith("ref:") ? S.run.reference.find((r) => r.key === layer.slice(4)) : null;
+
+function rampColour(colors, t) {
+  return colors[Math.max(0, Math.min(colors.length - 1, Math.round(t * (colors.length - 1))))];
+}
+
+/* reference geophysics: surface (if any), black contours, stations coloured by value; never part of the CPI */
+async function drawReference(ref) {
+  const base = `/api/blocks/${S.run.block}/reference/${ref.key}`;
+  const info = await getJSON(`${base}/overlay`);
+  const lg = info.legend;
+  if (!info.none) {
+    G.overlay = L.imageOverlay(info.url, info.bounds, { opacity: +$("#opacity").value, interactive: false }).addTo(map);
+    if ($("#show-contours").checked) {
+      G.contours = L.geoJSON(await getJSON(`${base}/contours.geojson`), {
+        style: { color: "#111", weight: 1.2, opacity: 0.85 },
+        onEachFeature: (f, l) => l.bindTooltip(`${f.properties.level} ${f.properties.unit}`, { sticky: true }),
+      }).addTo(map);
+    }
+  }
+  G.stations = L.geoJSON(await getJSON(`${base}/stations.geojson`), {
+    // diamonds, so stations are not mistaken for field-check locations (circles)
+    pointToLayer: (f, ll) => L.marker(ll, { icon: L.divIcon({ className: "", iconSize: [14, 14], iconAnchor: [7, 7],
+      html: `<span class="stn" style="background:${rampColour(lg.colors, (f.properties.value - lg.min) / (lg.max - lg.min || 1))}"></span>` }) }),
+    onEachFeature: (f, l) => l.bindTooltip(`<b>${f.properties.value} ${esc(f.properties.unit)}</b><br>station ${f.properties.station}` +
+      (f.properties.elevation_m != null ? `<br>elevation ${f.properties.elevation_m} m` : "")),
+  }).addTo(map);
+  return { ...lg, stations: ref.stations, spacing_m: ref.spacing_m, has_surface: ref.has_surface };
+}
+
+async function drawRaster() {
+  clearLayer("overlay"); clearLayer("contours"); clearLayer("na"); clearLayer("stations");
+  const run = S.run; if (!run) return;
+  let legend = null;
+  const ref = refOf(S.layer);
+  if (ref) {
+    legend = await drawReference(ref);
+    S.hatchShown = false;
+    S.legend = legend;
+    renderLegend(legend);
+    G.aoi && G.aoi.bringToFront();
+    G.targets && G.targets.bringToFront();
+    return;
+  }
+  if (S.layer !== "none") {
+    const info = await getJSON(`/api/runs/${run.run_id}/overlay/${S.layer}`);
+    G.overlay = L.imageOverlay(info.url, info.bounds, { opacity: +$("#opacity").value, interactive: false }).addTo(map);
+    legend = info.legend;
+    if ($("#show-contours").checked && info.legend.levels && info.legend.levels.length) {
+      const gj = await getJSON(`/api/runs/${run.run_id}/contours/${S.layer}.geojson`);
+      const lv = info.legend.levels;
+      G.contours = L.geoJSON(gj, {
+        style: (f) => ({ color: CONTOUR_COLORS[lv.indexOf(f.properties.level)] || "#fff", weight: 2, opacity: 0.95 }),
+        onEachFeature: (f, l) => l.bindTooltip(`${f.properties.level} ${f.properties.unit}`, { sticky: true }),
+      }).addTo(map);
+    }
+  }
+  S.hatchShown = false;
+  if ($("#show-na").checked && S.layer !== "none") {
+    // per layer: only EMIT-based layers can be "not assessed", and only where nothing was detected
+    const na = await getJSON(`/api/runs/${run.run_id}/overlay/na_${S.layer}`);
+    if (!na.none) {
+      G.na = L.imageOverlay(na.url, na.bounds, { opacity: 1, interactive: false }).addTo(map);
+      S.hatchShown = true;
+    }
+  }
+  S.legend = legend;
+  renderLegend(legend);
+  G.aoi && G.aoi.bringToFront();
+}
+
+async function drawVectors() {
+  ["targets", "lineaments", "zones"].forEach(clearLayer);
+  const id = S.run.run_id;
+  G.zoneLayers = {};
+  if ($("#show-zones").checked) {
+    try {
+      const gj = await getJSON(`/api/runs/${id}/vector/zones.geojson`);
+      G.zones = L.geoJSON(gj, {
+        style: (f) => {
+          const t = String(f.properties.Priority_Tier || "").match(/(\d)/)?.[1];
+          return { color: TIER_COLORS[t] || "#999", weight: t === "3" ? 1.5 : 2.5, dashArray: t === "3" ? "5 4" : null,
+            fillColor: TIER_COLORS[t] || "#999", fillOpacity: 0.08 };
+        },
+        onEachFeature: (f, l) => {
+          G.zoneLayers[f.properties.Zone_ID] = l;
+          l.bindPopup(zonePopup(f.properties));
+          if (f.properties.Zone <= 12) l.bindTooltip(f.properties.Zone_ID, { permanent: true, direction: "center", className: "zone-label" });
+        },
+      }).addTo(map);
+    } catch (e) { /* results made before zones existed have no zone file */ }
+  }
+  if ($("#show-lineaments").checked) {
+    const gj = await getJSON(`/api/runs/${id}/vector/lineaments.geojson`);
+    G.lineaments = L.geoJSON(gj, {
+      style: (f) => f.properties.morphology === "scarp" ? { color: "#bdbdbd", weight: 1.5, dashArray: "5 4" }
+        : { color: "#00e676", weight: 2 },
+      onEachFeature: (f, l) => l.bindTooltip(`${f.properties.line_id || ""} · strike ${f.properties.strike_deg}° · ` +
+        `${Math.round(f.properties.length_m)} m · ${f.properties.morphology}` +
+        (f.properties.morphology === "scarp" ? " (not used for CPI)" : "")),
+    }).addTo(map);
+  }
+  if ($("#show-targets").checked) {
+    const gj = await getJSON(`/api/runs/${id}/vector/targets.geojson`);
+    G.targetMarkers = {};
+    G.targets = L.geoJSON(gj, {
+      pointToLayer: (f, ll) => {
+        const t = String(f.properties.Priority_Tier || "").match(/(\d)/)?.[1];
+        const m = L.circleMarker(ll, { radius: f.properties.Rank <= 10 ? 8 : 6, color: "#000", weight: 1,
+          fillColor: TIER_COLORS[t] || "#999", fillOpacity: 0.95 });
+        G.targetMarkers[f.properties.Rank] = m;
+        return m;
+      },
+      onEachFeature: (f, l) => l.bindPopup(targetPopup(f.properties)),
+    }).addTo(map);
+  }
+  G.aoi && G.aoi.bringToFront();
+}
+
+function zonePopup(p) {
+  const rows = [["Tier", p.Priority_Tier], ["Area", `${p.Area_km2} km²`], ["Peak / mean CPI", `${p.CPI_Max_Pct} % / ${p.CPI_Mean_Pct} %`],
+    ["Main evidence", p.Main_Evidence], ["Muscovite · Quartz", `${p.Muscovite_Pct} % · ${p.Quartz_Pct} %`],
+    ["Gossan · Chlorite", `${p.Gossan_Pct} % · ${p.Chlorite_Pct} %`], ["Lineaments inside", `${p.Lineaments_km} km`],
+    ["Field-check locations", p.Field_Check_Locations], ["Based on", p.Evidence_Basis]];
+  return `<b>Zone ${esc(p.Zone_ID)}</b><table>${rows.map(([k, v]) => `<tr><td>${k}</td><td><b>${esc(v)}</b></td></tr>`).join("")}</table>
+    <div class="small muted">Suggested follow-up: ${esc(p.Suggested_Follow_Up)}</div>`;
+}
+
+function targetPopup(p) {
+  const rows = [["Zone", p.Zone], ["CPI", `${(+p.CPI_Percent).toFixed(1)} %`], ["Tier", p.Priority_Tier], ["Muscovite", `${p.Muscovite_Pct} %`],
+    ["Quartz", `${p.Quartz_Pct} %`], ["Gossan", `${p.Gossan_Pct} %`], ["Chlorite", `${p.Chlorite_Pct} %`],
+    ["To lineament", `${p.Distance_to_Lineament_m} m`], ["Lat / Lon", `${(+p.Latitude).toFixed(4)}, ${(+p.Longitude).toFixed(4)}`]]
+    .filter(([, v]) => v != null && v !== "undefined %" && v !== "");
+  const follow = p.Suggested_Follow_Up || "";
+  return `<b>#${p.Rank} ${esc(p.Location_Name || p.Target_Name || p.Location_ID || p.Target_ID)}</b>
+    <div class="small muted">Suggested field-check location${p.Check_Within_m ? `: look within about ${p.Check_Within_m} m` : ""}. Not a drill collar.</div>
+    <table>${rows.map(([k, v]) => `<tr><td>${k}</td><td><b>${esc(v)}</b></td></tr>`).join("")}</table>` +
+    (follow ? `<div class="small muted">Suggested follow-up: ${esc(follow)}</div>` : "");
+}
+
+function renderLegend(lg) {
+  const el = $("#legend");
+  let h = "";
+  if (lg && lg.kind === "ramp") {
+    h += `<b>${esc(lg.label)}</b><div class="ramp" style="background:linear-gradient(90deg,${lg.colors.join(",")})"></div>
+      <div class="ticks"><span>${lg.min}</span><span>${lg.unit}</span><span>${lg.max}</span></div>`;
+    if (lg.reference) {
+      h += `<div class="row"><span class="stn" style="background:#fff;margin:0 3px"></span>
+        ${lg.stations} stations${lg.spacing_m ? `, about ${(lg.spacing_m / 1000).toFixed(1)} km apart` : ""}</div>` +
+        (lg.has_surface ? ($("#show-contours").checked && lg.contour_step ? `<div class="row"><span class="sw" style="background:#111"></span>contours every ${lg.contour_step} ${lg.unit}</div>` : "") +
+          `<div class="small muted">Surface interpolated between stations.</div>`
+          : `<div class="small muted">Too few stations for a surface: points only.</div>`) +
+        `<div class="small" style="color:#b5532a"><b>Reference only</b>: not used in the CPI.</div>`;
+    }
+    if ($("#show-contours").checked && lg.levels.length)
+      h += lg.levels.map((v, i) => `<div class="row"><span class="sw" style="background:${CONTOUR_COLORS[i]};outline:1px solid #888"></span>${v} ${lg.unit} contour</div>`).join("");
+  }
+  if ($("#show-targets").checked)
+    h += `<div class="row"><span class="sw" style="background:${TIER_COLORS[1]};height:10px;width:10px;border-radius:50%"></span>Tier 1
+      <span class="sw" style="background:${TIER_COLORS[2]};height:10px;width:10px;border-radius:50%"></span>Tier 2
+      <span class="sw" style="background:${TIER_COLORS[3]};height:10px;width:10px;border-radius:50%"></span>Tier 3 field-check locations</div>`;
+  if ($("#show-zones").checked && G.zones)
+    h += `<div class="row"><span class="sw" style="height:10px;width:16px;background:rgba(213,0,0,.1);outline:2px solid ${TIER_COLORS[1]}"></span>Prospective zone, coloured by tier</div>`;
+  if ($("#show-lineaments").checked)
+    h += `<div class="row"><span class="sw" style="background:#00e676"></span>Lineament
+      <span class="sw" style="background:repeating-linear-gradient(90deg,#bdbdbd 0 5px,transparent 5px 9px)"></span>Scarp</div>`;
+  if ($("#show-na").checked && S.hatchShown) h += `<div class="row"><span class="hatch"></span>Not assessed (no usable EMIT data)</div>`;
+  el.innerHTML = h;
+  el.hidden = !h;
+}
+
+/* ---------------- info pop-ups ---------------- */
+const TAG_TEXT = { EXP: "Expert choice (no external source)", ASM: "Project assumption", LIB: "Spectral library",
+  LIT: "Published literature", TEST: "Tested against ground truth" };
+
+function showInfo(key) {
+  const p = S.config.params[key], o = S.config.options[key];
+  const d = (p || o || {}).info || {};
+  const meta = [];
+  if (p) {
+    const dflt = p.kind === "bool" ? (p.default ? "yes" : "no") : `${p.default}${p.unit ? " " + p.unit : ""}`;
+    meta.push(`Default: <b>${esc(dflt)}</b>`);
+    if (p.kind !== "bool") meta.push(`Allowed: ${p.min} – ${p.max}${p.unit ? " " + esc(p.unit) : ""}`);
+    meta.push(`Source: <b>${p.tag}</b> · ${esc(TAG_TEXT[p.tag] || "")}`);
+    meta.push(`Group: ${esc(p.group)}`);
+  } else if (o) {
+    const c = o.choices.find((x) => String(x.value) === String(o.default));
+    meta.push(`Recommended: <b>${esc(c ? c.label : o.default)}</b>`);
+  }
+  const sec = (title, text, cls = "") => text ? `<div class="info-sec ${cls}"><h4>${title}</h4><p>${esc(text)}</p></div>` : "";
+  let body = `<div class="info-meta">${meta.map((m) => `<span>${m}</span>`).join("")}</div>`;
+  body += sec("What it is", d.what);
+  body += sec("How the method uses it", d.how, "formula");
+  if (d.choices) body += sec("The choices", d.choices);
+  if (d.up || d.down) {
+    const upLabel = p && p.kind === "bool" ? "When on" : o ? "Effect" : "If you raise it";
+    const downLabel = p && p.kind === "bool" ? "When off" : o ? "Otherwise" : "If you lower it";
+    body += `<div class="info-sec"><div class="updown"><div><b>${upLabel}</b>${esc(d.up || "")}</div>
+      <div><b>${downLabel}</b>${esc(d.down || "")}</div></div></div>`;
+  }
+  body += sec("Why this default", d.why);
+  body += sec("What our tests show", d.evidence, "evidence");
+  if (p && p.help && !d.how) body += sec("Note", p.help);
+  $("#info-title").textContent = (p || o).label;
+  $("#info-body").innerHTML = body;
+  $("#info").showModal();
+}
+
+function showLayerInfo(key) {
+  const ref = S.run && key.startsWith("ref:") ? refOf(key) : null;
+  if (ref) {
+    $("#info-title").textContent = ref.label;
+    $("#info-body").innerHTML = `<div class="info-meta"><span><b>${ref.stations}</b> stations</span>
+      ${ref.spacing_m ? `<span>about <b>${(ref.spacing_m / 1000).toFixed(1)} km</b> apart</span>` : ""}
+      <span>range <b>${ref.min} to ${ref.max} ${esc(ref.unit)}</b></span></div>
+      <div class="info-sec"><h4>What it is</h4><p>${esc(ref.what)}</p></div>
+      <div class="info-sec"><h4>What you see on the map</h4><p>${ref.has_surface
+        ? "The dots are the measured stations (hover for the value). The coloured surface and the contour lines are interpolated between them."
+        : "Only the measured stations are shown: there are too few to draw a surface."}</p></div>
+      <div class="info-sec evidence"><h4>How to read it</h4><p>${esc(ref.caveat)} A zone is a few hundred metres across, so a pattern drawn from stations ${ref.spacing_m ? "about " + (ref.spacing_m / 1000).toFixed(1) + " km" : "this far"} apart cannot confirm or reject a single zone.</p></div>
+      <div class="info-sec"><h4>Source</h4><p>${esc(ref.source)}</p></div>`;
+    $("#info").showModal();
+    return;
+  }
+  $("#info-title").textContent = S.config.layers[key];
+  $("#info-body").innerHTML = `<div class="info-sec"><p>${esc(S.config.layer_info[key] || "")}</p></div>`;
+  $("#info").showModal();
+}
+
+function infoButton(key, kind = "param") {
+  return `<button type="button" class="ibtn" data-info="${esc(key)}" data-kind="${kind}" title="What is this?" aria-label="Explain">i</button>`;
+}
+
+document.addEventListener("click", (ev) => {
+  const b = ev.target.closest(".ibtn[data-info]");
+  if (!b) return;
+  ev.preventDefault();
+  ev.stopPropagation();
+  if (b.dataset.kind === "layer") showLayerInfo(b.dataset.info);
+  else showInfo(b.dataset.info);
+}, true);
+$("#info-close").onclick = () => $("#info").close();
+$("#info").addEventListener("click", (ev) => { if (ev.target.id === "info") $("#info").close(); });
+
+/* ---------------- sidebar ---------------- */
+function renderOptions() {
+  const box = $("#options");
+  box.innerHTML = "";
+  for (const [key, o] of Object.entries(S.config.options)) {
+    const id = "opt-" + key.replace(/\./g, "-");
+    const d = document.createElement("div");
+    d.className = "opt";
+    d.innerHTML = `<label for="${id}">${esc(o.label)}${infoButton(key, "option")}</label><select id="${id}">${o.choices.map((c) =>
+      `<option value="${esc(c.value)}">${esc(c.label)}${c.value === o.default ? " ★" : ""}</option>`).join("")}</select>`;
+    box.appendChild(d);
+    const sel = d.querySelector("select");
+    sel.value = String(S.options[key]);
+    sel.onchange = () => {
+      const c = o.choices.find((x) => String(x.value) === sel.value);
+      S.options[key] = c.value;
+      selectRun();
+    };
+  }
+}
+
+function sameOptions(a, b) { return Object.keys(S.config.options).every((k) => String(a[k]) === String(b[k])); }
+function sameParams(a, b) { return Object.keys(S.config.params).every((k) => Number(a[k]) === Number(b[k])); }
+function sameRun(r) { return sameOptions(r.options, S.options) && sameParams(r.params, S.params); }
+function defaults(obj) { return Object.fromEntries(Object.entries(obj).map(([k, o]) => [k, o.default])); }
+
+const STEPS = ["acquire", "emit_l2a", "emit_l2b", "aster", "structure", "alteration", "targets", "maps"];
+const RERUN_TEXT = {
+  targets: "Only the CPI, zones, field-check locations and maps are recomputed (seconds).",
+  alteration: "Alteration layers, CPI, zones and maps are recomputed (about a minute).",
+  structure: "Lineaments, alteration, CPI, zones and maps are recomputed (a few minutes).",
+  emit_l2a: "EMIT detection is redone from the downloaded scenes (several minutes to an hour, depending on area size).",
+  acquire: "Full analysis including data download.",
+};
+
+function firstStep() {
+  const steps = [];
+  for (const [k, o] of Object.entries(S.config.options)) if (String(S.options[k]) !== String(o.default)) steps.push(o.step);
+  for (const [k, p] of Object.entries(S.config.params)) if (Number(S.params[k]) !== Number(p.default)) steps.push(p.step);
+  return steps.sort((a, b) => STEPS.indexOf(a) - STEPS.indexOf(b))[0] || null;
+}
+
+function weightSum() {
+  return ["muscovite", "quartz", "gossan", "chlorite"].reduce((a, m) => a + Number(S.params["targets.w_" + m]), 0);
+}
+
+function ruleProblems() {
+  const v = S.params, out = [];
+  const w = weightSum();
+  if (Math.abs(w - 1) > 0.005) out.push(`Mineral weights add up to ${w.toFixed(2)} (must be 1.00).`);
+  if (!(v["targets.tier1"] > v["targets.tier2"] && v["targets.tier2"] > v["targets.tier3"])) out.push("Tiers must decrease: Tier 1 > Tier 2 > Tier 3.");
+  if (!(v["alteration.sigma_halo_m"] > v["alteration.sigma_core_m"])) out.push("Halo σ must be larger than core σ.");
+  if (!(v["alteration.sericite_max_nm"] > v["alteration.sericite_min_nm"])) out.push("White-mica window: 'to' must be above 'from'.");
+  if (!(v["structure.canny_high_quantile"] > v["structure.canny_low_quantile"])) out.push("High edge quantile must be above the low one.");
+  if (!(v["structure.min_length_m"] >= v["structure.min_segment_m"])) out.push("Minimum lineament length must be at least the minimum Hough segment.");
+  for (const [k, p] of Object.entries(S.config.params)) {
+    if (p.kind !== "bool" && !(Number(v[k]) >= p.min && Number(v[k]) <= p.max)) out.push(`${p.label} must be between ${p.min} and ${p.max}.`);
+  }
+  return out;
+}
+
+function renderParams() {
+  const box = $("#params");
+  const groups = {};
+  for (const [k, p] of Object.entries(S.config.params)) (groups[p.group] = groups[p.group] || []).push([k, p]);
+  const first = !box.querySelector("details");
+  const open = new Set([...box.querySelectorAll("details[open]")].map((d) => d.dataset.group));
+  if (first) open.add(Object.keys(groups)[0]);
+  box.innerHTML = Object.entries(groups).map(([g, ps]) => {
+    const rows = ps.map(([k, p]) => {
+      const val = S.params[k], ch = Number(val) !== Number(p.default);
+      const input = p.kind === "bool" ? `<input type="checkbox" data-k="${k}"${val ? " checked" : ""}>`
+        : `<input type="number" data-k="${k}" value="${val}" min="${p.min}" max="${p.max}" step="${p.step_size}">`;
+      const dflt = p.kind === "bool" ? (p.default ? "yes" : "no") : p.default;
+      return `<div class="prow${ch ? " changed" : ""}" title="${esc(p.help || "")}">
+        <div class="pl">${esc(p.label)}<span class="tag">${p.tag}</span>${infoButton(k)}<span class="def">default ${dflt}${p.unit ? " " + esc(p.unit) : ""}</span></div>
+        ${input}${ch ? `<button type="button" class="reset" data-reset="${k}">reset</button>` : ""}</div>`;
+    }).join("");
+    const sum = g.startsWith("CPI") ? '<div id="wsum" class="psum"></div>' : "";
+    return `<details class="pgroup" data-group="${esc(g)}"${open.has(g) ? " open" : ""}><summary>${esc(g)}</summary>${sum}${rows}</details>`;
+  }).join("");
+  box.querySelectorAll("input[data-k]").forEach((i) => i.onchange = () => {
+    const p = S.config.params[i.dataset.k];
+    S.params[i.dataset.k] = p.kind === "bool" ? i.checked : Number(i.value);
+    renderParams();
+    selectRun();
+  });
+  box.querySelectorAll("[data-reset]").forEach((b) => b.onclick = () => {
+    S.params[b.dataset.reset] = S.config.params[b.dataset.reset].default;
+    renderParams();
+    selectRun();
+  });
+  const w = weightSum(), ws = $("#wsum");
+  if (ws) { ws.className = "psum " + (Math.abs(w - 1) <= 0.005 ? "ok" : "bad"); ws.textContent = `Mineral weights sum: ${w.toFixed(2)} (must be 1.00)`; }
+  const n = Object.entries(S.config.params).filter(([k, p]) => Number(S.params[k]) !== Number(p.default)).length;
+  $("#params-changed").hidden = !n;
+  $("#params-changed").textContent = `${n} changed`;
+}
+
+async function refreshBlocks(selectName) {
+  S.blocks = await getJSON("/api/blocks");
+  const sel = $("#block-select");
+  sel.innerHTML = S.blocks.map((b) => `<option value="${esc(b.block)}">${esc(b.block)}${b.area_km2 ? ` · ${b.area_km2} km²` : ""}</option>`).join("");
+  const name = selectName || (S.block && S.block.block) || (S.blocks[0] && S.blocks[0].block);
+  if (name) sel.value = name;
+  S.block = S.blocks.find((b) => b.block === sel.value) || null;
+}
+
+function renderBlockInfo() {
+  const b = S.block;
+  $("#block-info").textContent = b ? `${b.runs.length} result set(s)` + (b.has_ground_truth ? " · ground truth available" : "") +
+    (b.uploaded_by ? ` · uploaded by ${b.uploaded_by}` : "") : "";
+  const box = $("#computed");
+  if (!b || !b.runs.length) { box.innerHTML = ""; return; }
+  box.innerHTML = `<div class="title">Already computed for this area</div>` + b.runs.map((r) =>
+    `<button class="chip${S.run && S.run.run_id === r.run_id ? " active" : ""}" data-run="${esc(r.run_id)}" title="${esc(r.label)}">
+      ${r.recommended ? '<span class="rec">Recommended · </span>' : ""}${esc(Object.entries(r.options).map(([k, v]) =>
+        (S.config.options[k].choices.find((c) => String(c.value) === String(v)) || { label: v }).label).join(" · "))}
+      ${r.custom ? `<br><span class="small muted">Custom: ${esc(r.label.split("Custom parameters: ")[1] || "")}</span>` : ""}
+      ${r.created_by ? `<br><span class="small muted">by ${esc(r.created_by)}</span>` : ""}</button>`).join("");
+  box.querySelectorAll(".chip").forEach((c) => c.onclick = () => {
+    const r = b.runs.find((x) => x.run_id === c.dataset.run);
+    Object.assign(S.options, r.options);
+    Object.assign(S.params, r.params);
+    renderOptions();
+    renderParams();
+    selectRun();
+  });
+}
+
+async function selectRun() {
+  const b = S.block;
+  const st = $("#run-status"), btn = $("#run-btn"), bar = $("#run-bar");
+  const match = b && b.runs.find(sameRun);
+  const job = await activeJob();
+  if (match) {
+    st.className = "status ready";
+    st.textContent = match.recommended ? "Results ready (recommended method)." : match.custom ? "Results ready (custom parameters)." : "Results ready.";
+    bar.hidden = true;
+    // remember what is being viewed, so "Discard changes" can come back to it
+    S.last = { block: b.block, options: { ...S.options }, params: { ...S.params } };
+    if (!S.run || S.run.run_id !== match.run_id) await loadRun(match.run_id);
+  } else {
+    // keep showing the results that were on screen while settings are being edited
+    const keep = S.run && S.run.block === b.block;
+    if (!keep) S.run = null;
+    const running = job && job.block === b.block && sameOptions(job.options, S.options) && sameParams(job.params, S.params);
+    const probs = ruleProblems();
+    const fs = firstStep();
+    const note = b.runs.length && fs ? (RERUN_TEXT[fs] || RERUN_TEXT.acquire) : RERUN_TEXT.acquire;
+    st.className = "status " + (running ? "running" : "missing");
+    st.textContent = running ? "These settings are being computed now." : "Not computed yet for these settings. Use the bar at the bottom to run them.";
+    // the run bar stays fixed at the bottom of the side panel, wherever the panel is scrolled
+    const last = S.last && S.last.block === b.block ? S.last : null;
+    const n = last ? Object.keys(S.config.options).filter((k) => String(S.options[k]) !== String(last.options[k])).length +
+      Object.keys(S.config.params).filter((k) => Number(S.params[k]) !== Number(last.params[k])).length : 0;
+    $("#run-bar-text").innerHTML = (n ? `<b>${n} setting${n > 1 ? "s" : ""} changed.</b> ` : "<b>Not computed yet.</b> ") +
+      (probs.length ? `<div class="error">${probs.map(esc).join("<br>")}</div>` : esc(note)) +
+      (keep ? `<div class="muted">The map and tabs still show the previous results until you run.</div>` : "");
+    $("#run-discard").hidden = !last;
+    bar.hidden = !!running;
+    btn.disabled = probs.length > 0;
+    if (!keep) clearViews();
+  }
+  renderBlockInfo();
+}
+
+function clearViews() {
+  drawMap();
+  $("#gallery").innerHTML = `<div class="empty">No results for these options yet.</div>`;
+  $("#targets-table").innerHTML = "";
+  $("#validation").innerHTML = `<div class="empty">No results for these options yet.</div>`;
+  $("#download-groups").innerHTML = `<div class="empty">No results for these options yet.</div>`;
+}
+
+async function loadRun(runId) {
+  S.run = await getJSON(`/api/runs/${runId}`);
+  const known = [...S.run.layers, ...S.run.reference.map((r) => "ref:" + r.key), "none"];
+  if (!known.includes(S.layer)) S.layer = S.run.layers[0] || "none";
+  renderLayerRadios();
+  await Promise.all([drawMap(), renderGallery(), renderTargets(), renderValidation()]);
+  renderDownloads();
+}
+
+function renderLayerRadios() {
+  const box = $("#layer-radios");
+  const radio = (k, text) => `<label><input type="radio" name="layer" value="${k}"${k === S.layer ? " checked" : ""}> ${text}</label>`;
+  box.innerHTML = S.run.layers.map((k) => radio(k, esc(S.config.layers[k]) + infoButton(k, "layer"))).join("") +
+    (S.run.reference.length ? `<div class="ref-head">Reference geophysics <span>view only · not in the CPI</span></div>` +
+      S.run.reference.map((r) => radio("ref:" + r.key, esc(r.label) + infoButton("ref:" + r.key, "layer"))).join("") : "") +
+    radio("none", "None");
+  box.querySelectorAll("input").forEach((i) => i.onchange = () => { S.layer = i.value; drawRaster(); });
+}
+
+/* ---------------- tabs ---------------- */
+function renderGallery() {
+  const run = S.run;
+  const maps = [...run.maps.map((m) => ({ url: `/api/runs/${run.run_id}/map/${m.file}`, label: m.label, file: m.file })),
+    ...run.reference.map((r) => ({ url: `/api/blocks/${run.block}/reference/${r.key}/map.png`, file: `reference_${r.key}_map.png`,
+      label: `Reference (not in the CPI): ${r.label}` }))];
+  $("#gallery").innerHTML = maps.map((m) => `<figure><img src="${m.url}" alt="${esc(m.label)}" loading="lazy" data-full="${m.url}">
+      <figcaption><span>${esc(m.label)}</span><a href="${m.url}" download="${run.block}_${m.file}">Download PNG</a></figcaption></figure>`).join("");
+  $("#gallery").querySelectorAll("img").forEach((i) => i.onclick = () => { $("#lightbox-img").src = i.dataset.full; $("#lightbox").showModal(); });
+}
+
+async function renderTargets() {
+  const [zones, rows] = await Promise.all([getJSON(`/api/runs/${S.run.run_id}/zones`), getJSON(`/api/runs/${S.run.run_id}/targets`)]);
+  const table = (el, cols, data, attrs) => {
+    cols = cols.filter(([k]) => data.length && k in data[0]);
+    const fmt = (k, v) => k === "Latitude" || k === "Longitude" ? (+v).toFixed(4) : k === "CPI_Percent" ? (+v).toFixed(1) : v;
+    el.innerHTML = data.length ? `<thead><tr>${cols.map(([, h]) => `<th>${h}</th>`).join("")}</tr></thead><tbody>${data.map((r) =>
+      `<tr ${attrs(r)}>${cols.map(([k]) => {
+        const t = k === "Priority_Tier" ? ` class="tier${String(r[k]).match(/(\d)/)?.[1]}"` : typeof r[k] === "number" ? ' class="num"' : "";
+        return `<td${t}>${esc(fmt(k, r[k]))}</td>`;
+      }).join("")}</tr>`).join("")}</tbody>` : "";
+  };
+  $("#zones-note").hidden = zones.length > 0;
+  table($("#zones-table"), [["Zone_ID", "Zone"], ["Priority_Tier", "Tier"], ["Area_km2", "Area km²"], ["CPI_Max_Pct", "Peak CPI %"],
+    ["CPI_Mean_Pct", "Mean CPI %"], ["Main_Evidence", "Main evidence"], ["Muscovite_Pct", "Musc %"], ["Quartz_Pct", "Qtz %"],
+    ["Gossan_Pct", "Goss %"], ["Chlorite_Pct", "Chl %"], ["Lineaments_km", "Lineaments km"], ["Field_Check_Locations", "Field-check locations"],
+    ["Evidence_Basis", "Based on"], ["Suggested_Follow_Up", "Suggested follow-up"]], zones, (r) => `data-zone="${esc(r.Zone_ID)}"`);
+  $("#zones-table").querySelectorAll("tbody tr").forEach((tr) => tr.onclick = async () => {
+    showTab("map");
+    if (!$("#show-zones").checked) { $("#show-zones").checked = true; await drawVectors(); }
+    const l = (G.zoneLayers || {})[tr.dataset.zone];
+    if (l) { map.fitBounds(l.getBounds(), { padding: [80, 80], maxZoom: 16 }); l.openPopup(); }
+  });
+  table($("#targets-table"), [["Rank", "#"], ["Location_Name", "Location"], ["Target_Name", "Location"], ["Zone", "Zone"], ["Priority_Tier", "Tier"],
+    ["CPI_Percent", "CPI %"], ["Muscovite_Pct", "Musc %"], ["Quartz_Pct", "Qtz %"], ["Gossan_Pct", "Goss %"], ["Chlorite_Pct", "Chl %"],
+    ["Distance_to_Lineament_m", "To lineament (m)"], ["Latitude", "Lat"], ["Longitude", "Lon"], ["Check_Within_m", "Check within (m)"],
+    ["Suggested_Follow_Up", "Suggested follow-up"]], rows, (r) => `data-rank="${r.Rank}" data-lat="${r.Latitude}" data-lon="${r.Longitude}"`);
+  $("#targets-table").querySelectorAll("tbody tr").forEach((tr) => tr.onclick = () => {
+    showTab("map");
+    map.setView([+tr.dataset.lat, +tr.dataset.lon], 16);
+    const m = G.targetMarkers[tr.dataset.rank];
+    if (m) m.openPopup();
+  });
+}
+
+async function renderValidation() {
+  const run = S.run, el = $("#validation");
+  if (!run.has_validation) {
+    el.innerHTML = `<div class="empty">No ground truth (boreholes, lodes or explored blocks) is available for this area,
+      so there is no validation. The maps, zones and field-check locations are still produced.</div>`;
+    return;
+  }
+  const v = await getJSON(`/api/runs/${run.run_id}/validation`);
+  el.innerHTML = marked.parse(v.summary) + run.validation_maps.map((m) =>
+    `<img src="/api/runs/${run.run_id}/validation/${m}" alt="">`).join("");
+}
+
+function renderDownloads() {
+  const run = S.run;
+  const groups = {};
+  run.downloads.forEach((d) => (groups[d.group] = groups[d.group] || []).push(d));
+  $("#download-groups").innerHTML = Object.entries(groups).map(([g, items]) => `<div class="dgroup"><h3>${esc(g)}
+    <button type="button" data-all>Select all</button></h3>${items.map((d) =>
+    `<label><input type="checkbox" value="${esc(d.id)}"${/^(map|vector):/.test(d.id) || d.id === "contour:cpi" ? " checked" : ""}> ${esc(d.label)}</label>`).join("")}</div>`).join("");
+  $("#download-groups").querySelectorAll("[data-all]").forEach((b) => b.onclick = () => {
+    const boxes = b.closest(".dgroup").querySelectorAll("input");
+    const all = [...boxes].every((x) => x.checked);
+    boxes.forEach((x) => (x.checked = !all));
+  });
+}
+
+function renderFormats() {
+  $("#formats").innerHTML = "Vector format:" + Object.entries(S.config.formats).map(([k, v]) =>
+    `<label><input type="checkbox" value="${k}"${k === "shp" ? " checked" : ""}> ${v}</label>`).join("");
+}
+
+$("#download-btn").onclick = async () => {
+  if (!S.run) return;
+  const items = [...document.querySelectorAll("#download-groups input:checked")].map((i) => i.value);
+  const formats = [...document.querySelectorAll("#formats input:checked")].map((i) => i.value);
+  if (!items.length) { alert("Select at least one item."); return; }
+  const btn = $("#download-btn");
+  btn.disabled = true; btn.textContent = "Preparing…";
+  try {
+    const r = await api(`/api/runs/${S.run.run_id}/download`, { method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ items, formats }) });
+    const blob = await r.blob();
+    const name = (r.headers.get("Content-Disposition") || "").match(/filename="(.+)"/)?.[1] || "geoscan.zip";
+    const a = document.createElement("a");
+    a.href = URL.createObjectURL(blob); a.download = name; a.click();
+    setTimeout(() => URL.revokeObjectURL(a.href), 5000);
+  } catch (e) { alert("Download failed: " + e.message); }
+  btn.disabled = false; btn.textContent = "Download selected (.zip)";
+};
+
+function showTab(name) {
+  document.querySelectorAll("#tabs button").forEach((b) => b.classList.toggle("active", b.dataset.tab === name));
+  document.querySelectorAll(".tab-panel").forEach((p) => p.classList.toggle("active", p.id === "tab-" + name));
+  if (name === "map") setTimeout(() => map.invalidateSize(), 50);
+  if (name === "admin") renderAdmin();
+}
+document.querySelectorAll("#tabs button").forEach((b) => b.onclick = () => { showTab(b.dataset.tab); history.replaceState(null, "", "#" + b.dataset.tab); });
+
+/* ---------------- jobs ---------------- */
+async function activeJob() {
+  const js = await getJSON("/api/jobs");
+  return js.reverse().find((j) => j.status === "running" || j.status === "queued") || null;
+}
+
+function showJob(j) {
+  $("#job-card").hidden = false;
+  $("#job-title").textContent = `${j.block} · ${j.label}`;
+  $("#job-bar").style.width = `${Math.round(100 * j.progress)}%`;
+  $("#job-step").textContent = j.status === "failed" ? `Failed: ${j.error}` : j.status === "done" ? "Finished." :
+    j.status === "queued" ? "Waiting for another analysis to finish…" : j.step_label || "Starting…";
+  $("#job-log").textContent = j.log.join("\n");
+}
+
+function pollJob(jobId) {
+  clearInterval(S.jobTimer);
+  S.jobTimer = setInterval(async () => {
+    const j = await getJSON(`/api/jobs/${jobId}`);
+    showJob(j);
+    if (j.status === "done" || j.status === "failed") {
+      clearInterval(S.jobTimer);
+      if (j.status === "done") {
+        await refreshBlocks(j.block);
+        S.block = S.blocks.find((b) => b.block === j.block);
+        $("#block-select").value = j.block;
+        Object.assign(S.options, j.options);
+        Object.assign(S.params, j.params);
+        renderOptions();
+        renderParams();
+        await selectRun();
+      }
+    }
+  }, 3000);
+}
+
+$("#run-discard").onclick = () => {
+  if (!S.last) return;
+  S.options = { ...S.last.options };
+  S.params = { ...S.last.params };
+  renderOptions();
+  renderParams();
+  selectRun();
+};
+
+$("#run-btn").onclick = async () => {
+  const btn = $("#run-btn");
+  if (ruleProblems().length) return;
+  btn.disabled = true;
+  try {
+    const opts = {}, params = {};
+    Object.keys(S.config.options).forEach((k) => (opts[k] = S.options[k]));
+    Object.keys(S.config.params).forEach((k) => (params[k] = S.params[k]));
+    const r = await (await api("/api/runs", { method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ block: S.block.block, options: opts, params }) })).json();
+    if (r.run) { await refreshBlocks(); await selectRun(); }
+    else { showJob(r.job); pollJob(r.job.job_id); await selectRun(); }
+  } catch (e) { alert(e.message); }
+  btn.disabled = false;
+};
+
+/* ---------------- new area ---------------- */
+$("#new-area-btn").onclick = () => { $("#area-error").textContent = ""; $("#new-area").showModal(); };
+$("#area-cancel").onclick = () => $("#new-area").close();
+$("#new-area-form").onsubmit = async (ev) => {
+  ev.preventDefault();
+  const f = $("#area-file").files[0];
+  if (!f) return;
+  const fd = new FormData();
+  fd.append("file", f);
+  fd.append("name", $("#area-name").value);
+  $("#area-upload").disabled = true;
+  try {
+    const r = await (await api("/api/blocks", { method: "POST", body: fd })).json();
+    $("#new-area").close();
+    await refreshBlocks(r.block);
+    S.options = defaults(S.config.options);
+    S.params = defaults(S.config.params);
+    renderOptions();
+    renderParams();
+    S.run = null;
+    await selectRun();
+    if (!S.block.runs.length) $("#run-status").textContent = `New area uploaded (${r.area_km2} km²). Choose options and press Run.`;
+  } catch (e) { $("#area-error").textContent = e.message; }
+  $("#area-upload").disabled = false;
+};
+
+$("#block-select").onchange = async () => {
+  S.block = S.blocks.find((b) => b.block === $("#block-select").value);
+  S.run = null;
+  S.fitted = null;
+  await selectRun();
+};
+$("#opacity").oninput = () => G.overlay && G.overlay.setOpacity(+$("#opacity").value);
+["#show-contours", "#show-na"].forEach((s) => $(s).onchange = drawRaster);
+["#show-targets", "#show-lineaments", "#show-zones"].forEach((s) => $(s).onchange = async () => { await drawVectors(); renderLegend(S.legend || null); });
+document.querySelectorAll('input[name="base"]').forEach((r) => r.onchange = () => {
+  Object.values(bases).forEach((b) => map.removeLayer(b));
+  bases[r.value].addTo(map).bringToBack();
+});
+$("#lightbox-close").onclick = () => $("#lightbox").close();
+
+/* ---------------- accounts and admin ---------------- */
+const ACTION_TEXT = { session_start: "Signed in", upload_area: "Uploaded area", run_started: "Started analysis",
+  run_finished: "Analysis finished", run_failed: "Analysis failed", open_results: "Opened results", download: "Downloaded",
+  signed_out: "Signed out", user_added: "Added user", user_removed: "Removed user" };
+
+function logDetails(e) {
+  const d = [];
+  if (e.file) d.push(`file <b>${esc(e.file)}</b>${e.bytes ? ` (${(e.bytes / 1024).toFixed(1)} kB)` : ""}`);
+  if (e.area) d.push(`area <b>${esc(e.area)}</b>${e.area_km2 ? ` (${e.area_km2} km²)` : ""}`);
+  if (e.centre_lat) d.push(`centre ${e.centre_lat}, ${e.centre_lon}`);
+  if (e.result) d.push(esc(e.result));
+  if (e.settings) d.push(esc(e.settings));
+  if (e.changed_parameters) d.push("changed: " + Object.entries(e.changed_parameters).map(([k, v]) =>
+    `${esc((S.config.params[k] || { label: k }).label)} = ${esc(v)}`).join(", "));
+  if (e.recompute_from && e.action === "run_started") d.push(`recomputed from: ${esc(e.recompute_from)}`);
+  if (e.results && e.action !== "open_results") d.push(`results: ${esc(e.results)}`);
+  if (e.items) d.push(`${e.items.length} item(s): ${esc(e.items.join(", "))}${e.megabytes ? ` · ${e.megabytes} MB` : ""}`);
+  if (e.formats && e.action === "download") d.push(`formats: ${esc(e.formats.join(", "))}`);
+  if (e.error) d.push(`<span class="error">${esc(e.error)}</span>`);
+  if (e.account) d.push(`account <b>${esc(e.account)}</b>${e.note ? ` (${esc(e.note)})` : ""}`);
+  if (e.ip) d.push(`from ${esc(e.ip)}`);
+  if (e.browser) d.push(`<span class="muted">${esc(e.browser)}</span>`);
+  return d.join(" · ");
+}
+
+const localTime = (t) => t ? new Date(t).toLocaleString() : "";
+
+async function renderAdmin() {
+  const panel = $("#tab-admin");
+  if (!panel.firstElementChild) {
+    panel.appendChild($("#admin-template").content.cloneNode(true));
+    $("#user-form").onsubmit = async (ev) => {
+      ev.preventDefault();
+      $("#user-error").textContent = "";
+      try {
+        await api("/api/admin/users", { method: "POST", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ user: $("#new-user").value, password: $("#new-pass").value, note: $("#new-note").value }) });
+        $("#user-form").reset();
+        renderAdmin();
+      } catch (e) { $("#user-error").textContent = e.message; }
+    };
+    $("#log-refresh").onclick = renderAdmin;
+    $("#log-user").onchange = () => drawLog();
+    $("#log-action").onchange = () => drawLog();
+  }
+  const [users, log] = await Promise.all([getJSON("/api/admin/users"), getJSON("/api/admin/log?limit=2000")]);
+  S.log = log;
+  $("#users-table").innerHTML = `<thead><tr><th>User</th><th>Role</th><th>Note</th><th>Created</th><th>Last active</th><th></th></tr></thead><tbody>` +
+    users.map((u) => `<tr><td><b>${esc(u.user)}</b></td><td>${esc(u.role)}</td><td>${esc(u.note)}</td>
+      <td class="nowrap">${esc(localTime(u.created))}</td><td class="nowrap">${esc(localTime(u.last_active))}</td>
+      <td>${u.role === "user" ? `<button class="linkbtn" data-remove="${esc(u.user)}">Remove</button>` : ""}</td></tr>`).join("") + "</tbody>";
+  $("#users-table").querySelectorAll("[data-remove]").forEach((b) => b.onclick = async () => {
+    if (!confirm(`Remove user "${b.dataset.remove}"? They will no longer be able to sign in.`)) return;
+    await api(`/api/admin/users/${encodeURIComponent(b.dataset.remove)}`, { method: "DELETE" });
+    renderAdmin();
+  });
+  const keep = (sel, values, all, label) => {
+    const cur = sel.value;
+    sel.innerHTML = `<option value="">${all}</option>` + values.map((v) => `<option value="${esc(v)}">${esc(label(v))}</option>`).join("");
+    sel.value = values.includes(cur) ? cur : "";
+  };
+  keep($("#log-user"), [...new Set(log.map((e) => e.user))].sort(), "All users", (v) => v);
+  keep($("#log-action"), [...new Set(log.map((e) => e.action))].sort(), "All actions", (v) => ACTION_TEXT[v] || v);
+  drawLog();
+}
+
+function drawLog() {
+  const u = $("#log-user").value, a = $("#log-action").value;
+  const rows = (S.log || []).filter((e) => (!u || e.user === u) && (!a || e.action === a));
+  $("#log-table").innerHTML = `<thead><tr><th>Time</th><th>User</th><th>Action</th><th>Details</th></tr></thead><tbody>` +
+    (rows.length ? rows.map((e) => `<tr style="cursor:default"><td class="nowrap">${esc(localTime(e.time))}</td><td><b>${esc(e.user)}</b></td>
+      <td class="nowrap"><span class="act ${esc(e.action)}">${esc(ACTION_TEXT[e.action] || e.action)}</span></td><td>${logDetails(e)}</td></tr>`).join("")
+      : `<tr><td colspan="4" class="muted">No activity recorded yet.</td></tr>`) + "</tbody>";
+}
+
+async function signOut(ev) {
+  ev.preventDefault();
+  try { await api("/api/signout", { method: "POST" }); } catch (e) { /* still sign out */ }
+  // Browsers keep a Basic-auth password until told otherwise: send wrong credentials on purpose so the
+  // stored ones are replaced, then show a signed-out page.
+  await new Promise((done) => {
+    const x = new XMLHttpRequest();
+    x.open("GET", "/api/logout", true, "signed-out", "signed-out");
+    x.onloadend = done;
+    x.send();
+  });
+  document.body.innerHTML = `<div class="signed-out"><h1>You are signed out</h1>
+    <p>Close this tab, or <a href="/">sign in again</a>.</p>
+    <p class="muted small">If the app opens without asking for a password, close all browser windows to finish signing out.</p></div>`;
+}
+
+async function initAccount() {
+  S.me = await getJSON("/api/me");
+  if (S.me.login) {
+    $("#whoami").hidden = false;
+    $("#whoami").innerHTML = `Signed in as <b>${esc(S.me.user)}</b> · activity is recorded · <a href="#" id="signout">Sign out</a>`;
+    $("#signout").onclick = signOut;
+  }
+  if (S.me.admin) $("#admin-tab-btn").hidden = false;
+}
+
+/* ---------------- start ---------------- */
+(async function init() {
+  S.config = await getJSON("/api/config");
+  await initAccount();
+  S.options = defaults(S.config.options);
+  S.params = defaults(S.config.params);
+  renderOptions();
+  renderParams();
+  renderFormats();
+  $("#params-reset").onclick = () => { S.params = defaults(S.config.params); renderParams(); selectRun(); };
+  await refreshBlocks();
+  await selectRun();
+  const j = await activeJob();
+  if (j) { showJob(j); pollJob(j.job_id); }
+  if (location.hash.includes("params")) $("#params-box").open = true;
+  // links can pre-set parameters, e.g. #params&set=targets.min_spacing_m:400
+  let preset = false;
+  for (const m of location.hash.matchAll(/set=([\w.]+):([\d.]+)/g)) {
+    if (S.config.params[m[1]]) { S.params[m[1]] = Number(m[2]); preset = true; }
+  }
+  if (preset) { renderParams(); await selectRun(); }
+  const lm = location.hash.match(/layer=([\w:]+)/);
+  if (lm && S.run && (S.run.layers.includes(lm[1]) || refOf(lm[1]))) { S.layer = lm[1]; renderLayerRadios(); await drawRaster(); }
+  const im = location.hash.match(/info=([\w.]+)/);
+  if (im && (S.config.params[im[1]] || S.config.options[im[1]])) showInfo(im[1]);
+  const tab = location.hash.slice(1).split("&")[0];
+  if (["map", "contours", "targets", "validation", "download", "guide", "admin"].includes(tab)) showTab(tab);
+})();

geoscan/geoscan/webapp/static/index.html

@@ -1,266 +1,284 @@
-<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>GeoScan Copper Prospectivity</title>
-<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css">
-<link rel="stylesheet" href="/static/style.css">
-</head>
-<body>
-<header class="topbar">
-  <div class="brand"><span class="logo">◆</span> GeoScan <span class="sub">Copper prospectivity from satellite data</span></div>
-  <nav class="tabs" id="tabs">
-    <button data-tab="map" class="active">Map</button>
-    <button data-tab="contours">Contour maps</button>
-    <button data-tab="targets">Targets</button>
-    <button data-tab="validation">Validation</button>
-    <button data-tab="download">Download</button>
-    <button data-tab="guide">Guide</button>
-    <button data-tab="admin" id="admin-tab-btn" hidden>Admin</button>
-  </nav>
-  <div id="whoami" class="whoami" hidden></div>
-</header>
-
-<div class="layout">
-  <aside class="sidebar">
-   <div class="side-scroll">
-    <section class="card">
-      <h2>Area</h2>
-      <select id="block-select"></select>
-      <div id="block-info" class="muted small"></div>
-      <button id="new-area-btn" class="btn ghost full">＋ Upload a new area (KML / KMZ / GeoJSON)</button>
-    </section>
-
-    <section class="card">
-      <h2>Method options</h2>
-      <div id="options"></div>
-      <div class="muted small">★ = recommended (tested best on both blocks)</div>
-      <div id="run-status" class="status"></div>
-      <div id="computed" class="computed"></div>
-    </section>
-
-    <section class="card">
-      <details id="params-box">
-        <summary><h2 class="inline">Adjust parameters</h2> <span id="params-changed" class="badge" hidden></span></summary>
-        <p class="muted small">Values the method chose by hand. Tags: <b>EXP</b> expert choice, <b>ASM</b> project assumption,
-          <b>LIB</b> spectral library. Change any value, then press <i>Run analysis</i> in the bar at the bottom; only the affected steps are recomputed.</p>
-        <div id="params"></div>
-        <button type="button" id="params-reset" class="btn ghost full">Reset all to defaults</button>
-      </details>
-    </section>
-
-   </div>
-
-   <div class="side-footer">
-    <section id="job-card" class="footer-block" hidden>
-      <h2>Analysis in progress</h2>
-      <div id="job-title" class="small"></div>
-      <div class="bar"><div id="job-bar"></div></div>
-      <div id="job-step" class="small"></div>
-      <details><summary class="small">Log</summary><pre id="job-log"></pre></details>
-    </section>
-    <div id="run-bar" class="footer-block run-bar" hidden>
-      <div id="run-bar-text" class="small"></div>
-      <div class="run-bar-actions">
-        <button id="run-discard" class="btn ghost" type="button" title="Go back to the results you were viewing">Discard changes</button>
-        <button id="run-btn" class="btn primary">Run analysis</button>
-      </div>
-    </div>
-   </div>
-  </aside>
-
-  <main class="content">
-    <section class="tab-panel active" id="tab-map">
-      <div id="map"></div>
-      <div class="map-panel" id="map-panel">
-        <h3>Layer</h3>
-        <div id="layer-radios"></div>
-        <label class="slider">Opacity <input type="range" id="opacity" min="0" max="1" step="0.05" value="0.8"></label>
-        <h3>Show</h3>
-        <label><input type="checkbox" id="show-contours" checked> Contour lines</label>
-        <label><input type="checkbox" id="show-targets" checked> Drill targets</label>
-        <label><input type="checkbox" id="show-lineaments" checked> Lineaments</label>
-        <label><input type="checkbox" id="show-zones"> CPI target zones</label>
-        <label><input type="checkbox" id="show-na" checked> Not assessed (no usable EMIT data)</label>
-        <h3>Base map</h3>
-        <label><input type="radio" name="base" value="sat" checked> Satellite</label>
-        <label><input type="radio" name="base" value="topo"> Topographic</label>
-      </div>
-      <div class="legend" id="legend"></div>
-    </section>
-
-    <section class="tab-panel" id="tab-contours">
-      <p class="muted">Publication-style contour maps for the selected area and method options. Click a map to enlarge.</p>
-      <div class="gallery" id="gallery"></div>
-    </section>
-
-    <section class="tab-panel" id="tab-targets">
-      <p class="muted">Ranked drill targets (CPI ≥ 0.25, at least 250 m apart). Click a row to show it on the map.</p>
-      <div class="table-wrap"><table id="targets-table"></table></div>
-    </section>
-
-    <section class="tab-panel" id="tab-validation">
-      <div id="validation"></div>
-    </section>
-
-    <section class="tab-panel" id="tab-download">
-      <div class="download-head">
-        <div>
-          <h2>Download results</h2>
-          <p class="muted small">Rasters, Shapefiles and GeoPackages are in the area's UTM zone; GeoJSON is in WGS84.</p>
-        </div>
-        <div class="formats" id="formats"></div>
-        <button id="download-btn" class="btn primary">Download selected (.zip)</button>
-      </div>
-      <div id="download-groups" class="download-groups"></div>
-    </section>
-
-    <section class="tab-panel" id="tab-admin"></section>
-
-    <section class="tab-panel" id="tab-guide">
-      <article class="guide">
-        <h1>How GeoScan works</h1>
-        <p class="lead">GeoScan ranks ground by how likely it is to host copper, using only satellite data.
-          It finds the surface signs that copper-bearing fluids leave behind and the structures those fluids used.
-          It does not see copper itself. Every result is a surface-evidence ranking to guide field checks,
-          geophysics and drilling.</p>
-
-        <h2>1. The four alteration minerals</h2>
-        <p>Hot fluids that carry copper change the rocks they pass through. Four signs are mapped:</p>
-        <table>
-          <tr><th>Layer</th><th>What it is</th><th>Satellite and signal</th></tr>
-          <tr><td><b>Muscovite / sericite</b></td><td>White mica (phyllic alteration), usually closest to the ore</td><td>EMIT, Al-OH absorption near 2200 nm</td></tr>
-          <tr><td><b>Chlorite / epidote</b></td><td>Green minerals (propylitic alteration), usually an outer halo</td><td>EMIT, Fe-OH (2250 nm) and Mg-OH (2330 nm) absorptions</td></tr>
-          <tr><td><b>Gossan / iron oxide</b></td><td>Rusty iron staining, the weathered cap of sulphides</td><td>EMIT, Fe³⁺ absorption near 900 nm</td></tr>
-          <tr><td><b>Quartz / silicification</b></td><td>Silica added by the fluids</td><td>ASTER thermal emissivity (90 m)</td></tr>
-        </table>
-        <p>For each EMIT pixel the depth of the absorption and its uncertainty are measured on every usable date.
-          A pixel counts as a detection only when the absorption is clearly larger than its uncertainty.
-          Detections are then spread into smooth zones (a sharp core plus a wider halo) and scaled so that
-          <b>100 % = the strongest 2 % of this area</b>. Percentages are relative within one area.</p>
-
-        <h2>2. Structures (lineaments)</h2>
-        <p>Fluids rise along faults, fractures and shear zones. Straight features are traced from an elevation
-          model: hillshades from 8 sun directions plus valley and ridge axes. Lines shorter than 800 m are dropped.
-          Cliff and plateau edges (<i>scarps</i>) are kept on the map but not used for scoring.
-          Lineaments come from terrain, so <b>buried structures under flat ground can be missed</b>. Aeromagnetic data is
-          the standard tool for those.</p>
-
-        <h2>3. The Copper Prospectivity Index (CPI)</h2>
-        <p class="formula">H = 0.30·muscovite + 0.28·quartz + 0.22·gossan + 0.20·chlorite<br>
-          CPI = 0.70·H + 0.30·exp(−distance to lineament / 250 m)</p>
-        <p>These are the default weights. All of them can be changed under <i>Adjust parameters</i>.
-          CPI is shown 0-100 %, with contours at 28 % (Tier 3), 50 % (Tier 2) and 70 % (Tier 1).</p>
-
-        <h2>4. Drill targets</h2>
-        <p>Every spot is ranked by CPI. The best is Target A. Each next target must be at least 250 m from every
-          target already chosen, so each anomaly gets about one target instead of the top ranks all sitting on one hot spot.
-          Up to 50 targets with CPI ≥ 25 % are listed. Tier 1 → diamond core drilling; Tier 2 → RC drilling or trenching;
-          Tier 3 → field mapping and rock-chip sampling.</p>
-
-        <h2>5. Reading the maps</h2>
-        <ul>
-          <li><b>Hatched grey areas = "Not assessed".</b> EMIT had no usable view of the ground there. This does
-            <b>not</b> mean there is no alteration. In those areas the CPI uses quartz and structure only.</li>
-          <li><b>Contour lines</b> mark the zone boundaries shown in each map's legend.</li>
-          <li>Click any target on the map for its scores. Click a row in <i>Targets</i> to jump to it.</li>
-          <li><b>Reference geophysics</b> (magnetic anomaly, Bouguer gravity) is listed under the map layers where ground
-            stations exist for the area. Diamonds are the measured stations; the coloured surface and contours are
-            interpolated between them. These layers are for viewing and download only: <b>they are not used in the CPI
-            or the target ranking</b>. The stations are typically about 1 km apart, so they show the regional pattern
-            and cannot confirm or reject a single target.</li>
-        </ul>
-
-        <h2>6. Using the app</h2>
-        <ol>
-          <li><b>Area:</b> pick an area or upload a polygon (KML, KMZ, GeoJSON). New areas download their data from Google Earth Engine on the first run.</li>
-          <li><b>Method options:</b> ★ marks the settings that tested best. Results already computed open at once.</li>
-          <li><b>Adjust parameters:</b> every hand-chosen number, with its default and an <span class="ibtn-demo">i</span> explanation.
-            Change values and press <i>Run analysis</i>. Only the affected steps are recomputed, and the result is saved
-            and listed so you can compare it with the others.</li>
-          <li><b>Download:</b> choose maps, rasters, contour lines, vectors (Shapefile / GeoJSON / GeoPackage) and tables. You get one zip.</li>
-        </ol>
-
-        <h2>7. Where each number comes from</h2>
-        <table>
-          <tr><td><span class="tag">LIT</span></td><td>Published literature</td></tr>
-          <tr><td><span class="tag">LIB</span></td><td>Spectral library or product documentation</td></tr>
-          <tr><td><span class="tag">EXP</span></td><td>Expert choice with no external source. Most worth reviewing.</td></tr>
-          <tr><td><span class="tag">ASM</span></td><td>Project assumption</td></tr>
-          <tr><td><span class="tag">TEST</span></td><td>Checked against ground truth</td></tr>
-        </table>
-
-        <h2>8. What the validation numbers mean</h2>
-        <p><b>AUC</b> is the chance that a known mineralised spot scores higher than a random non-mineralised one.
-          0.5 = no better than chance, 1.0 = perfect. At Thanewasna the CPI is tested against 30 mapped Cu lodes
-          and 47 boreholes. Kelipur has no lode or borehole coordinates, so its checks are consistency tests against
-          NGDR explored blocks and the GSI geology map.</p>
-
-        <h2>9. Known limits</h2>
-        <ul>
-          <li>An Al-OH absorption at 2190-2215 nm is read as white mica, but kaolinite and smectite absorb at similar positions.</li>
-          <li>Iron oxide from satellites cannot separate a true gossan from laterite or ferruginous soil.</li>
-          <li>The weights follow porphyry-style zoning. The deposit type (for example VMS at Kelipur) may call for different weights.</li>
-          <li>The quartz layer is coarse (90 m) and the silica ratio SI has no verified primary source.</li>
-        </ul>
-      </article>
-    </section>
-  </main>
-</div>
-
-<template id="admin-template">
-      <div class="admin">
-        <div class="admin-card">
-          <h2>Users</h2>
-          <p class="muted small">Each person signs in with their own user name and password. Passwords are stored scrambled;
-            they cannot be read back, only replaced. Tell users that their activity on this site is recorded.</p>
-          <div class="table-wrap"><table id="users-table"></table></div>
-          <form id="user-form" class="user-form">
-            <input type="text" id="new-user" placeholder="user name" autocomplete="off" required>
-            <input type="password" id="new-pass" placeholder="password (8+ characters)" autocomplete="new-password" required>
-            <input type="text" id="new-note" placeholder="note, e.g. name / organisation">
-            <button class="btn primary" type="submit">Add or replace user</button>
-          </form>
-          <div id="user-error" class="error"></div>
-        </div>
-        <div class="admin-card">
-          <div class="admin-head">
-            <h2>Activity log</h2>
-            <select id="log-user"><option value="">All users</option></select>
-            <select id="log-action"><option value="">All actions</option></select>
-            <button class="btn ghost" id="log-refresh" type="button">Refresh</button>
-            <a class="btn ghost" href="/api/admin/log.csv" download>Download CSV</a>
-          </div>
-          <div class="table-wrap"><table id="log-table"></table></div>
-        </div>
-      </div>
-    </template>
-
-<dialog id="new-area">
-  <form method="dialog" id="new-area-form">
-    <h2>Upload a new area</h2>
-    <p class="muted small">A polygon as KML, KMZ or GeoJSON. Satellite data are fetched from Google Earth Engine when you run the analysis
-      (a 100 km² area takes roughly 20–40 minutes the first time).</p>
-    <label>File <input type="file" id="area-file" accept=".kml,.kmz,.geojson,.json" required></label>
-    <label>Name <input type="text" id="area-name" placeholder="e.g. betul_north" maxlength="40"></label>
-    <div id="area-error" class="error"></div>
-    <div class="dialog-actions">
-      <button type="button" class="btn ghost" id="area-cancel">Cancel</button>
-      <button type="submit" class="btn primary" id="area-upload">Upload</button>
-    </div>
-  </form>
-</dialog>
-
-<dialog id="info" class="info-dialog">
-  <div class="info-head"><h2 id="info-title"></h2><button class="btn ghost" id="info-close" aria-label="Close">✕</button></div>
-  <div id="info-body"></div>
-</dialog>
-
-<dialog id="lightbox"><img id="lightbox-img" alt=""><button class="btn ghost" id="lightbox-close">Close</button></dialog>
-
-<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/marked/12.0.2/marked.min.js"></script>
-<script src="/static/app.js"></script>
-</body>
-</html>
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>GeoScan Copper Prospectivity</title>
+<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css">
+<link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+<header class="topbar">
+  <div class="brand"><span class="logo">◆</span> GeoScan <span class="sub">Copper prospectivity from satellite data</span></div>
+  <nav class="tabs" id="tabs">
+    <button data-tab="map" class="active">Map</button>
+    <button data-tab="contours">Contour maps</button>
+    <button data-tab="targets">Zones</button>
+    <button data-tab="validation">Validation</button>
+    <button data-tab="download">Download</button>
+    <button data-tab="guide">Guide</button>
+    <button data-tab="admin" id="admin-tab-btn" hidden>Admin</button>
+  </nav>
+  <div id="whoami" class="whoami" hidden></div>
+</header>
+
+<div class="layout">
+  <aside class="sidebar">
+   <div class="side-scroll">
+    <section class="card">
+      <h2>Area</h2>
+      <select id="block-select"></select>
+      <div id="block-info" class="muted small"></div>
+      <button id="new-area-btn" class="btn ghost full">＋ Upload a new area (KML / KMZ / GeoJSON)</button>
+    </section>
+
+    <section class="card">
+      <h2>Method options</h2>
+      <div id="options"></div>
+      <div class="muted small">★ = recommended (tested best on both blocks)</div>
+      <div id="run-status" class="status"></div>
+      <div id="computed" class="computed"></div>
+    </section>
+
+    <section class="card">
+      <details id="params-box">
+        <summary><h2 class="inline">Adjust parameters</h2> <span id="params-changed" class="badge" hidden></span></summary>
+        <p class="muted small">Values the method chose by hand. Tags: <b>EXP</b> expert choice, <b>ASM</b> project assumption,
+          <b>LIB</b> spectral library. Change any value, then press <i>Run analysis</i> in the bar at the bottom; only the affected steps are recomputed.</p>
+        <div id="params"></div>
+        <button type="button" id="params-reset" class="btn ghost full">Reset all to defaults</button>
+      </details>
+    </section>
+
+   </div>
+
+   <div class="side-footer">
+    <section id="job-card" class="footer-block" hidden>
+      <h2>Analysis in progress</h2>
+      <div id="job-title" class="small"></div>
+      <div class="bar"><div id="job-bar"></div></div>
+      <div id="job-step" class="small"></div>
+      <details><summary class="small">Log</summary><pre id="job-log"></pre></details>
+    </section>
+    <div id="run-bar" class="footer-block run-bar" hidden>
+      <div id="run-bar-text" class="small"></div>
+      <div class="run-bar-actions">
+        <button id="run-discard" class="btn ghost" type="button" title="Go back to the results you were viewing">Discard changes</button>
+        <button id="run-btn" class="btn primary">Run analysis</button>
+      </div>
+    </div>
+   </div>
+  </aside>
+
+  <main class="content">
+    <section class="tab-panel active" id="tab-map">
+      <div id="map"></div>
+      <div class="map-panel" id="map-panel">
+        <h3>Layer</h3>
+        <div id="layer-radios"></div>
+        <label class="slider">Opacity <input type="range" id="opacity" min="0" max="1" step="0.05" value="0.8"></label>
+        <h3>Show</h3>
+        <label><input type="checkbox" id="show-contours" checked> Contour lines</label>
+        <label><input type="checkbox" id="show-zones" checked> Prospective zones</label>
+        <label><input type="checkbox" id="show-targets" checked> Field-check locations</label>
+        <label><input type="checkbox" id="show-lineaments" checked> Lineaments</label>
+        <label><input type="checkbox" id="show-na" checked> Not assessed (no usable EMIT data)</label>
+        <h3>Base map</h3>
+        <label><input type="radio" name="base" value="sat" checked> Satellite</label>
+        <label><input type="radio" name="base" value="topo"> Topographic</label>
+      </div>
+      <div class="legend" id="legend"></div>
+    </section>
+
+    <section class="tab-panel" id="tab-contours">
+      <p class="muted">Publication-style contour maps for the selected area and method options. Click a map to enlarge.</p>
+      <div class="gallery" id="gallery"></div>
+    </section>
+
+    <section class="tab-panel" id="tab-targets">
+      <h2 class="tab-h">Prospective zones</h2>
+      <p class="muted">The main result: ranked regions where the evidence is strongest. The method predicts regions, not exact
+        points. Click a row to show the zone on the map.</p>
+      <div id="zones-note" class="empty" hidden>These results were made before zones were introduced. Run the analysis again to get zones.</div>
+      <div class="table-wrap"><table id="zones-table"></table></div>
+      <h2 class="tab-h">Suggested field-check locations</h2>
+      <p class="muted">Starting points for field work inside the zones (highest CPI, at least 250 m apart). Their exact
+        position is not significant; they are not drill collars. Click a row to show it on the map.</p>
+      <div class="table-wrap"><table id="targets-table"></table></div>
+    </section>
+
+    <section class="tab-panel" id="tab-validation">
+      <div id="validation"></div>
+    </section>
+
+    <section class="tab-panel" id="tab-download">
+      <div class="download-head">
+        <div>
+          <h2>Download results</h2>
+          <p class="muted small">Rasters, Shapefiles and GeoPackages are in the area's UTM zone; GeoJSON is in WGS84.</p>
+        </div>
+        <div class="formats" id="formats"></div>
+        <button id="download-btn" class="btn primary">Download selected (.zip)</button>
+      </div>
+      <div id="download-groups" class="download-groups"></div>
+    </section>
+
+    <section class="tab-panel" id="tab-admin"></section>
+
+    <section class="tab-panel" id="tab-guide">
+      <article class="guide">
+        <h1>How GeoScan works</h1>
+        <p class="lead">GeoScan ranks ground by how likely it is to host copper, using only satellite data.
+          It finds the surface signs that copper-bearing fluids leave behind and the structures those fluids used.
+          It does not see copper itself. Every result is a surface-evidence ranking to guide field checks,
+          geophysics and drilling.</p>
+
+        <h2>1. The four alteration minerals</h2>
+        <p>Hot fluids that carry copper change the rocks they pass through. Four signs are mapped:</p>
+        <table>
+          <tr><th>Layer</th><th>What it is</th><th>Satellite and signal</th></tr>
+          <tr><td><b>Muscovite / sericite</b></td><td>White mica (phyllic alteration), usually closest to the ore</td><td>EMIT, Al-OH absorption near 2200 nm</td></tr>
+          <tr><td><b>Chlorite / epidote</b></td><td>Green minerals (propylitic alteration), usually an outer halo</td><td>EMIT, Fe-OH (2250 nm) and Mg-OH (2330 nm) absorptions</td></tr>
+          <tr><td><b>Gossan / iron oxide</b></td><td>Rusty iron staining, the weathered cap of sulphides</td><td>EMIT, Fe³⁺ absorption near 900 nm</td></tr>
+          <tr><td><b>Quartz / silicification</b></td><td>Silica added by the fluids</td><td>ASTER thermal emissivity (90 m)</td></tr>
+        </table>
+        <p>For each EMIT pixel the depth of the absorption and its uncertainty are measured on every usable date.
+          A pixel counts as a detection only when the absorption is clearly larger than its uncertainty.
+          Detections are then spread into smooth zones (a sharp core plus a wider halo) and scaled so that
+          <b>100 % = the strongest 2 % of this area</b>. Percentages are relative within one area.</p>
+
+        <h2>2. Structures (lineaments)</h2>
+        <p>Fluids rise along faults, fractures and shear zones. Straight features are traced from an elevation
+          model: hillshades from 8 sun directions plus valley and ridge axes. Lines shorter than 800 m are dropped.
+          Cliff and plateau edges (<i>scarps</i>) are kept on the map but not used for scoring.
+          Lineaments come from terrain, so <b>buried structures under flat ground can be missed</b>. Aeromagnetic data is
+          the standard tool for those.</p>
+
+        <h2>3. The Copper Prospectivity Index (CPI)</h2>
+        <p class="formula">H = 0.30·muscovite + 0.28·quartz + 0.22·gossan + 0.20·chlorite<br>
+          CPI = 0.70·H + 0.30·exp(−distance to lineament / 250 m)</p>
+        <p>These are the default weights. All of them can be changed under <i>Adjust parameters</i>.
+          CPI is shown 0-100 %, with contours at 28 % (Tier 3), 50 % (Tier 2) and 70 % (Tier 1).</p>
+
+        <h2>4. Prospective zones and field-check locations</h2>
+        <p><b>The result of this method is a region, not a point.</b> The satellite pixels are 60-90 m, each detection is
+          spread over a few hundred metres, and the data describe the surface while the ore is underground. So the method
+          can say "the mineralisation is probably somewhere in this zone", but it cannot say "drill exactly here".</p>
+        <p><b>Prospective zones</b> are the main result: connected ground with CPI at or above the Tier 2 threshold (50 %).
+          A zone is Tier 1 if it reaches 70 % somewhere, otherwise Tier 2. Separate weak anomalies that only reach 28 % are
+          listed as Tier 3 zones. The 28 % contour around a zone is its outer halo. Zones are ranked by tier, then by peak CPI.</p>
+        <p><b>Suggested field-check locations</b> are starting points for field work inside the zones: the highest-CPI
+          cells, kept at least 250 m apart. Their exact position is not significant, and <b>they are not drill collars</b>.
+          Follow-up is staged: Tier 1 → detailed mapping, systematic sampling and ground geophysics; Tier 2 → reconnaissance
+          mapping and sampling; Tier 3 → check during regional traverses. Drilling decisions come only after that work.</p>
+        <p>Validation supports this: at Thanewasna the Tier 1 zone covers 17.5 % of the block and holds 53 % of the known
+          lode area and 6 of the 8 boreholes that intersect a lode, while only 3 of the top 10 point locations lie within
+          100 m of a lode.</p>
+
+        <h2>5. Reading the maps</h2>
+        <ul>
+          <li><b>Hatched grey areas = "Not assessed".</b> EMIT had no usable view of the ground there. This does
+            <b>not</b> mean there is no alteration. In those areas the CPI uses quartz and structure only.</li>
+          <li><b>Contour lines</b> mark the zone boundaries shown in each map's legend.</li>
+          <li>Click a zone or a field-check location on the map for its details. Click a row in <i>Zones</i> to jump to it.</li>
+          <li><b>Reference geophysics</b> (magnetic anomaly, Bouguer gravity) is listed under the map layers where ground
+            stations exist for the area. Diamonds are the measured stations; the coloured surface and contours are
+            interpolated between them. These layers are for viewing and download only: <b>they are not used in the CPI
+            or the zone ranking</b>. The stations are typically about 1 km apart, so they show the regional pattern
+            and cannot confirm or reject a single zone.</li>
+        </ul>
+
+        <h2>6. Using the app</h2>
+        <ol>
+          <li><b>Area:</b> pick an area or upload a polygon (KML, KMZ, GeoJSON). New areas download their data from Google Earth Engine on the first run.</li>
+          <li><b>Method options:</b> ★ marks the settings that tested best. Results already computed open at once.</li>
+          <li><b>Adjust parameters:</b> every hand-chosen number, with its default and an <span class="ibtn-demo">i</span> explanation.
+            Change values and press <i>Run analysis</i>. Only the affected steps are recomputed, and the result is saved
+            and listed so you can compare it with the others.</li>
+          <li><b>Download:</b> choose maps, rasters, contour lines, vectors (Shapefile / GeoJSON / GeoPackage) and tables. You get one zip.</li>
+        </ol>
+
+        <h2>7. Where each number comes from</h2>
+        <table>
+          <tr><td><span class="tag">LIT</span></td><td>Published literature</td></tr>
+          <tr><td><span class="tag">LIB</span></td><td>Spectral library or product documentation</td></tr>
+          <tr><td><span class="tag">EXP</span></td><td>Expert choice with no external source. Most worth reviewing.</td></tr>
+          <tr><td><span class="tag">ASM</span></td><td>Project assumption</td></tr>
+          <tr><td><span class="tag">TEST</span></td><td>Checked against ground truth</td></tr>
+        </table>
+
+        <h2>8. What the validation numbers mean</h2>
+        <p><b>AUC</b> is the chance that a known mineralised spot scores higher than a random non-mineralised one.
+          0.5 = no better than chance, 1.0 = perfect. At Thanewasna the CPI is tested against 30 mapped Cu lodes
+          and 47 boreholes. Kelipur has no lode or borehole coordinates, so its checks are consistency tests against
+          NGDR explored blocks and the GSI geology map.</p>
+
+        <h2>9. Known limits</h2>
+        <ul>
+          <li><b>The method predicts regions, not exact points.</b> Use the zones to decide where to work, and treat the
+            point locations only as places to start.</li>
+          <li>An Al-OH absorption at 2190-2215 nm is read as white mica, but kaolinite and smectite absorb at similar positions.</li>
+          <li>Iron oxide from satellites cannot separate a true gossan from laterite or ferruginous soil.</li>
+          <li>The weights follow porphyry-style zoning. The deposit type (for example VMS at Kelipur) may call for different weights.</li>
+          <li>The quartz layer is coarse (90 m) and the silica ratio SI has no verified primary source.</li>
+        </ul>
+      </article>
+    </section>
+  </main>
+</div>
+
+<template id="admin-template">
+      <div class="admin">
+        <div class="admin-card">
+          <h2>Users</h2>
+          <p class="muted small">Each person signs in with their own user name and password. Passwords are stored scrambled;
+            they cannot be read back, only replaced. Tell users that their activity on this site is recorded.</p>
+          <div class="table-wrap"><table id="users-table"></table></div>
+          <form id="user-form" class="user-form">
+            <input type="text" id="new-user" placeholder="user name" autocomplete="off" required>
+            <input type="password" id="new-pass" placeholder="password (8+ characters)" autocomplete="new-password" required>
+            <input type="text" id="new-note" placeholder="note, e.g. name / organisation">
+            <button class="btn primary" type="submit">Add or replace user</button>
+          </form>
+          <div id="user-error" class="error"></div>
+        </div>
+        <div class="admin-card">
+          <div class="admin-head">
+            <h2>Activity log</h2>
+            <select id="log-user"><option value="">All users</option></select>
+            <select id="log-action"><option value="">All actions</option></select>
+            <button class="btn ghost" id="log-refresh" type="button">Refresh</button>
+            <a class="btn ghost" href="/api/admin/log.csv" download>Download CSV</a>
+          </div>
+          <div class="table-wrap"><table id="log-table"></table></div>
+        </div>
+      </div>
+    </template>
+
+<dialog id="new-area">
+  <form method="dialog" id="new-area-form">
+    <h2>Upload a new area</h2>
+    <p class="muted small">A polygon as KML, KMZ or GeoJSON. Satellite data are fetched from Google Earth Engine when you run the analysis
+      (a 100 km² area takes roughly 20–40 minutes the first time).</p>
+    <label>File <input type="file" id="area-file" accept=".kml,.kmz,.geojson,.json" required></label>
+    <label>Name <input type="text" id="area-name" placeholder="e.g. betul_north" maxlength="40"></label>
+    <div id="area-error" class="error"></div>
+    <div class="dialog-actions">
+      <button type="button" class="btn ghost" id="area-cancel">Cancel</button>
+      <button type="submit" class="btn primary" id="area-upload">Upload</button>
+    </div>
+  </form>
+</dialog>
+
+<dialog id="info" class="info-dialog">
+  <div class="info-head"><h2 id="info-title"></h2><button class="btn ghost" id="info-close" aria-label="Close">✕</button></div>
+  <div id="info-body"></div>
+</dialog>
+
+<dialog id="lightbox"><img id="lightbox-img" alt=""><button class="btn ghost" id="lightbox-close">Close</button></dialog>
+
+<script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/marked/12.0.2/marked.min.js"></script>
+<script src="/static/app.js"></script>
+</body>
+</html>

geoscan/geoscan/webapp/static/style.css

@@ -198,3 +198,9 @@ h2.inline { display: inline; margin: 0; }
 
 .stn { display: inline-block; width: 11px; height: 11px; transform: rotate(45deg); border: 1.5px solid #000;
   box-shadow: 0 0 0 1px rgba(255,255,255,.7); flex: none; }
+
+.tab-h { font-size: 17px; margin: 4px 0 4px; }
+.tab-h:not(:first-child) { margin-top: 26px; }
+.zone-label { background: #fff; border: 1px solid #000; border-radius: 4px; padding: 0 4px; font-size: 11px; font-weight: 700;
+  color: #000; box-shadow: none; }
+.zone-label::before { display: none; }

geoscan/scripts/validate.py

@@ -16,6 +16,7 @@ Kelipur     no borehole / lode coordinates are available, so: CPI on Precambrian
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
 from pathlib import Path
@@ -39,7 +40,7 @@ from compare_methods import geoscan_layers  # noqa: E402
 from geoscan.aoi import load_aoi  # noqa: E402
 from geoscan.grid import grid_for_aoi  # noqa: E402
 from geoscan.raster_io import aoi_mask  # noqa: E402
-from geoscan.validation import bootstrap_auc, captured_at, success_rate, target_hits  # noqa: E402
+from geoscan.validation import bootstrap_auc, captured_at, success_rate, target_hits, zone_capture  # noqa: E402
 
 ROOT = Path(os.environ.get("GEOSCAN_ROOT") or HERE.parents[1])
 LAYERS = ("cpi", "gossan", "muscovite", "chlorite", "quartz", "structure")
@@ -61,6 +62,21 @@ def _auc(arr, pos, neg, valid, cap=3000, n=1000):
     return bootstrap_auc(p, q, n=n)
 
 
+def _zone_masks(zones, G, grid, inside, tier3):
+    """Boolean rasters for the nested zone sets (None when the run has no zone file)."""
+    if zones is None:
+        return None
+
+    def burn(sub):
+        return rasterize([(g, 1) for g in sub.geometry], out_shape=grid.shape, transform=grid.transform,
+                         all_touched=True, dtype="uint8").astype(bool) & inside if len(sub) else np.zeros(grid.shape, bool)
+
+    t = zones["Priority_Tier"].str.extract(r"Tier (\d)")[0].astype(int)
+    return {"Tier 1 zones": burn(zones[t == 1]), "Tier 1 + 2 zones": burn(zones[t <= 2]),
+            "All zones (Tier 1-3)": burn(zones),
+            f"Outer halo (all ground with CPI >= {100 * tier3:.0f} %)": inside & (np.nan_to_num(G["cpi"]) >= tier3)}
+
+
 def _setup(name):
     aoi = load_aoi(next(p for p in (ROOT / "data" / name / "aoi").glob("*.geojson") if p.name != "aoi.geojson"), name)
     grid = grid_for_aoi(aoi, 15.0, 180.0)
@@ -68,8 +84,12 @@ def _setup(name):
     inside = aoi_mask(grid, aoi_utm)
     src = ROOT / "outputs" / (OUTPUT or name)
     G = geoscan_layers(src, grid, inside)
-    targets = pd.read_csv(src / "tables/top50_targets.csv")
-    return aoi, grid, aoi_utm, inside, G, targets
+    loc = src / "tables/field_check_locations.csv"
+    targets = pd.read_csv(loc if loc.exists() else src / "tables/top50_targets.csv")
+    zp = src / "vectors/prospective_zones.geojson"
+    zones = gpd.read_file(zp).to_crs(grid.crs) if zp.exists() else None
+    tier3 = json.loads((src / "manifest.json").read_text(encoding="utf-8"))["settings"]["targets"]["tier3"]
+    return aoi, grid, aoi_utm, inside, G, targets, zones, _zone_masks(zones, G, grid, inside, tier3)
 
 
 def _panel(ax, grid, arr, inside, aoi, title):
@@ -94,7 +114,7 @@ def _panel(ax, grid, arr, inside, aoi, title):
 
 def thanewasna(out: Path):
     name = "thanewasna"
-    aoi, grid, aoi_utm, inside, G, targets = _setup(name)
+    aoi, grid, aoi_utm, inside, G, targets, zones, zmask = _setup(name)
     gt = ROOT / "data" / name / "ground_truth"
     lodes = gpd.read_file(gt / "cu_lodes_mineral_zone.geojson").to_crs(grid.crs)
     lode = rasterize([(g, 1) for g in lodes.geometry], out_shape=grid.shape, transform=grid.transform,
@@ -119,7 +139,13 @@ def thanewasna(out: Path):
     xy = targets[["Easting", "Northing"]].to_numpy()
     hits = pd.DataFrame([{"subset": "top 10", **target_hits(xy[:10], lodes.geometry, aoi_utm)},
                          {"subset": "all", **target_hits(xy, lodes.geometry, aoi_utm)}])
-    hits.to_csv(out / "tables/target_hits.csv", index=False)
+    hits.to_csv(out / "tables/field_check_location_hits.csv", index=False)
+    zcap = None
+    if zmask:
+        zcap = zone_capture(zmask, lode, inside)
+        zcap["lode_boreholes_inside"] = [f"{int(m[br, bc][bh.lode.values].sum())} of {int(bh.lode.sum())}" for m in zmask.values()]
+        zcap["halo_boreholes_inside"] = [f"{int(m[br, bc][~bh.lode.values].sum())} of {int((~bh.lode).sum())}" for m in zmask.values()]
+        zcap.to_csv(out / "tables/zone_capture.csv", index=False)
     curve = success_rate(G["cpi"], lode, inside & np.isfinite(G["cpi"]))
     curve.iloc[::5].to_csv(out / "tables/success_rate_curve.csv", index=False)
 
@@ -130,8 +156,11 @@ def thanewasna(out: Path):
                linewidths=0.4, zorder=6, label="Borehole: halo only")
     ax.scatter(bh.loc[bh.lode, "BH_Lon"], bh.loc[bh.lode, "BH_Lat"], s=34, c="#ff1744", edgecolors="black",
                marker="D", zorder=7, label="Borehole: intersects Cu lode")
-    ax.scatter(targets.Longitude[:10], targets.Latitude[:10], s=110, marker="*", c="white", edgecolors="#d50000",
-               zorder=8, label="Top-10 targets")
+    if zones is not None and len(zones):
+        zones.to_crs(4326).boundary.plot(ax=ax, color="#00e5ff", linewidth=1.8, zorder=7)
+        ax.plot([], [], color="#00e5ff", lw=2, label="Prospective zone")
+    ax.scatter(targets.Longitude[:10], targets.Latitude[:10], s=45, marker="*", c="#ffd600", edgecolors="black",
+               linewidths=0.6, zorder=8, label="Suggested field-check locations (top 10)")
     ax.plot([], [], color="#00e676", lw=2, label="Cu lode (MECL Mineral_Zone_DM)")
     ax.legend(loc="lower left", fontsize=7.5, framealpha=0.9)
     fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.08, shrink=0.8, label="CPI (%)")
@@ -161,11 +190,21 @@ def thanewasna(out: Path):
              f"by CPI contains {100 * c.captured_top10pct:.0f} / {100 * c.captured_top20pct:.0f} / "
              f"{100 * c.captured_top30pct:.0f}% of the lode area.",
              f"- **CPI at borehole collars:** AUC {c.borehole_auc:.2f} (95% CI {c.borehole_ci}), permutation p = {c.borehole_p:.3f}.",
-             f"- **Targets:** {h.loc['top 10', 'hits_within_100m']} of the top 10 lie within 100 m of a lode "
+             f"- **Suggested field-check locations** (points; their exact position is not significant): "
+             f"{h.loc['top 10', 'hits_within_100m']} of the top 10 lie within 100 m of a lode "
              f"(expected at random: {h.loc['top 10', 'expected_random_100m']}); "
              f"{h.loc['all', 'hits_within_100m']} of all {h.loc['all', 'n_targets']} "
-             f"(expected {h.loc['all', 'expected_random_100m']}).\n",
-             "| Layer | Lode AUC (95% CI) | Borehole AUC (95% CI) |", "|---|---|---|"]
+             f"(expected {h.loc['all', 'expected_random_100m']}). The method predicts regions far better than points.\n",
+             ]
+    if zcap is not None:
+        lines += ["**Prospective zones against the known lodes.** Enrichment = share of lode area inside the zones divided "
+                  "by the share of the block they cover (1.0 = no better than chance).\n",
+                  "| Zones | % of block | % of lode area inside | Enrichment | Lode-intersecting boreholes inside | Halo-only boreholes inside |",
+                  "|---|---|---|---|---|---|"]
+        lines += [f"| {r.zones} | {r.pct_of_block} | {r.pct_of_truth_captured} | {r.enrichment}× | {r.lode_boreholes_inside} | "
+                  f"{r.halo_boreholes_inside} |" for r in zcap.itertuples()]
+        lines += [""]
+    lines += ["| Layer | Lode AUC (95% CI) | Borehole AUC (95% CI) |", "|---|---|---|"]
     lines += [f"| {r.layer} | {r.lode_auc:.2f} ({r.lode_ci}) | {r.borehole_auc:.2f} ({r.borehole_ci}) |"
               for r in res.itertuples()]
     lines += ["\nAUC = probability that a mineralised location scores higher than a non-mineralised one; 0.5 = no skill. "
@@ -176,7 +215,7 @@ def thanewasna(out: Path):
 
 def kelipur(out: Path):
     name = "kelipur"
-    aoi, grid, aoi_utm, inside, G, targets = _setup(name)
+    aoi, grid, aoi_utm, inside, G, targets, zones, zmask = _setup(name)
     gt = ROOT / "data" / name / "ground_truth"
     lith = gpd.read_file(gt / "lithology_gsi_cro19966.geojson").to_crs(grid.crs)
     lith["group"] = lith["LITHOLOGICAL_UNIT"].map(lith_group)
@@ -204,20 +243,31 @@ def kelipur(out: Path):
         a = _auc(G["cpi"], m, ~m, inside)
         n_in = int(sum(poly.contains(Point(x, y)) for x, y in xy))
         brow.append({"report": rid, "area": label, "area_km2": round(poly.area / 1e6, 2), "cpi_auc": a["auc"],
-                     "ci": f"{a['ci_low']:.2f}–{a['ci_high']:.2f}", "targets_inside": n_in,
-                     "targets_expected_at_random": round(len(xy) * poly.area / aoi_utm.area, 1)})
+                     "ci": f"{a['ci_low']:.2f}–{a['ci_high']:.2f}", "locations_inside": n_in,
+                     "locations_expected_at_random": round(len(xy) * poly.area / aoi_utm.area, 1),
+                     "priority_zones_touching": int(zones[~zones["Priority_Tier"].str.contains("Tier 3")].intersects(poly).sum())
+                     if zones is not None else None})
     blocks = pd.DataFrame(brow)
     blocks.to_csv(out / "tables/ngdr_exploration_blocks.csv", index=False)
+    zcap = None
+    if zmask:
+        key = ["CRO-20859-1986", "CRO-23431-2018", "CRO-22666-2009"]
+        explored = rasterize([(g, 1) for g in idx[idx.exp_upid.isin(key)].geometry], out_shape=grid.shape,
+                             transform=grid.transform).astype(bool) & inside
+        zcap = zone_capture(zmask, explored, inside)
+        zcap["pct_of_zone_area_on_cover"] = [round(100 * float((m & (cls == COVER)).sum() / max(m.sum(), 1)), 1)
+                                             for m in zmask.values()]
+        zcap.to_csv(out / "tables/zone_capture.csv", index=False)
 
     tc = np.clip(((xy[:, 0] - grid.x0) / grid.res).astype(int), 0, grid.width - 1)
     tr = np.clip(((grid.y0 - xy[:, 1]) / grid.res).astype(int), 0, grid.height - 1)
     on = cls[tr, tc]
     share = {g: (cls == g).sum() / inside.sum() for g in (COVER, NONHOST, HOST)}
-    tl = pd.DataFrame([{"lithology_group": n, "targets": int((on == g).sum()),
+    tl = pd.DataFrame([{"lithology_group": n, "locations": int((on == g).sum()),
                         "expected_by_area": round(share[g] * len(xy), 1)}
                        for g, n in ((HOST, "granitic / metapelite"), (NONHOST, "amphibolite / mafic–ultramafic"),
                                     (COVER, "Deccan trap / infra-trap cover"))])
-    tl.to_csv(out / "tables/targets_by_lithology.csv", index=False)
+    tl.to_csv(out / "tables/field_check_locations_by_lithology.csv", index=False)
 
     fig, ax = plt.subplots(figsize=(11, 7.5), dpi=170)
     cf = _panel(ax, grid, G["cpi"], inside, aoi, "Kelipur — CPI with NGDR exploration blocks and GSI Deccan cover")
@@ -227,8 +277,11 @@ def kelipur(out: Path):
         ax.plot([], [], color=col, lw=2, label=f"{rid}: {label}")
     lith[lith["group"] == COVER].to_crs(4326).boundary.plot(ax=ax, color="white", linewidth=1.0, ls="--", zorder=5)
     ax.plot([], [], color="white", lw=1.5, ls="--", label="Deccan trap / infra-trap (GSI)")
-    ax.scatter(targets.Longitude[:10], targets.Latitude[:10], s=110, marker="*", c="white", edgecolors="#d50000",
-               zorder=8, label="Top-10 targets")
+    if zones is not None and len(zones):
+        zones[~zones["Priority_Tier"].str.contains("Tier 3")].to_crs(4326).boundary.plot(ax=ax, color="#d500f9", linewidth=1.4, zorder=7)
+        ax.plot([], [], color="#d500f9", lw=2, label="Prospective zone (Tier 1 / 2)")
+    ax.scatter(targets.Longitude[:10], targets.Latitude[:10], s=45, marker="*", c="#ffd600", edgecolors="black",
+               linewidths=0.6, zorder=8, label="Suggested field-check locations (top 10)")
     ax.legend(loc="upper left", bbox_to_anchor=(1.02, 1), fontsize=7.5, framealpha=0.9)
     fig.colorbar(cf, ax=ax, orientation="horizontal", pad=0.08, shrink=0.6, label="CPI (%)")
     fig.tight_layout()
@@ -241,11 +294,21 @@ def kelipur(out: Path):
              "block. The checks below ask whether the results are consistent with independent GSI information.\n",
              f"- **CPI on Precambrian basement vs Deccan / infra-trap cover** (GSI CRO-19966-1987; the cover is younger "
              f"than the mineralisation): AUC {c.basement_vs_cover_auc:.2f} (95% CI {c.ci}). "
-             f"{int(tl.loc[2, 'targets'])} of {len(xy)} targets fall on cover (expected at random: {tl.loc[2, 'expected_by_area']}).",
+             f"{int(tl.loc[2, 'locations'])} of {len(xy)} suggested field-check locations fall on cover "
+             f"(expected at random: {tl.loc[2, 'expected_by_area']}).",
              "- **CPI inside NGDR exploration-block footprints vs the rest of the block:**\n",
-             "| NGDR report | Area | km² | CPI AUC (95% CI) | Targets inside (random) |", "|---|---|---|---|---|"]
-    lines += [f"| {r.report} | {r.area} | {r.area_km2} | {r.cpi_auc:.2f} ({r.ci}) | {r.targets_inside} "
-              f"({r.targets_expected_at_random}) |" for r in blocks.itertuples()]
+             "| NGDR report | Area | km² | CPI AUC (95% CI) | Priority zones touching it | Field-check locations inside (random) |",
+             "|---|---|---|---|---|---|"]
+    lines += [f"| {r.report} | {r.area} | {r.area_km2} | {r.cpi_auc:.2f} ({r.ci}) | {r.priority_zones_touching} | "
+              f"{r.locations_inside} ({r.locations_expected_at_random}) |" for r in blocks.itertuples()]
+    if zcap is not None:
+        lines += ["\n- **Prospective zones against the three explored / mineralised NGDR blocks** (Bhawratekra and the two "
+                  "Banskhapa-Pipariya areas). Enrichment = share of explored ground inside the zones divided by the share of "
+                  "the block they cover (1.0 = no better than chance).\n",
+                  "| Zones | % of block | % of explored ground inside | Enrichment | % of zone area on Deccan cover |",
+                  "|---|---|---|---|---|"]
+        lines += [f"| {r.zones} | {r.pct_of_block} | {r.pct_of_truth_captured} | {r.enrichment}× | {r.pct_of_zone_area_on_cover} |"
+                  for r in zcap.itertuples()]
     lines += ["\nNGDR footprints are areas that were explored, not ore outlines, and they were chosen partly because of "
               "surface signs (e.g. gossans) that this method also detects. AUC 0.5 = no difference from the rest of the block."]
     return lines