pyarchinit-photogrammetry 1.2.0__tar.gz → 1.2.2__tar.gz

{pyarchinit_photogrammetry-1.2.0/src/pyarchinit_photogrammetry.egg-info → pyarchinit_photogrammetry-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-photogrammetry
-Version: 1.2.0
+Version: 1.2.2
 Summary: Open-source photogrammetry engine for archaeology and BIM, integrated with PyArchInit
 Author-email: Enzo Cocca <enzo.ccc@gmail.com>
 License-Expression: GPL-2.0-or-later

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-photogrammetry"
-version = "1.2.0"
+version = "1.2.2"
 description = "Open-source photogrammetry engine for archaeology and BIM, integrated with PyArchInit"
 readme = "README.md"
 license = "GPL-2.0-or-later"

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/src/pyarchinit_photogrammetry/__init__.py

@@ -32,7 +32,7 @@ from .core import (ARCHAEO_CLASSES, ASPRS_CLASSES, Camera, Chunk, Document, Mark
 from .core.progress import Cancelled, Progress, print_progress
 from . import demo  # noqa: E402  (ppg.demo.create_demo)
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 
 __all__ = ["app", "Document", "Chunk", "Camera", "Sensor", "Marker", "Projection", "Reference", "ScaleBar",
            "PointCloud", "ASPRS_CLASSES", "ARCHAEO_CLASSES", "Progress", "Cancelled", "print_progress", "__version__"]

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/src/pyarchinit_photogrammetry/engine/multispectral.py

@@ -607,8 +607,35 @@ def build_reflectance(chunk: Chunk, bands: list[str] | None = None, resolution:
 
 
 # ------------------------------------------------------------------------------ indices and zoning
+def formula_bands(formula: str) -> set[str]:
+    """The band names a formula uses (``np`` and the numbers left out)."""
+    import ast
+
+    try:
+        tree = ast.parse(formula, mode="eval")
+    except SyntaxError as exc:
+        raise ValueError(f"formula {formula!r}: {exc.msg}") from None
+    return {n.id for n in ast.walk(tree) if isinstance(n, ast.Name) and n.id != "np"}
+
+
+def missing_bands(formula: str, available) -> list[str]:
+    """The bands a formula needs that ``available`` has not got (sorted)."""
+    return sorted(formula_bands(formula) - set(available))
+
+
+def available_indices(bands) -> list[str]:
+    """The indices of :data:`INDICES` whose bands are all among ``bands``."""
+    return [name for name, (formula, _) in INDICES.items() if not missing_bands(formula, bands)]
+
+
 def index_values(formula: str, bands: dict[str, np.ndarray]) -> np.ndarray:
-    """``formula`` over the band arrays (names as in :data:`INDICES`); NaN where undefined."""
+    """``formula`` over the band arrays (names as in :data:`INDICES`); NaN where undefined. A
+    band the captures have not got (the thermal LWIR of a camera without it) is an error that
+    names it, not a crash."""
+    missing = missing_bands(formula, bands)
+    if missing:
+        raise ValueError(f"the formula needs the band(s) {', '.join(missing)}, which these captures have not got "
+                         f"(bands: {', '.join(bands)})")
     names = {k: np.asarray(v, np.float32) for k, v in bands.items()}
     with np.errstate(divide="ignore", invalid="ignore"):
         out = eval(formula, {"__builtins__": {}, "np": np}, names)  # noqa: S307 - our own formulas
@@ -632,6 +659,9 @@ def index_raster(chunk: Chunk, name: str, formula: str | None = None) -> Path:
         profile = src.profile.copy()
     out = index_values(formula, bands)
     profile.update(count=1, dtype="float32", nodata=float("nan"))
+    if not profile.get("tiled"):
+        profile.pop("blockxsize", None)
+        profile.pop("blockysize", None)
     target = chunk.data_dir / "multispectral" / f"{name}.tif"
     with rasterio.open(target, "w", **profile) as dst:
         dst.write(out, 1)
@@ -736,7 +766,8 @@ def export_zoning(chunk: Chunk, name: str, path, classes: int = 3, method: str =
         dst.write(cls, 1)
     areas = {k: round(sum(a["area_m2"] for _, a in polys if a["classe"] == k), 2) for k in range(1, classes + 1)}
     summary = {"index": name, "classes": classes, "method": method, "breaks": [round(b, 4) for b in breaks],
-               "polygons": len(polys), "area_m2": areas, "file": str(path)}
+               "polygons": len(polys), "area_m2": areas, "file": str(path),
+               "raster": str((chunk.data_dir / "multispectral" / f"{name}_zone.tif").relative_to(chunk.data_dir))}
     ms.setdefault("zoning", {})[name] = summary
     json.dumps(summary)  # serialisable
     return summary

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/src/pyarchinit_photogrammetry/gui/icons.py

@@ -49,6 +49,9 @@ ICONS = {
     "ifc": ("mdi6.office-building-outline", "slate"), "script": ("mdi6.language-python", "blue"),
     "plugin": ("mdi6.puzzle-outline", "violet"),
     "network": ("mdi6.lan-connect", "violet"),
+    "multispectral": ("mdi6.leaf", "green"), "run": ("mdi6.play-circle-outline", "green"),
+    "index": ("mdi6.sprout-outline", "lime"), "zones": ("mdi6.view-dashboard-outline", "amber"),
+    "qgis": ("mdi6.map-search-outline", "lime"),
     # PyArchInit
     "database": ("mdi6.database-outline", "olive"), "publish": ("mdi6.database-arrow-up-outline", "olive"),
     "load": ("mdi6.database-arrow-down-outline", "olive"), "refresh": ("mdi6.refresh", "grey"),

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/src/pyarchinit_photogrammetry/gui/image_views.py

@@ -15,7 +15,9 @@ from PySide6.QtWidgets import (QGraphicsEllipseItem, QGraphicsPathItem, QGraphic
 from .i18n import tr
 
 RELIEF_KINDS = ("svf", "openness_pos", "openness_neg", "slrm", "msrm", "multi_hillshade")  # archaeo.relief
-SCALAR_KINDS = ("dem", "diff", "sigma", "coverage", "slope", "aspect") + RELIEF_KINDS  # one band of values, coloured
+SCALAR_KINDS = ("dem", "diff", "sigma", "coverage", "slope", "aspect", "index", "zones") + RELIEF_KINDS  # one band of values, coloured
+ZONE_COLORS = [(214, 96, 77), (247, 203, 120), (178, 223, 138), (26, 152, 80), (0, 109, 44), (69, 117, 180),
+               (152, 78, 163), (255, 127, 0), (166, 86, 40), (120, 120, 120)]  # the classes of a zoning, 1 = lowest
 US_COLORS = ["#e6194b", "#3cb44b", "#ffe119", "#4363d8", "#f58231", "#911eb4", "#46f0f0", "#f032e6", "#bcf60c",
              "#fabebe", "#008080", "#e6beff", "#9a6324", "#800000", "#aaffc3", "#808000"]
 
@@ -70,6 +72,76 @@ def dem_colors(z: np.ndarray, res: float, limits: tuple[float, float] | None = N
     return rgba
 
 
+def index_limits(z: np.ndarray) -> tuple[float, float]:
+    """The ends of the colour ramp of a vegetation index: the 2nd and 98th percentiles, within
+    -1 and 1 for the normalised indices."""
+    valid = np.isfinite(z)
+    if not valid.any():
+        return -1.0, 1.0
+    lo, hi = np.percentile(z[valid], [2, 98])
+    if lo >= -1.0 and hi <= 1.0:
+        lo, hi = max(lo, -1.0), min(hi, 1.0)
+    return float(lo), float(hi) if hi > lo else float(lo) + 1e-6
+
+
+def index_colors(z: np.ndarray, limits: tuple[float, float] | None = None) -> np.ndarray:
+    """A vegetation index: brown-red where low, pale yellow in the middle, dark green where
+    high (the ramp of the agronomic maps); transparent where no data."""
+    valid = np.isfinite(z)
+    rgba = np.zeros(z.shape + (4,), np.uint8)
+    if not valid.any():
+        return rgba
+    lo, hi = limits if limits is not None else index_limits(z)
+    t = np.clip((np.where(valid, z, lo) - lo) / max(hi - lo, 1e-9), 0, 1)
+    stops = np.array([[0.0, 165, 0, 38], [0.25, 244, 109, 67], [0.5, 254, 224, 139], [0.75, 102, 189, 99],
+                      [1.0, 0, 104, 55]])
+    rgba[..., :3] = np.stack([np.interp(t, stops[:, 0], stops[:, k]) for k in (1, 2, 3)], -1).astype(np.uint8)
+    rgba[..., 3] = np.where(valid, 255, 0)
+    return rgba
+
+
+def zone_colors(c: np.ndarray) -> np.ndarray:
+    """The classes of a zoning (1, 2, ...), one colour each; transparent where no class."""
+    valid = np.isfinite(c) & (c > 0)
+    rgba = np.zeros(c.shape + (4,), np.uint8)
+    if not valid.any():
+        return rgba
+    k = (np.where(valid, c, 1).astype(int) - 1) % len(ZONE_COLORS)
+    rgba[..., :3] = np.asarray(ZONE_COLORS, np.uint8)[k]
+    rgba[..., 3] = np.where(valid, 255, 0)
+    return rgba
+
+
+def band_limits(path, bands: tuple[int, int, int]) -> list[tuple[float, float]]:
+    """The 2nd-98th percentile stretch of three bands of a multi-band raster, read at a reduced
+    size: the same for the whole raster and for the details."""
+    import rasterio
+    from rasterio.enums import Resampling
+
+    out = []
+    with rasterio.open(path) as src:
+        f = max(1, int(np.ceil(max(src.width, src.height) / 2048)))
+        for b in bands:
+            a = src.read(b, out_shape=(max(src.height // f, 1), max(src.width // f, 1)), resampling=Resampling.nearest,
+                         masked=True).astype(np.float64).filled(np.nan)
+            v = a[np.isfinite(a)]
+            lo, hi = (np.percentile(v, [2, 98]) if v.size > 16 else (0.0, 1.0))
+            out.append((float(lo), float(hi) if hi > lo else float(lo) + 1e-6))
+    return out
+
+
+def stretched_rgba(arr: np.ndarray, limits: list[tuple[float, float]]) -> np.ndarray:
+    """Three float bands ``(h, w, 3)`` stretched between their limits into RGBA, transparent
+    where a band has no value."""
+    h, w = arr.shape[:2]
+    rgba = np.zeros((h, w, 4), np.uint8)
+    valid = np.isfinite(arr).all(axis=-1)
+    for k, (lo, hi) in enumerate(limits[:3]):
+        rgba[..., k] = np.clip((np.nan_to_num(arr[..., k], nan=lo) - lo) / max(hi - lo, 1e-9) * 255, 0, 255).astype(np.uint8)
+    rgba[..., 3] = np.where(valid, 255, 0)
+    return rgba
+
+
 def diff_colors(d: np.ndarray, limit: float | None = None) -> tuple[np.ndarray, float]:
     """Differences between two DEMs: blue below zero, white at zero, red above (symmetric,
     saturated at ``limit``, default the 98th percentile of the absolute differences). Returns
@@ -191,10 +263,13 @@ def relief_colors(z: np.ndarray, kind: str, limits: tuple[float, float] | None =
 
 
 def read_window_rgba(path, kind: str, window: tuple[int, int, int, int], out_shape: tuple[int, int],
-                     dem_range: tuple[float, float] | None = None, diff_limit: float | None = None) -> np.ndarray:
+                     dem_range: tuple[float, float] | None = None, diff_limit: float | None = None,
+                     bands: tuple[int, int, int] | None = None, limits: list | None = None) -> np.ndarray:
     """RGBA ``(h, w, 4)`` of a window ``(col, row, width, height)`` of a raster read at
     ``out_shape`` (the overviews of the file are used when smaller), coloured like the whole
-    raster: orthomosaic bands as they are, DEM tinted and shaded, difference of DEMs diverging."""
+    raster: orthomosaic bands as they are, DEM tinted and shaded, difference of DEMs diverging,
+    a vegetation index on its ramp, a zoning by class, a reflectance orthomosaic by three of its
+    bands (1-based ``bands``) stretched between ``limits``."""
     import rasterio
     from rasterio.enums import Resampling
     from rasterio.windows import Window
@@ -205,7 +280,7 @@ def read_window_rgba(path, kind: str, window: tuple[int, int, int, int], out_sha
         win = Window(col, row, width, height)
         if kind in SCALAR_KINDS:
             z = src.read(1, window=win, out_shape=(h, w), masked=True,
-                         resampling=Resampling.nearest if kind in ("coverage", "aspect") else Resampling.average
+                         resampling=Resampling.nearest if kind in ("coverage", "aspect", "zones") else Resampling.average
                          ).astype(np.float64).filled(np.nan)
             if kind == "slope":
                 return slope_colors(z, diff_limit)[0]
@@ -217,10 +292,19 @@ def read_window_rgba(path, kind: str, window: tuple[int, int, int, int], out_sha
                 return sigma_colors(z, diff_limit)[0]
             if kind == "coverage":
                 return coverage_colors(z)
+            if kind == "index":
+                return index_colors(z, dem_range)
+            if kind == "zones":
+                return zone_colors(z)
             if kind in RELIEF_KINDS:
                 return relief_colors(z, kind, dem_range)
             res = abs(src.transform.a) * width / max(w, 1)
             return dem_colors(z, res, dem_range)
+        if kind == "reflectance":
+            bands = bands or (1, 2, 3)
+            arr = src.read(list(bands), window=win, out_shape=(3, h, w), resampling=Resampling.average,
+                           masked=True).astype(np.float64).filled(np.nan)
+            return stretched_rgba(np.moveaxis(arr, 0, -1), limits or band_limits(path, bands))
         n = min(src.count, 4)
         arr = np.moveaxis(src.read(list(range(1, n + 1)), window=win, out_shape=(n, h, w),
                                    resampling=Resampling.average), 0, -1)
@@ -388,7 +472,7 @@ class RasterView(_ZoomView):
             self.layers_changed.emit()
 
     # ----------------------------------------------------------- data
-    def load(self, path: str | Path, kind: str, max_side: int = 6000) -> None:
+    def load(self, path: str | Path, kind: str, max_side: int = 6000, bands=None) -> None:
         import rasterio
         from rasterio.enums import Resampling
 
@@ -430,9 +514,21 @@ class RasterView(_ZoomView):
                 elif kind in RELIEF_KINDS:  # the stretch of the whole raster, also for the detail
                     self._dem_range = relief_limits(self.z, kind)
                     rgba = relief_colors(self.z, kind, self._dem_range)
+                elif kind == "index":  # a vegetation index: its ramp between the percentiles of the whole raster
+                    self._dem_range = index_limits(self.z)
+                    rgba = index_colors(self.z, self._dem_range)
+                elif kind == "zones":  # the classes of a zoning
+                    rgba = zone_colors(self.z)
                 else:
                     self._dem_range = dem_limits(self.z)
                     rgba = dem_colors(self.z, abs(self.tr.a), self._dem_range)
+            elif kind == "reflectance":  # three bands of a float multi-band raster, stretched
+                self.z = None
+                self._bands = tuple(int(b) for b in (bands or (1, 2, 3)))[:3]
+                self._band_limits = band_limits(path, self._bands)
+                arr = src.read(list(self._bands), out_shape=(3, h, w), resampling=Resampling.average,
+                               masked=True).astype(np.float64).filled(np.nan)
+                rgba = stretched_rgba(np.moveaxis(arr, 0, -1), self._band_limits)
             else:
                 self.z = None
                 n = min(src.count, 4)
@@ -502,7 +598,7 @@ class RasterView(_ZoomView):
         self._detail_key = (window, shape)
         self._detail_gen += 1
         job = (self._detail_gen, str(self.path), self.kind, window, shape, scene, self._dem_range,
-               self.diff_limit)
+               self.diff_limit, getattr(self, "_bands", None), getattr(self, "_band_limits", None))
         if wait:
             self._show_detail(*self._read_detail(job))
         else:
@@ -510,8 +606,9 @@ class RasterView(_ZoomView):
 
     @staticmethod
     def _read_detail(job):
-        gen, path, kind, window, shape, scene, dem_range, diff_limit = job
-        rgba = read_window_rgba(path, kind if kind in SCALAR_KINDS else "ortho", window, shape, dem_range, diff_limit)
+        gen, path, kind, window, shape, scene, dem_range, diff_limit, bands, limits = job
+        kind = kind if kind in SCALAR_KINDS or kind == "reflectance" else "ortho"
+        rgba = read_window_rgba(path, kind, window, shape, dem_range, diff_limit, bands=bands, limits=limits)
         return gen, to_qimage(rgba), scene
 
     def _read_detail_async(self, job) -> None:

{pyarchinit_photogrammetry-1.2.0 → pyarchinit_photogrammetry-1.2.2}/src/pyarchinit_photogrammetry/gui/main_window.py

@@ -279,6 +279,19 @@ class MainWindow(QMainWindow):
         self.proxies_pane.quote_requested.connect(self.quote_proxies)
         self.proxies_pane.us_requested.connect(self._us_form_from_proxy)
         self.proxies_pane.delete_requested.connect(self.delete_proxies)
+        from .multispectral_pane import MultispectralPane
+
+        self.ms_pane = MultispectralPane()
+        self.left_tabs.addTab(self.ms_pane, icon("multispectral"), tr("Multispettrale"))
+        self.ms_pane.add_requested.connect(self.ms_add)
+        self.ms_pane.align_requested.connect(self.align_photos)
+        self.ms_pane.surface_requested.connect(self.ms_build_surface)
+        self.ms_pane.panel_requested.connect(self.ms_panel)
+        self.ms_pane.reflectance_requested.connect(self.ms_reflectance)
+        self.ms_pane.show_requested.connect(self.ms_show)
+        self.ms_pane.index_requested.connect(self.ms_compute_index)
+        self.ms_pane.zoning_requested.connect(self.ms_zoning)
+        self.ms_pane.qgis_requested.connect(self.open_in_qgis)
         self.sections_pane = SectionsPane()
         self.sections_pane.zoom_requested.connect(self._zoom_section)
         self.sections_pane.publish_requested.connect(self._publish_section)
@@ -933,6 +946,7 @@ class MainWindow(QMainWindow):
         step(0.95, tr("Sezioni e disegni"))
         self._load_sections()
         self.proxies_pane.set_proxies(self.chunk.meta.get("proxies", []) if self.chunk else [])
+        self.ms_pane.set_state(self.chunk)
         if self.history is None:
             self.history = UndoHistory(self._undo_state, self._undo_apply, lambda: self.chunk,
                                        on_change=self._undo_actions)
@@ -963,10 +977,12 @@ class MainWindow(QMainWindow):
         step(0.6, tr("Ortofoto e DEM"))
         self._load_raster()
         self._update_stack()
+        self.ms_pane.set_state(self.chunk)
 
-    def _load_raster(self, kind: str | None = None, path=None) -> None:
+    def _load_raster(self, kind: str | None = None, path=None, bands=None) -> None:
         """The orthomosaic or the DEM of the chunk in the raster view (``path``: another file of
-        that kind, e.g. a kept version or a difference of DEMs) with the drawings on top."""
+        that kind, e.g. a kept version or a difference of DEMs; ``bands``: the three to show of a
+        reflectance orthomosaic) with the drawings on top."""
         ch = self.chunk
         kind = kind or ("ortho" if ch is not None and ch.orthomosaic_path else "dem")
         if path is None:
@@ -976,7 +992,7 @@ class MainWindow(QMainWindow):
             self.ortho_view.tr = None
             self.ortho_view.scene().addText(tr("Costruisci il DEM o l'ortofoto per vederli qui"))
             return
-        self.ortho_view.load(path, kind)
+        self.ortho_view.load(path, kind, bands=bands)
         if kind == "ortho" and ch.dem_path:
             self.ortho_view.set_dem(ch.dem_path)
         self._raster_version = None
@@ -1202,6 +1218,153 @@ class MainWindow(QMainWindow):
         self.run_task("Ortofoto di riflettanza", lambda p: ms.build_reflectance(self.chunk, resolution=v["resolution"], progress=p),
                       lambda path: self._info(tr("Ortofoto di riflettanza"), str(path)))
 
+    def ms_build_surface(self) -> None:
+        """Depth maps, dense cloud and DEM in one step with the default choices: what the
+        reflectance orthomosaic needs, for the multispectral pane."""
+        if not self._need_chunk(aligned=True):
+            return
+        ch = self.chunk
+
+        def job(p):
+            if not (ch.data_dir / "dense" / "stereo" / "depth_maps").exists():
+                ch.build_depth_maps(quality="medium", progress=p.sub(0.0, 0.6))
+            if not ch.product_path("point_cloud"):
+                ch.build_point_cloud(progress=p.sub(0.6, 0.25))
+            ch.build_dem(progress=p.sub(0.85, 0.15))
+            return ch.dem_path
+
+        self.run_task("Superficie per il multispettrale", job,
+                      lambda path: self._info(tr("Superficie"), tr("DEM pronto: {0}", path)))
+
+    def _ms_meta(self) -> dict:
+        return (self.chunk.meta.get("multispectral") if self.chunk is not None else None) or {}
+
+    def ms_show(self, kind: str, payload=None) -> None:
+        """A multispectral product in the raster view: the reflectance orthomosaic by three of
+        its bands (names, false colour by default), an index on its ramp, the zones by class
+        (and their polygons as a layer)."""
+        ms = self._ms_meta()
+        ch = self.chunk
+        if kind == "reflectance":
+            rel = ms.get("reflectance")
+            if not rel:
+                self._warn("Costruisci prima l'ortofoto di riflettanza.")
+                return
+            names = list(ms.get("reflectance_bands") or [])
+            wanted = list(payload) if payload else ["NIR", "Red", "Green"]
+            idx = [names.index(b) + 1 for b in wanted if b in names]
+            if len(idx) < 3:
+                idx = (idx + [1, 2, 3])[:3]
+            self._load_raster("reflectance", ch.data_dir / rel, bands=tuple(idx))
+            self.statusBar().showMessage(tr("Riflettanza: bande {0}", ", ".join(names[i - 1] for i in idx)))
+        elif kind == "index":
+            info = (ms.get("indices") or {}).get(payload or "")
+            if not info:
+                self._warn("Calcola prima l'indice.")
+                return
+            self._load_raster("index", ch.data_dir / info["file"])
+            lo, hi = self.ortho_view._dem_range or (-1.0, 1.0)
+            self.statusBar().showMessage(tr("{0}: colori da {1} (rosso) a {2} (verde)", payload, f"{lo:.2f}", f"{hi:.2f}"))
+        elif kind == "zones":
+            z = (ms.get("zoning") or {}).get(payload or "")
+            if not z or not z.get("raster"):
+                self._warn("Fai prima la zonizzazione.")
+                return
+            self._load_raster("zones", ch.data_dir / z["raster"])
+            self._ms_zone_layer(payload, z)
+        else:
+            return
+        self.show_view(self.ortho_view)
+
+    def _ms_zone_layer(self, name: str, z: dict, limit: int = 3000) -> None:
+        """The polygons of a zoning as a layer of the raster view (up to ``limit``, the largest)."""
+        from ..io import gpkg
+
+        layer = tr("Zone {0}", name)
+        if layer in self.ortho_view.layers:
+            return
+        path = Path(z.get("file", ""))
+        if not path.exists():
+            return
+        try:
+            rows = gpkg.read_table(path, "zone")
+        except Exception as exc:  # noqa: BLE001
+            log.warning("zone %s: %s", path, exc)
+            return
+        rows = sorted(rows, key=lambda r: -(r[1].get("area_m2") or 0))[:limit]
+        from .image_views import ZONE_COLORS
+
+        with self.ortho_view.batch():
+            for geom, attrs in rows:
+                polys = list(geom.geoms) if geom.geom_type == "MultiPolygon" else [geom]
+                for poly in polys:
+                    rgb = ZONE_COLORS[(int(attrs.get("classe") or 1) - 1) % len(ZONE_COLORS)]
+                    self.ortho_view.add_polygon(list(poly.exterior.coords), label="", color="#%02x%02x%02x" % rgb,
+                                                fill_alpha=0, layer=layer, attrs=dict(attrs))
+        if len(rows) == limit:
+            self.log_pane.info(tr("Zone {0}: nel layer i {1} poligoni più grandi; tutti sono nel GeoPackage {2}",
+                                  name, limit, path))
+
+    def ms_compute_index(self, name: str, formula: str = "") -> None:
+        """An index from the reflectance orthomosaic (a known one, or a formula asked for), then shown."""
+        if not self._need_chunk():
+            return
+        from ..engine import multispectral as ms_mod
+
+        if not self._ms_meta().get("reflectance"):
+            self._warn("Costruisci prima l'ortofoto di riflettanza.")
+            return
+        if name == "formula":
+            text, ok = QInputDialog.getText(self, tr("Formula dell'indice"),
+                                            tr("Formula sui nomi delle bande ({0}):", ", ".join(self._ms_meta().get("reflectance_bands") or [])),
+                                            text="(NIR - Red) / (NIR + Red)")
+            if not ok or not text.strip():
+                return
+            formula = text.strip()
+            label, ok = QInputDialog.getText(self, tr("Nome dell'indice"), tr("Nome del raster (senza spazi):"), text="Indice")
+            if not ok or not label.strip():
+                return
+            name = "".join(c for c in label.strip() if c.isalnum() or c in "_-") or "Indice"
+        formula = formula or None
+        used = formula or ms_mod.INDICES.get(name, ("", ""))[0]
+        bands = self._ms_meta().get("reflectance_bands") or self._ms_meta().get("bands") or []
+        try:
+            missing = ms_mod.missing_bands(used, bands) if used else []
+        except ValueError as exc:
+            self._warn(tr("Formula non valida: {0}", exc))
+            return
+        if missing:
+            self._warn(tr("L'indice {0} usa le bande {1}, che queste riprese non hanno (bande: {2}).", name,
+                          ", ".join(missing), ", ".join(bands)))
+            return
+        self.run_task(tr("Indice {0}", name), lambda p: ms_mod.index_raster(self.chunk, name, formula),
+                      lambda path: self.ms_show("index", name))
+
+    def ms_zoning(self, name: str, classes: int = 3, method: str = "quantiles") -> None:
+        """The zoning of an index: polygons in a GeoPackage beside the project, the class raster
+        shown with the polygons as a layer."""
+        if not self._need_chunk():
+            return
+        from ..engine import multispectral as ms_mod
+
+        if name == "formula" or name not in (self._ms_meta().get("indices") or {}):
+            self._warn("Calcola prima l'indice scelto.")
+            return
+        base = Path(self.doc.path).with_name(f"{Path(self.doc.path).stem}_{name}_zone.gpkg") if self.doc.path \
+            else self.chunk.data_dir / "multispectral" / f"{name}_zone.gpkg"
+        path, _f = QFileDialog.getSaveFileName(self, tr("GeoPackage delle zone"), str(base), "GeoPackage (*.gpkg)")
+        if not path:
+            return
+
+        def done(summary):
+            self.ortho_view.remove_layer(tr("Zone {0}", name)) if tr("Zone {0}", name) in self.ortho_view.layers else None
+            self.ms_show("zones", name)
+            self._info(tr("Zonizzazione"), tr("{0}: {1} poligoni, soglie {2}, in {3}", name, summary["polygons"],
+                                               ", ".join(f"{b:.3g}" for b in summary["breaks"]), path))
+
+        self.run_task(tr("Zonizzazione {0}", name),
+                      lambda p: ms_mod.export_zoning(self.chunk, name, path, classes=int(classes), method=method), done)
+
     def ms_index(self) -> None:
         if not self._need_chunk():
             return
@@ -4571,8 +4734,13 @@ class MainWindow(QMainWindow):
                 self.show_coverage_map()
             elif payload in ("dem", "orthomosaic"):
                 self._show_raster("dem" if payload == "dem" else "ortho")
+            elif isinstance(payload, str) and payload.startswith("ms:"):
+                parts = payload.split(":", 2)
+                self.ms_show(parts[1], parts[2] if len(parts) > 2 else None)
             else:
                 self._show_model(payload)
+        elif kind == "multispectral":
+            self._show_pane(self.left_tabs, self.ms_pane)
         elif kind == "version":
             self.show_version(*payload)
         elif kind == "elevation":
@@ -6229,10 +6397,37 @@ class MainWindow(QMainWindow):
             rasters.append({"name": "DEM (ombreggiato)", "path": str(ch.dem_path), "hillshade": True,
                             "opacity": 0.6, "hidden": True})
             rasters.append({"name": "DEM", "path": str(ch.dem_path), "hidden": True})
+        extra_vectors = []
+        ms = self._ms_meta()
+        if ch is not None and ms.get("reflectance") and (ch.data_dir / ms["reflectance"]).exists():
+            names = list(ms.get("reflectance_bands") or [])
+            idx = [names.index(b) + 1 for b in ("NIR", "Red", "Green") if b in names]
+            rasters.append({"name": "Riflettanza (falso colore)", "path": str(ch.data_dir / ms["reflectance"]),
+                            "bands": idx if len(idx) == 3 else [1, 2, 3], "hidden": True})
+            for iname, info in (ms.get("indices") or {}).items():
+                p_i = ch.data_dir / info.get("file", "")
+                if p_i.exists():
+                    rasters.append({"name": f"Indice {iname}", "path": str(p_i), "ramp": "index", "hidden": True})
+            for zname, z in (ms.get("zoning") or {}).items():
+                if z.get("raster") and (ch.data_dir / z["raster"]).exists():
+                    rasters.append({"name": f"Zone {zname} (raster)", "path": str(ch.data_dir / z["raster"]),
+                                    "ramp": "zones", "classes": z.get("classes", 3), "hidden": True})
+                if z.get("file") and Path(z["file"]).exists():
+                    extra_vectors.append({"name": f"Zone {zname}", "path": z["file"], "table": "zone",
+                                          "geometry": "POLYGON", "color": "#1a9850", "label": "classe"})
+
+        for provider in getattr(self, "qgis_providers", []):  # plugins: their rasters and GeoPackage layers
+            try:
+                more_rasters, more_vectors = provider()
+                rasters += list(more_rasters or [])
+                extra_vectors += list(more_vectors or [])
+            except Exception as exc:  # noqa: BLE001 - a plugin must not stop the export
+                log.warning("QGIS: layer di un plugin saltati: %s", exc)
 
         def job(p):
             p(0.2, "Creazione del progetto QGIS")
-            rep = qgis_link.build_project(project, ch.crs if ch else "", files, rasters, title=name, qgis=q)
+            rep = qgis_link.build_project(project, ch.crs if ch else "", files, rasters, title=name, qgis=q,
+                                          extra_vectors=extra_vectors)
             qgis_link.open_in_qgis(project, q)
             return rep