Upgrade to professional LULC workbench

.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "satellite-vision-toolkit",
-  "version": "0.1.0",
-  "description": "Detect remote-sensing objects and segment land cover in satellite and aerial imagery.",
+  "version": "0.2.0",
+  "description": "Classify land use and land cover, segment surface classes, and detect objects in satellite and aerial imagery.",
   "author": {
     "name": "Mingze Chen",
     "url": "https://github.com/LabMingzeChen"
@@ -12,16 +12,16 @@
   "skills": "./skills/",
   "interface": {
     "displayName": "Satellite Vision Toolkit",
-    "shortDescription": "Detect objects and map land cover in overhead imagery.",
-    "longDescription": "Analyze satellite and aerial images with a remote-sensing object detector and an OpenEarthMap land-cover segmentation model, then export visual, tabular, and pixel-coordinate results.",
+    "shortDescription": "Professional multi-level analysis for overhead imagery.",
+    "longDescription": "Analyze satellite and aerial images with scene-level EuroSAT LULC classification, OpenEarthMap pixel segmentation, and remote-sensing object detection, then export visual, tabular, JSON, and pixel-coordinate evidence.",
     "developerName": "Mingze Chen",
     "category": "Developer Tools",
-    "capabilities": ["Analyze", "Export"],
+    "capabilities": ["Classify", "Analyze", "Export"],
     "defaultPrompt": [
-      "Detect objects in this satellite image.",
-      "Segment land cover and summarize the area share.",
+      "Run a complete professional assessment of this satellite image.",
+      "Classify the scene into land-use and land-cover categories.",
+      "Segment land cover and detect supported objects.",
       "Explain the limits of these remote-sensing results."
     ]
   }
 }
-

.gitignore

@@ -4,4 +4,3 @@ __pycache__/
 .venv/
 .DS_Store
 outputs/
-

LICENSE

@@ -19,4 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-

README.md

@@ -9,21 +9,22 @@ python_version: "3.11"
 app_file: app.py
 pinned: false
 license: mit
-short_description: Satellite object detection and land-cover segmentation.
+short_description: LULC classification, segmentation, and object detection.
 ---
 
 <div align="center">
 
 # 🛰️ Satellite Vision Toolkit
 
-### Object detection and pixel-level land-cover mapping for overhead imagery
+### Professional scene, pixel, and object-level analysis for overhead imagery
 
 [![Hugging Face Space](https://img.shields.io/badge/🤗_Hugging_Face-Live_Demo-FFD21E)](https://huggingface.co/spaces/Mingze/SatelliteVisionToolkit)
 [![Detection](https://img.shields.io/badge/Detection-YOLOv8n-2563EB)](https://huggingface.co/bluelabel/satellite-equipment-detection-yolov8n-vhr10)
 [![Segmentation](https://img.shields.io/badge/Segmentation-Mask2Former-16A34A)](https://huggingface.co/mfaytin/mask2former-satellite)
+[![LULC](https://img.shields.io/badge/LULC-ConvNeXT--Tiny-0F766E)](https://huggingface.co/mrm8488/convnext-tiny-finetuned-eurosat)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-**Upload one satellite or aerial image, detect remote-sensing objects, map land cover, and download reusable evidence.**
+**Upload one satellite or aerial image, run a multi-model assessment, and download reusable visual and machine-readable evidence.**
 
 [**🚀 Launch the live app**](https://huggingface.co/spaces/Mingze/SatelliteVisionToolkit) ·
 [**💻 GitHub source**](https://github.com/LabMingzeChen/SatelliteVisionToolkit)
@@ -32,24 +33,32 @@ short_description: Satellite object detection and land-cover segmentation.
 
 ## What it does
 
-The app provides two complementary analysis modes:
+The app provides three complementary analytical levels plus a one-click combined workflow:
 
 | Mode | Model | Output vocabulary |
 |---|---|---|
+| Scene-level LULC classification | ConvNeXT-Tiny fine-tuned on EuroSAT | annual crop, forest, herbaceous vegetation, highway, industrial, pasture, permanent crop, residential, river, sea/lake |
 | Object detection | YOLOv8n fine-tuned on NWPU VHR-10 | airplane, ship, storage tank, baseball diamond, tennis court, basketball court, ground track field, harbor, bridge, vehicle |
 | Land-cover segmentation | Mask2Former fine-tuned on OpenEarthMap | background, bare land, grass, pavement, road, tree, water, cropland, building |
 
 Every run creates visual and machine-readable outputs:
 
+- Ranked LULC probabilities, a confidence tier, normalized entropy, and CSV/JSON exports.
 - Detection overlay, per-class summary, per-object CSV, and pixel-coordinate GeoJSON.
 - Land-cover overlay, categorical mask, raw class-ID PNG, and class-area CSV.
-- Independent Gradio API endpoints at `/detect` and `/segment`.
+- A professional executive dashboard and complete JSON evidence package.
+- Independent Gradio API endpoints at `/classify`, `/segment`, `/detect`, and `/analyze`.
 - A reusable Codex skill and command-line Space client.
 
 ## How it works
 
 ```text
 Satellite or aerial RGB image
+    ├── ConvNeXT-Tiny / EuroSAT
+    │     ├── ranked scene-level LULC probabilities
+    │     ├── normalized uncertainty (entropy)
+    │     └── classification CSV + JSON
+    │
     ├── YOLOv8n / NWPU VHR-10
     │     ├── labeled bounding-box overlay
     │     ├── class counts and confidence
@@ -85,6 +94,12 @@ from gradio_client import Client, handle_file
 
 client = Client("Mingze/SatelliteVisionToolkit")
 
+classification = client.predict(
+    handle_file("satellite.jpg"),
+    5,
+    api_name="/classify",
+)
+
 detection = client.predict(
     handle_file("satellite.jpg"),
     0.25,
@@ -98,13 +113,21 @@ segmentation = client.predict(
     0.10,
     api_name="/segment",
 )
+
+complete = client.predict(
+    handle_file("satellite.jpg"),
+    5, 0.55, 0.10, 0.25, 0.45,
+    api_name="/analyze",
+)
 ```
 
 The bundled CLI wraps the same endpoints:
 
 ```bash
+python scripts/satellite_client.py classify satellite.jpg --output classification.json
 python scripts/satellite_client.py detect satellite.jpg --output detection.json
 python scripts/satellite_client.py segment satellite.jpg --output segmentation.json
+python scripts/satellite_client.py analyze satellite.jpg --output complete.json
 ```
 
 ## Project structure
@@ -125,6 +148,8 @@ The application code is MIT licensed. Model software, weights, and training data
 
 | Resource | Role | Terms noted by source |
 |---|---|---|
+| [`mrm8488/convnext-tiny-finetuned-eurosat`](https://huggingface.co/mrm8488/convnext-tiny-finetuned-eurosat) | Scene-level LULC classifier | Model card lists Apache-2.0 |
+| [EuroSAT](https://huggingface.co/datasets/GFM-Bench/EuroSAT) | LULC classification dataset | Review dataset terms and cite Helber et al. |
 | [`bluelabel/satellite-equipment-detection-yolov8n-vhr10`](https://huggingface.co/bluelabel/satellite-equipment-detection-yolov8n-vhr10) | Remote-sensing object detector | Model card lists MIT; Ultralytics runtime has separate licensing |
 | [NWPU VHR-10](https://gcheng-nwpu.github.io/#Datasets) | Detection training dataset | Review dataset terms and cite its authors |
 | [`mfaytin/mask2former-satellite`](https://huggingface.co/mfaytin/mask2former-satellite) | Land-cover segmentation model | Model card lists MIT |
@@ -133,6 +158,8 @@ The application code is MIT licensed. Model software, weights, and training data
 ## Limitations and responsible use
 
 - Results vary with spatial resolution, sensor, geography, season, atmospheric conditions, shadows, and image preprocessing.
+- EuroSAT classification is a whole-scene hypothesis learned from small European Sentinel-2 RGB tiles; it is not parcel delineation, zoning, cadastral, or legal land-use evidence.
+- Review ranked alternatives and normalized entropy. A confident prediction can still be wrong under domain shift.
 - Small objects may disappear during resizing or fall below the confidence threshold.
 - Detection counts describe visible predictions, not complete inventories.
 - Segmentation shares describe processed image pixels, not surveyed ground area.
@@ -152,4 +179,3 @@ The application code is MIT licensed. Model software, weights, and training data
 ```
 
 Please also cite NWPU VHR-10, OpenEarthMap, YOLO/Ultralytics, and Mask2Former as applicable.
-

app.py

@@ -1,4 +1,4 @@
-"""Hugging Face Space for satellite object detection and land-cover segmentation."""
+"""Professional Hugging Face Space for multi-level satellite image analysis."""
 
 from __future__ import annotations
 
@@ -13,7 +13,11 @@ import numpy as np
 import torch
 from huggingface_hub import hf_hub_download
 from PIL import Image
-from transformers import AutoImageProcessor, Mask2FormerForUniversalSegmentation
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+    Mask2FormerForUniversalSegmentation,
+)
 
 try:
     import spaces
@@ -27,18 +31,25 @@ except ImportError:
     spaces = _SpacesFallback()
 
 from satellite_utils import (
+    build_analysis_summary,
     build_class_table,
     build_detection_summary,
     build_detection_table,
+    build_lulc_table,
+    normalized_entropy,
     render_detections,
+    render_lulc_assessment,
     render_segmentation,
     resize_for_inference,
     write_class_csv,
     write_detection_csv,
+    write_json,
+    write_lulc_csv,
     write_pixel_geojson,
 )
 
 
+CLASSIFICATION_MODEL_ID = "mrm8488/convnext-tiny-finetuned-eurosat"
 SEGMENTATION_MODEL_ID = "mfaytin/mask2former-satellite"
 DETECTION_MODEL_ID = "bluelabel/satellite-equipment-detection-yolov8n-vhr10"
 DETECTION_FILENAME = "best.pt"
@@ -56,16 +67,25 @@ OPEN_EARTH_MAP_LABELS = {
 }
 
 
+def _device() -> torch.device:
+    torch.set_num_threads(max(1, min(4, os.cpu_count() or 1)))
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+@lru_cache(maxsize=1)
+def load_classifier():
+    device = _device()
+    processor = AutoImageProcessor.from_pretrained(CLASSIFICATION_MODEL_ID)
+    model = AutoModelForImageClassification.from_pretrained(CLASSIFICATION_MODEL_ID).to(device).eval()
+    id2label = {int(key): str(value) for key, value in model.config.id2label.items()}
+    return processor, model, id2label, device
+
+
 @lru_cache(maxsize=1)
 def load_segmenter():
-    torch.set_num_threads(max(1, min(4, os.cpu_count() or 1)))
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    device = _device()
     processor = AutoImageProcessor.from_pretrained(SEGMENTATION_MODEL_ID)
-    model = (
-        Mask2FormerForUniversalSegmentation.from_pretrained(SEGMENTATION_MODEL_ID)
-        .to(device)
-        .eval()
-    )
+    model = Mask2FormerForUniversalSegmentation.from_pretrained(SEGMENTATION_MODEL_ID).to(device).eval()
     return processor, model, OPEN_EARTH_MAP_LABELS, device
 
 
@@ -83,34 +103,62 @@ def _new_output_dir() -> Path:
     return output_dir
 
 
-@spaces.GPU(duration=120)
-def segment_satellite_image(
-    image: Image.Image | None,
-    opacity: float,
-    min_share_percent: float,
-):
+def _require_image(image: Image.Image | None) -> Image.Image:
     if image is None:
         raise gr.Error("Please upload a satellite or aerial image first.")
-    started_at = time.perf_counter()
-    prepared = resize_for_inference(image)
-    try:
-        processor, model, id2label, device = load_segmenter()
-        inputs = processor(images=prepared, return_tensors="pt")
-        inputs = {name: tensor.to(device) for name, tensor in inputs.items()}
-        with torch.inference_mode():
-            outputs = model(**inputs)
-        class_map = processor.post_process_semantic_segmentation(
-            outputs,
-            target_sizes=[(prepared.height, prepared.width)],
-        )[0].cpu().numpy().astype(np.uint8)
-    except Exception as exc:
-        raise gr.Error(f"Land-cover segmentation failed: {type(exc).__name__}: {exc}") from exc
+    return resize_for_inference(image)
+
 
-    overlay, color_mask = render_segmentation(
-        prepared, class_map, id2label, float(opacity)
+def _classify_impl(prepared: Image.Image, top_k: int, output_dir: Path) -> dict[str, object]:
+    processor, model, id2label, device = load_classifier()
+    inputs = {name: tensor.to(device) for name, tensor in processor(images=prepared, return_tensors="pt").items()}
+    with torch.inference_mode():
+        logits = model(**inputs).logits[0]
+    probabilities = torch.softmax(logits, dim=-1).detach().cpu().tolist()
+    rows = build_lulc_table(probabilities, id2label, top_k)
+    entropy = normalized_entropy(probabilities)
+    csv_path = output_dir / "lulc_classification.csv"
+    json_path = output_dir / "lulc_classification.json"
+    write_lulc_csv(csv_path, rows)
+    write_json(
+        json_path,
+        {
+            "task": "scene_level_lulc_classification",
+            "model": CLASSIFICATION_MODEL_ID,
+            "processed_image_size": {"width": prepared.width, "height": prepared.height},
+            "normalized_entropy": round(entropy, 6),
+            "predictions": [
+                {"rank": row[0], "class": row[1], "probability_percent": row[2], "confidence_tier": row[3]}
+                for row in rows
+            ],
+            "scope_note": "Whole-scene EuroSAT class; not a cadastral or planning land-use designation.",
+        },
     )
+    return {
+        "rows": rows,
+        "entropy": entropy,
+        "assessment": render_lulc_assessment(rows, entropy),
+        "files": [str(csv_path), str(json_path)],
+        "device": device.type,
+    }
+
+
+def _segment_impl(
+    prepared: Image.Image,
+    opacity: float,
+    min_share_percent: float,
+    output_dir: Path,
+) -> dict[str, object]:
+    processor, model, id2label, device = load_segmenter()
+    inputs = {name: tensor.to(device) for name, tensor in processor(images=prepared, return_tensors="pt").items()}
+    with torch.inference_mode():
+        outputs = model(**inputs)
+    class_map = processor.post_process_semantic_segmentation(
+        outputs,
+        target_sizes=[(prepared.height, prepared.width)],
+    )[0].cpu().numpy().astype(np.uint8)
+    overlay, color_mask = render_segmentation(prepared, class_map, id2label, float(opacity))
     rows = build_class_table(class_map, id2label, float(min_share_percent))
-    output_dir = _new_output_dir()
     overlay_path = output_dir / "land_cover_overlay.png"
     mask_path = output_dir / "land_cover_color_mask.png"
     ids_path = output_dir / "land_cover_class_ids.png"
@@ -119,110 +167,250 @@ def segment_satellite_image(
     color_mask.save(mask_path)
     Image.fromarray(class_map).save(ids_path)
     write_class_csv(csv_path, rows)
-    elapsed = time.perf_counter() - started_at
-    status = (
-        f"Done · {prepared.width}×{prepared.height} · "
-        f"{len(np.unique(class_map))} land-cover classes · {elapsed:.1f}s · device={device.type}"
-    )
-    return overlay, color_mask, rows, [str(overlay_path), str(mask_path), str(ids_path), str(csv_path)], status
+    return {
+        "overlay": overlay,
+        "mask": color_mask,
+        "rows": rows,
+        "files": [str(overlay_path), str(mask_path), str(ids_path), str(csv_path)],
+        "device": device.type,
+    }
 
 
-@spaces.GPU(duration=120)
-def detect_satellite_objects(
-    image: Image.Image | None,
+def _detect_impl(
+    prepared: Image.Image,
     confidence_threshold: float,
     iou_threshold: float,
-):
-    if image is None:
-        raise gr.Error("Please upload a satellite or aerial image first.")
-    started_at = time.perf_counter()
-    prepared = resize_for_inference(image)
+    output_dir: Path,
+) -> dict[str, object]:
     device = "cuda" if torch.cuda.is_available() else "cpu"
-    try:
-        detector = load_detector()
-        prediction = detector.predict(
-            source=np.asarray(prepared),
-            conf=float(confidence_threshold),
-            iou=float(iou_threshold),
-            imgsz=1024,
-            device=device,
-            max_det=500,
-            verbose=False,
-        )[0]
-        detections: list[dict[str, object]] = []
-        if prediction.boxes is not None:
-            for coordinates, confidence, class_id_value in zip(
-                prediction.boxes.xyxy.detach().cpu().tolist(),
-                prediction.boxes.conf.detach().cpu().tolist(),
-                prediction.boxes.cls.detach().cpu().tolist(),
-            ):
-                class_id = int(class_id_value)
-                detections.append(
-                    {
-                        "class_id": class_id,
-                        "class_name": str(prediction.names[class_id]),
-                        "confidence": float(confidence),
-                        "x1": float(coordinates[0]),
-                        "y1": float(coordinates[1]),
-                        "x2": float(coordinates[2]),
-                        "y2": float(coordinates[3]),
-                    }
-                )
-    except Exception as exc:
-        raise gr.Error(f"Satellite object detection failed: {type(exc).__name__}: {exc}") from exc
-
+    detector = load_detector()
+    prediction = detector.predict(
+        source=np.asarray(prepared),
+        conf=float(confidence_threshold),
+        iou=float(iou_threshold),
+        imgsz=1024,
+        device=device,
+        max_det=500,
+        verbose=False,
+    )[0]
+    detections: list[dict[str, object]] = []
+    if prediction.boxes is not None:
+        for coordinates, confidence, class_id_value in zip(
+            prediction.boxes.xyxy.detach().cpu().tolist(),
+            prediction.boxes.conf.detach().cpu().tolist(),
+            prediction.boxes.cls.detach().cpu().tolist(),
+        ):
+            class_id = int(class_id_value)
+            detections.append(
+                {
+                    "class_id": class_id,
+                    "class_name": str(prediction.names[class_id]),
+                    "confidence": float(confidence),
+                    "x1": float(coordinates[0]),
+                    "y1": float(coordinates[1]),
+                    "x2": float(coordinates[2]),
+                    "y2": float(coordinates[3]),
+                }
+            )
     overlay = render_detections(prepared, detections)
     summary_rows = build_detection_summary(detections)
     detail_rows = build_detection_table(detections, prepared.size)
-    output_dir = _new_output_dir()
     overlay_path = output_dir / "satellite_detection_overlay.png"
     csv_path = output_dir / "satellite_detections.csv"
     geojson_path = output_dir / "satellite_detections_pixel_coordinates.geojson"
     overlay.save(overlay_path)
     write_detection_csv(csv_path, detail_rows)
     write_pixel_geojson(geojson_path, detections, prepared.size)
-    elapsed = time.perf_counter() - started_at
+    return {
+        "overlay": overlay,
+        "summary": summary_rows,
+        "details": detail_rows,
+        "files": [str(overlay_path), str(csv_path), str(geojson_path)],
+        "device": device,
+    }
+
+
+@spaces.GPU(duration=120)
+def classify_lulc(image: Image.Image | None, top_k: int):
+    started_at = time.perf_counter()
+    prepared = _require_image(image)
+    try:
+        result = _classify_impl(prepared, int(top_k), _new_output_dir())
+    except Exception as exc:
+        raise gr.Error(f"LULC classification failed: {type(exc).__name__}: {exc}") from exc
+    status = (
+        f"Complete · {prepared.width}×{prepared.height} · top class {result['rows'][0][1]} "
+        f"({result['rows'][0][2]:.1f}%) · {time.perf_counter() - started_at:.1f}s · device={result['device']}"
+    )
+    return result["assessment"], result["rows"], result["files"], status
+
+
+@spaces.GPU(duration=120)
+def segment_satellite_image(image: Image.Image | None, opacity: float, min_share_percent: float):
+    started_at = time.perf_counter()
+    prepared = _require_image(image)
+    try:
+        result = _segment_impl(prepared, opacity, min_share_percent, _new_output_dir())
+    except Exception as exc:
+        raise gr.Error(f"Land-cover segmentation failed: {type(exc).__name__}: {exc}") from exc
     status = (
-        f"Done · {prepared.width}×{prepared.height} · {len(detections)} objects · "
-        f"{len(summary_rows)} classes · {elapsed:.1f}s · device={device}"
+        f"Complete · {prepared.width}×{prepared.height} · {len(result['rows'])} reported cover classes · "
+        f"{time.perf_counter() - started_at:.1f}s · device={result['device']}"
+    )
+    return result["overlay"], result["mask"], result["rows"], result["files"], status
+
+
+@spaces.GPU(duration=120)
+def detect_satellite_objects(image: Image.Image | None, confidence_threshold: float, iou_threshold: float):
+    started_at = time.perf_counter()
+    prepared = _require_image(image)
+    try:
+        result = _detect_impl(prepared, confidence_threshold, iou_threshold, _new_output_dir())
+    except Exception as exc:
+        raise gr.Error(f"Satellite object detection failed: {type(exc).__name__}: {exc}") from exc
+    status = (
+        f"Complete · {prepared.width}×{prepared.height} · {len(result['details'])} objects · "
+        f"{len(result['summary'])} classes · {time.perf_counter() - started_at:.1f}s · device={result['device']}"
+    )
+    return result["overlay"], result["summary"], result["details"], result["files"], status
+
+
+@spaces.GPU(duration=180)
+def analyze_satellite_image(
+    image: Image.Image | None,
+    top_k: int,
+    opacity: float,
+    min_share_percent: float,
+    confidence_threshold: float,
+    iou_threshold: float,
+):
+    started_at = time.perf_counter()
+    prepared = _require_image(image)
+    output_dir = _new_output_dir()
+    try:
+        classification = _classify_impl(prepared, int(top_k), output_dir)
+        segmentation = _segment_impl(prepared, opacity, min_share_percent, output_dir)
+        detection = _detect_impl(prepared, confidence_threshold, iou_threshold, output_dir)
+    except Exception as exc:
+        raise gr.Error(f"Complete analysis failed: {type(exc).__name__}: {exc}") from exc
+    elapsed = time.perf_counter() - started_at
+    summary = build_analysis_summary(
+        classification["rows"],
+        float(classification["entropy"]),
+        segmentation["rows"],
+        detection["summary"],
+        elapsed,
+    )
+    report_path = output_dir / "analysis_report.json"
+    write_json(
+        report_path,
+        {
+            "processed_image_size": {"width": prepared.width, "height": prepared.height},
+            "models": {
+                "classification": CLASSIFICATION_MODEL_ID,
+                "segmentation": SEGMENTATION_MODEL_ID,
+                "detection": DETECTION_MODEL_ID,
+            },
+            "lulc_classification": classification["rows"],
+            "lulc_normalized_entropy": round(float(classification["entropy"]), 6),
+            "land_cover_pixel_shares": segmentation["rows"],
+            "detection_summary": detection["summary"],
+            "detection_details": detection["details"],
+            "elapsed_seconds": round(elapsed, 3),
+            "coordinate_note": "Detection GeoJSON is in top-left-origin image pixels and has no geographic CRS.",
+        },
+    )
+    files = classification["files"] + segmentation["files"] + detection["files"] + [str(report_path)]
+    status = f"Complete multi-model assessment · {prepared.width}×{prepared.height} · {elapsed:.1f}s"
+    return (
+        summary,
+        classification["assessment"],
+        classification["rows"],
+        segmentation["overlay"],
+        segmentation["mask"],
+        segmentation["rows"],
+        detection["overlay"],
+        detection["summary"],
+        detection["details"],
+        files,
+        status,
     )
-    return overlay, summary_rows, detail_rows, [str(overlay_path), str(csv_path), str(geojson_path)], status
 
 
 CSS = """
-.gradio-container {max-width: 1280px !important;}
-.hero {text-align: center; margin: 0 auto 1rem;}
-.hero h1 {font-size: 2.15rem; margin-bottom: .3rem;}
-.note {color: #64748b;}
+.gradio-container {max-width: 1440px !important; background: #f6f8fb;}
+.hero {padding: 2rem; border-radius: 22px; color: white; background: linear-gradient(125deg,#071c33,#0a4b5c 56%,#198f75); box-shadow: 0 18px 44px rgba(7,28,51,.18); margin-bottom: 1rem;}
+.hero h1 {font-size: 2.35rem; margin: 0 0 .35rem; letter-spacing: -.03em;}
+.hero p {max-width: 850px; margin: .35rem 0; color: #d8f3ee;}
+.hero a {color: #fff; font-weight: 650;}
+.pipeline {display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin:14px 0 20px;}
+.pipeline div,.assessment-card,.metric-card {background:white;border:1px solid #dce6ed;border-radius:16px;padding:16px;box-shadow:0 6px 18px rgba(20,50,70,.06);}
+.pipeline b {display:block;color:#0c5262;margin-bottom:5px}.pipeline span,.micro-note {color:#667985;font-size:.87rem;}
+.summary-grid {display:grid;grid-template-columns:repeat(4,1fr);gap:12px;margin:12px 0;}
+.metric-card span,.eyebrow {display:block;color:#66808c;font-size:.72rem;font-weight:750;letter-spacing:.1em;text-transform:uppercase;}
+.metric-card strong {display:block;font-size:1.45rem;margin:6px 0;color:#113544;}.metric-card small {color:#60747e;}
+.assessment-card h2 {margin:.25rem 0;color:#123c49}.assessment-card p {color:#526b76;}
+.prob-row {display:grid;grid-template-columns:155px 1fr 62px;gap:10px;align-items:center;margin:8px 0;font-size:.86rem;}
+.prob-row b {text-align:right}.prob-track {height:9px;background:#e5edf1;border-radius:20px;overflow:hidden}.prob-track i {display:block;height:100%;background:linear-gradient(90deg,#169c7d,#36b7c5);border-radius:20px;}
+.section-note {padding:12px 14px;border-left:4px solid #15947a;background:#eef9f6;border-radius:8px;color:#315c62;}
+@media(max-width:850px){.pipeline,.summary-grid{grid-template-columns:1fr}.prob-row{grid-template-columns:115px 1fr 56px}}
 """
 
-with gr.Blocks(title="Satellite Vision Toolkit", css=CSS, theme=gr.themes.Soft()) as demo:
+
+with gr.Blocks(title="Satellite Vision Toolkit Pro", css=CSS, theme=gr.themes.Soft()) as demo:
     gr.HTML("""
     <div class="hero">
-      <h1>🛰️ Satellite Vision Toolkit</h1>
-      <p>Detect remote-sensing objects and map land cover from one satellite or aerial image.</p>
-      <p><a href="https://github.com/LabMingzeChen/SatelliteVisionToolkit">GitHub</a> ·
-      <a href="https://huggingface.co/mfaytin/mask2former-satellite">Segmentation model</a> ·
-      <a href="https://huggingface.co/bluelabel/satellite-equipment-detection-yolov8n-vhr10">Detection model</a></p>
+      <div class="eyebrow" style="color:#8ee5d2">REMOTE SENSING DECISION SUPPORT</div>
+      <h1>🛰️ Satellite Vision Toolkit Pro</h1>
+      <p>A multi-level workbench for scene-level land-use/land-cover classification, pixel-level cover mapping, and overhead object detection.</p>
+      <p><a href="https://github.com/LabMingzeChen/SatelliteVisionToolkit">GitHub</a> · <a href="https://huggingface.co/mrm8488/convnext-tiny-finetuned-eurosat">LULC model</a> · <a href="https://huggingface.co/mfaytin/mask2former-satellite">Segmentation model</a> · <a href="https://huggingface.co/bluelabel/satellite-equipment-detection-yolov8n-vhr10">Detection model</a></p>
+    </div>
+    <div class="pipeline">
+      <div><b>01 · Scene classification</b><span>EuroSAT probability profile across 10 LULC scene types.</span></div>
+      <div><b>02 · Semantic segmentation</b><span>Per-pixel OpenEarthMap land-cover composition and masks.</span></div>
+      <div><b>03 · Object detection</b><span>Bounding boxes and inventory-style summaries for 10 VHR object types.</span></div>
     </div>
     """)
-    with gr.Row():
-        image_input = gr.Image(type="pil", label="Satellite / aerial image", height=420)
+    with gr.Row(equal_height=True):
+        image_input = gr.Image(type="pil", label="Satellite / aerial RGB image", height=430)
         with gr.Column():
-            gr.Markdown("""
-### Supported analysis
+            gr.Markdown("### Analysis controls\nTune reproducible thresholds, then run the complete assessment or an individual method.")
+            top_k = gr.Slider(3, 10, value=5, step=1, label="LULC alternatives (top-k)")
+            opacity = gr.Slider(0.1, 0.9, value=0.55, step=0.05, label="Segmentation overlay opacity")
+            min_share = gr.Slider(0.0, 5.0, value=0.1, step=0.1, label="Minimum reported cover share (%)")
+            confidence = gr.Slider(0.05, 0.9, value=0.25, step=0.05, label="Detection confidence threshold")
+            iou = gr.Slider(0.1, 0.9, value=0.45, step=0.05, label="Detection NMS IoU threshold")
+            analyze_button = gr.Button("Run complete professional assessment", variant="primary", size="lg")
 
-- **Object detection:** airplane, ship, storage tank, sports fields/courts, harbor, bridge, and vehicle.
-- **Land-cover segmentation:** background, bare land, grass, pavement, road, tree, water, cropland, and building.
+    with gr.Tabs():
+        with gr.Tab("Executive overview"):
+            analysis_status = gr.Markdown()
+            executive_summary = gr.HTML()
+            overview_lulc = gr.HTML()
+            overview_lulc_table = gr.Dataframe(
+                headers=["Rank", "LULC class", "Probability (%)", "Confidence tier"],
+                interactive=False,
+                label="Scene classification probability profile",
+            )
+            with gr.Row():
+                overview_segment = gr.Image(label="Pixel-level land-cover overlay")
+                overview_detection = gr.Image(label="Detected objects")
+            overview_files = gr.File(label="Download complete evidence package", file_count="multiple")
 
-RGB PNG/JPEG/WebP/TIFF images work best. Results are image-space estimates, not surveyed GIS data.
-            """)
+        with gr.Tab("LULC classification"):
+            gr.Markdown("<div class='section-note'><b>Scene-level interpretation.</b> Assigns the whole image to EuroSAT land-use/land-cover classes. This is distinct from pixel segmentation and is not a legal land-use designation.</div>")
+            classify_button = gr.Button("Classify scene LULC", variant="primary")
+            classify_status = gr.Markdown()
+            classification_assessment = gr.HTML()
+            classification_table = gr.Dataframe(
+                headers=["Rank", "LULC class", "Probability (%)", "Confidence tier"],
+                interactive=False,
+                label="Ranked LULC alternatives",
+            )
+            classification_files = gr.File(label="Download classification CSV / JSON", file_count="multiple")
 
-    with gr.Tabs():
         with gr.Tab("Land-cover segmentation"):
-            with gr.Row():
-                opacity = gr.Slider(0.1, 0.9, value=0.55, step=0.05, label="Overlay opacity")
-                min_share = gr.Slider(0.0, 5.0, value=0.1, step=0.1, label="Minimum table share (%)")
+            gr.Markdown("<div class='section-note'><b>Pixel-level interpretation.</b> Maps nine OpenEarthMap surface classes and reports image-pixel composition.</div>")
             segment_button = gr.Button("Segment land cover", variant="primary")
             segment_status = gr.Markdown()
             with gr.Row():
@@ -230,22 +418,18 @@ RGB PNG/JPEG/WebP/TIFF images work best. Results are image-space estimates, not
                 segment_mask = gr.Image(label="Categorical mask")
             segment_table = gr.Dataframe(
                 headers=["Class ID", "Class", "Pixels", "Share (%)", "Color"],
-                datatype=["number", "str", "number", "number", "str"],
                 interactive=False,
                 label="Land-cover area summary",
             )
             segment_files = gr.File(label="Download segmentation outputs", file_count="multiple")
 
         with gr.Tab("Object detection"):
-            with gr.Row():
-                confidence = gr.Slider(0.05, 0.9, value=0.25, step=0.05, label="Confidence threshold")
-                iou = gr.Slider(0.1, 0.9, value=0.45, step=0.05, label="NMS IoU threshold")
+            gr.Markdown("<div class='section-note'><b>Instance-level interpretation.</b> Locates supported objects with confidence-filtered bounding boxes.</div>")
             detect_button = gr.Button("Detect satellite objects", variant="primary")
             detect_status = gr.Markdown()
             detect_overlay = gr.Image(label="Detection overlay")
             detection_summary = gr.Dataframe(
                 headers=["Class", "Count", "Average confidence", "Maximum confidence"],
-                datatype=["str", "number", "number", "number"],
                 interactive=False,
                 label="Detection summary",
             )
@@ -256,10 +440,25 @@ RGB PNG/JPEG/WebP/TIFF images work best. Results are image-space estimates, not
             )
             detection_files = gr.File(label="Download detection outputs", file_count="multiple")
 
-    gr.Markdown("""
-> **Responsible use:** Models can miss small objects and may generalize poorly across sensors, regions, seasons, cloud cover, and ground resolution. Pixel-coordinate GeoJSON is not georeferenced. Do not use outputs for navigation, surveillance, legal boundaries, emergency response, or other safety-critical decisions without qualified review.
-    """)
+        with gr.Tab("Methodology & scope"):
+            gr.Markdown("""
+### Analytical hierarchy
+
+| Level | Question answered | Model / training domain | Output |
+|---|---|---|---|
+| Scene | What broad LULC type best characterizes this image? | ConvNeXT-Tiny / EuroSAT Sentinel-2 RGB | Ranked probabilities + entropy |
+| Pixel | Which cover class is predicted at each pixel? | Mask2Former / OpenEarthMap | Overlay, mask, pixel shares |
+| Object | Where are supported discrete objects? | YOLOv8n / NWPU VHR-10 | Boxes, counts, CSV, pixel GeoJSON |
+
+**Interpretation guardrails:** EuroSAT is a European Sentinel-2 scene dataset; classification may shift on other sensors, regions, resolutions, or crops. Pixel shares are not automatically physical ground-area shares. Pixel-coordinate GeoJSON is not georeferenced. Models can miss small or obscured objects. Do not use outputs alone for legal, surveillance, emergency, navigation, or safety-critical decisions.
+            """)
 
+    classify_button.click(
+        classify_lulc,
+        inputs=[image_input, top_k],
+        outputs=[classification_assessment, classification_table, classification_files, classify_status],
+        api_name="classify",
+    )
     segment_button.click(
         segment_satellite_image,
         inputs=[image_input, opacity, min_share],
@@ -272,6 +471,24 @@ RGB PNG/JPEG/WebP/TIFF images work best. Results are image-space estimates, not
         outputs=[detect_overlay, detection_summary, detection_details, detection_files, detect_status],
         api_name="detect",
     )
+    analyze_button.click(
+        analyze_satellite_image,
+        inputs=[image_input, top_k, opacity, min_share, confidence, iou],
+        outputs=[
+            executive_summary,
+            overview_lulc,
+            overview_lulc_table,
+            overview_segment,
+            segment_mask,
+            segment_table,
+            overview_detection,
+            detection_summary,
+            detection_details,
+            overview_files,
+            analysis_status,
+        ],
+        api_name="analyze",
+    )
 
 
 if __name__ == "__main__":

satellite_utils.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import csv
+import html
 import json
+import math
 from collections import defaultdict
 from pathlib import Path
 from typing import Iterable
@@ -27,11 +29,119 @@ LAND_COVER_PALETTE: dict[str, tuple[int, int, int]] = {
     "building": (218, 73, 73),
 }
 
+LULC_DISPLAY_NAMES = {
+    "annualcrop": "Annual crop",
+    "forest": "Forest",
+    "herbaceousvegetation": "Herbaceous vegetation",
+    "highway": "Highway",
+    "industrial": "Industrial",
+    "pasture": "Pasture",
+    "permanentcrop": "Permanent crop",
+    "residential": "Residential",
+    "river": "River",
+    "sealake": "Sea / lake",
+}
+
 
 def normalize_label(label: str) -> str:
     return label.lower().replace("_", " ").strip()
 
 
+def display_lulc_label(label: str) -> str:
+    """Convert EuroSAT model labels into compact report labels."""
+    key = "".join(character for character in label.lower() if character.isalnum())
+    return LULC_DISPLAY_NAMES.get(key, label.replace("_", " ").strip().title())
+
+
+def confidence_tier(probability: float) -> str:
+    if probability >= 0.80:
+        return "High"
+    if probability >= 0.55:
+        return "Moderate"
+    return "Low"
+
+
+def normalized_entropy(probabilities: Iterable[float]) -> float:
+    """Return Shannon entropy normalized to 0–1 for model ambiguity."""
+    values = [max(0.0, float(value)) for value in probabilities]
+    total = sum(values)
+    if not values or total <= 0.0 or len(values) == 1:
+        return 0.0
+    normalized = [value / total for value in values if value > 0.0]
+    entropy = -sum(value * math.log(value) for value in normalized)
+    return entropy / math.log(len(values))
+
+
+def build_lulc_table(
+    probabilities: Iterable[float],
+    id2label: dict[int, str],
+    top_k: int = 5,
+) -> list[list[object]]:
+    ranked = sorted(
+        enumerate(float(value) for value in probabilities),
+        key=lambda item: item[1],
+        reverse=True,
+    )[: max(1, int(top_k))]
+    return [
+        [rank, display_lulc_label(id2label.get(class_id, f"class_{class_id}")), round(score * 100, 2), confidence_tier(score)]
+        for rank, (class_id, score) in enumerate(ranked, start=1)
+    ]
+
+
+def render_lulc_assessment(rows: list[list[object]], entropy: float) -> str:
+    """Render an accessible probability profile and uncertainty note."""
+    if not rows:
+        return "<div class='assessment-card'>No classification result.</div>"
+    top_probability = float(rows[0][2])
+    bars = "".join(
+        "<div class='prob-row'><span>{}</span><div class='prob-track'><i style='width:{:.2f}%'></i></div><b>{:.2f}%</b></div>".format(
+            html.escape(str(row[1])), float(row[2]), float(row[2])
+        )
+        for row in rows
+    )
+    ambiguity = "low" if entropy < 0.35 else "moderate" if entropy < 0.65 else "high"
+    return (
+        "<div class='assessment-card'>"
+        f"<div class='eyebrow'>SCENE-LEVEL LULC</div><h2>{html.escape(str(rows[0][1]))}</h2>"
+        f"<p><strong>{top_probability:.2f}%</strong> top-class confidence · "
+        f"{ambiguity} ambiguity (normalized entropy {entropy:.2f})</p>{bars}"
+        "<p class='micro-note'>A whole-scene EuroSAT label, not a cadastral or planning designation.</p></div>"
+    )
+
+
+def build_analysis_summary(
+    lulc_rows: list[list[object]],
+    entropy: float,
+    land_cover_rows: list[list[object]],
+    detection_rows: list[list[object]],
+    elapsed_seconds: float,
+) -> str:
+    lulc_name = str(lulc_rows[0][1]) if lulc_rows else "Unavailable"
+    lulc_confidence = float(lulc_rows[0][2]) if lulc_rows else 0.0
+    cover_name = str(land_cover_rows[0][1]) if land_cover_rows else "Unavailable"
+    cover_share = float(land_cover_rows[0][3]) if land_cover_rows else 0.0
+    object_count = sum(int(row[1]) for row in detection_rows)
+    return f"""
+    <div class="summary-grid">
+      <div class="metric-card"><span>Scene LULC</span><strong>{html.escape(lulc_name)}</strong><small>{lulc_confidence:.1f}% confidence · entropy {entropy:.2f}</small></div>
+      <div class="metric-card"><span>Dominant cover</span><strong>{html.escape(cover_name)}</strong><small>{cover_share:.1f}% of processed pixels</small></div>
+      <div class="metric-card"><span>Detected objects</span><strong>{object_count}</strong><small>{len(detection_rows)} represented object classes</small></div>
+      <div class="metric-card"><span>Analysis time</span><strong>{elapsed_seconds:.1f}s</strong><small>classification + segmentation + detection</small></div>
+    </div>
+    """
+
+
+def write_lulc_csv(path: Path, rows: Iterable[Iterable[object]]) -> None:
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.writer(handle)
+        writer.writerow(["rank", "class", "probability_percent", "confidence_tier"])
+        writer.writerows(rows)
+
+
+def write_json(path: Path, payload: object) -> None:
+    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
 def fallback_color(class_id: int) -> tuple[int, int, int]:
     return (
         int((67 * class_id + 41) % 190 + 35),
@@ -257,4 +367,3 @@ def write_pixel_geojson(
         "features": features,
     }
     path.write_text(json.dumps(collection, indent=2), encoding="utf-8")
-

scripts/satellite_client.py

@@ -15,7 +15,7 @@ DEFAULT_SPACE = "Mingze/SatelliteVisionToolkit"
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("operation", choices=("detect", "segment"))
+    parser.add_argument("operation", choices=("classify", "segment", "detect", "analyze"))
     parser.add_argument("image", type=Path)
     parser.add_argument("--space", default=DEFAULT_SPACE)
     parser.add_argument("--output", type=Path)
@@ -23,6 +23,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--iou", type=float, default=0.45)
     parser.add_argument("--opacity", type=float, default=0.55)
     parser.add_argument("--min-share", type=float, default=0.1)
+    parser.add_argument("--top-k", type=int, default=5)
     return parser.parse_args()
 
 
@@ -31,20 +32,36 @@ def main() -> int:
     if not args.image.is_file():
         raise SystemExit(f"Image not found: {args.image}")
     client = Client(args.space)
-    if args.operation == "detect":
+    if args.operation == "classify":
+        result = client.predict(
+            handle_file(str(args.image)),
+            args.top_k,
+            api_name="/classify",
+        )
+    elif args.operation == "detect":
         result = client.predict(
             handle_file(str(args.image)),
             args.confidence,
             args.iou,
             api_name="/detect",
         )
-    else:
+    elif args.operation == "segment":
         result = client.predict(
             handle_file(str(args.image)),
             args.opacity,
             args.min_share,
             api_name="/segment",
         )
+    else:
+        result = client.predict(
+            handle_file(str(args.image)),
+            args.top_k,
+            args.opacity,
+            args.min_share,
+            args.confidence,
+            args.iou,
+            api_name="/analyze",
+        )
     rendered = json.dumps(result, ensure_ascii=False, indent=2, default=str)
     if args.output:
         args.output.write_text(rendered + "\n", encoding="utf-8")
@@ -55,4 +72,3 @@ def main() -> int:
 
 if __name__ == "__main__":
     raise SystemExit(main())
-

skills/analyze-satellite-imagery/SKILL.md

@@ -1,37 +1,44 @@
 ---
 name: analyze-satellite-imagery
-description: Detect remote-sensing objects and segment land cover in satellite or aerial RGB imagery. Use when Codex needs to analyze overhead PNG, JPEG, WebP, or TIFF images; locate airplanes, ships, vehicles, storage tanks, bridges, harbors, or sports facilities; map OpenEarthMap land-cover classes; produce overlays, masks, CSV summaries, or pixel-coordinate GeoJSON; or call the Satellite Vision Toolkit Hugging Face Space API.
+description: Classify land use and land cover, segment surface classes, and detect remote-sensing objects in satellite or aerial RGB imagery. Use when Codex needs to analyze overhead PNG, JPEG, WebP, or TIFF images; assign EuroSAT LULC scene classes; locate airplanes, ships, vehicles, storage tanks, bridges, harbors, or sports facilities; map OpenEarthMap land-cover classes; produce professional summaries, overlays, masks, CSV, JSON, or pixel-coordinate GeoJSON; or call the Satellite Vision Toolkit Hugging Face Space API.
 ---
 
 # Analyze Satellite Imagery
 
-Use the bundled Space or local app to run two complementary workflows:
+Use the bundled Space or local app to run three complementary analytical levels:
 
+- Classify the whole scene across 10 EuroSAT LULC categories with ConvNeXT-Tiny.
 - Detect 10 NWPU VHR-10 object categories with the fine-tuned YOLOv8n model.
 - Segment 9 OpenEarthMap land-cover categories with Mask2Former.
 
 ## Choose a workflow
 
-1. Use detection for discrete objects and bounding boxes.
+1. Use classification for a broad whole-scene LULC hypothesis and ranked alternatives.
 2. Use segmentation for per-pixel land-cover composition.
-3. Run both when the question mixes infrastructure counts and surface coverage.
-4. Inspect `references/model-guide.md` before making claims about model scope, licenses, or limitations.
+3. Use detection for discrete objects and bounding boxes.
+4. Use complete analysis when a professional summary or cross-method evidence package is needed.
+5. Inspect `references/model-guide.md` before making claims about model scope, licenses, or limitations.
 
 ## Run the app
 
-From the plugin root, install `requirements.txt` and run `python app.py`. For a deployed Space, use the browser UI or call the `/detect` and `/segment` endpoints with `gradio_client`.
+From the plugin root, install `requirements.txt` and run `python app.py`. For a deployed Space, use the browser UI or call `/classify`, `/segment`, `/detect`, or `/analyze` with `gradio_client`.
 
 Use `scripts/satellite_client.py` for repeatable API calls:
 
 ```bash
+python scripts/satellite_client.py classify image.jpg --output classification.json
 python scripts/satellite_client.py detect image.jpg --output result.json
 python scripts/satellite_client.py segment image.jpg --output result.json
+python scripts/satellite_client.py analyze image.jpg --output complete.json
 ```
 
 Set `--space` when using a fork. The default is `Mingze/SatelliteVisionToolkit`.
 
 ## Interpret outputs
 
+- Keep scene-level classification separate from pixel-level segmentation in the report.
+- Treat EuroSAT probabilities as a broad scene hypothesis, not zoning, cadastral, or legal land-use evidence.
+- Report normalized entropy when classification ambiguity matters; a high top score does not remove domain-shift risk.
 - Treat detection counts as visible-image estimates, not inventories.
 - Treat class shares as proportions of processed image pixels, not physical land area.
 - State that exported GeoJSON uses top-left-origin image pixels and has no geographic CRS.
@@ -41,5 +48,4 @@ Set `--space` when using a fork. The default is `Mingze/SatelliteVisionToolkit`.
 
 ## Report results
 
-Include the model, thresholds, processed image dimensions, detected classes/counts or land-cover shares, and the important limitations. Link or return the generated overlays and exports when available.
-
+Include the analytical level, model, thresholds, processed image dimensions, ranked LULC alternatives, detected classes/counts or land-cover shares, and important limitations. Link or return generated overlays and exports when available.

skills/analyze-satellite-imagery/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "Satellite Imagery Analysis"
-  short_description: "Detect objects and map land cover in satellite images"
-  default_prompt: "Use $analyze-satellite-imagery to detect objects and segment land cover in this satellite image."
+  short_description: "Classify LULC, segment cover, and detect overhead objects"
+  default_prompt: "Use $analyze-satellite-imagery to run a professional scene, pixel, and object-level assessment of this satellite image."

skills/analyze-satellite-imagery/references/model-guide.md

@@ -1,5 +1,16 @@
 # Model and output guide
 
+## Scene-level LULC classification
+
+- Model: `mrm8488/convnext-tiny-finetuned-eurosat`
+- Architecture: ConvNeXT-Tiny
+- Training data: EuroSAT RGB images derived from European Sentinel-2 imagery
+- Classes: annual crop, forest, herbaceous vegetation, highway, industrial, pasture, permanent crop, residential, river, sea/lake
+- Model-card license: Apache-2.0
+- Model-card reported evaluation accuracy: 0.9805
+
+The classifier assigns one broad label to the processed image. It does not delineate parcels or pixels and must not be represented as a cadastral, zoning, or legal land-use conclusion. EuroSAT images are small European Sentinel-2 tiles; other sensors, countries, seasons, scales, and image crops introduce domain shift. Review the full probability profile and normalized entropy, not only the top label.
+
 ## Object detection
 
 - Model: `bluelabel/satellite-equipment-detection-yolov8n-vhr10`
@@ -24,8 +35,9 @@ Area share is computed as `class pixels / all processed pixels`. It is a two-dim
 
 ## Export semantics
 
+- Classification CSV and JSON preserve ranked probabilities, confidence tiers, and normalized entropy.
+- Complete-analysis JSON records all three model IDs, summaries, thresholds-derived outputs, timing, and coordinate caveats.
 - Segmentation class-ID PNG preserves numeric predicted labels.
 - Segmentation CSV contains class ID, name, pixel count, share percent, and display color.
 - Detection CSV contains image-pixel boxes, pixel area, and normalized box centers.
 - Detection GeoJSON stores box polygons in image-pixel coordinates with origin at the top left. It is intentionally not assigned a geographic coordinate reference system.
-

tests/test_app_contract.py

@@ -2,7 +2,7 @@ import ast
 from pathlib import Path
 
 
-def test_app_exposes_both_api_endpoints():
+def test_app_exposes_all_api_endpoints_and_models():
     source = Path("app.py").read_text(encoding="utf-8")
     tree = ast.parse(source)
     constants = {
@@ -12,6 +12,9 @@ def test_app_exposes_both_api_endpoints():
     }
     assert "segment" in constants
     assert "detect" in constants
+    assert "classify" in constants
+    assert "analyze" in constants
+    assert "mrm8488/convnext-tiny-finetuned-eurosat" in constants
     assert "mfaytin/mask2former-satellite" in constants
     assert "bluelabel/satellite-equipment-detection-yolov8n-vhr10" in constants
-
+    assert "cropland" in constants

tests/test_satellite_utils.py

@@ -52,6 +52,23 @@ def test_class_table_is_sorted_and_thresholded():
     assert rows == [[4, "road", 3, 75.0, "#5C5C5C"]]
 
 
+def test_lulc_table_is_ranked_and_human_readable():
+    rows = utils.build_lulc_table(
+        [0.1, 0.65, 0.25],
+        {0: "AnnualCrop", 1: "SeaLake", 2: "HerbaceousVegetation"},
+        top_k=2,
+    )
+    assert rows == [
+        [1, "Sea / lake", 65.0, "Moderate"],
+        [2, "Herbaceous vegetation", 25.0, "Low"],
+    ]
+
+
+def test_normalized_entropy_has_expected_extremes():
+    assert utils.normalized_entropy([1.0, 0.0, 0.0]) == 0.0
+    assert round(utils.normalized_entropy([1 / 3, 1 / 3, 1 / 3]), 6) == 1.0
+
+
 def test_segmentation_outputs_match_input_size():
     image = Image.new("RGB", (3, 2), "black")
     class_map = np.array([[4, 4, 6], [4, 6, 6]], dtype=np.uint8)
@@ -81,4 +98,3 @@ def test_pixel_geojson_is_explicitly_unreferenced(tmp_path):
     assert data["properties"]["coordinate_system"] == "image_pixels"
     assert data["properties"]["origin"] == "top_left"
     assert data["features"][0]["geometry"]["coordinates"][0][0] == [10.0, 20.0]
-