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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-photogrammetry
-Version: 1.2.2
+Version: 1.3.0
 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
@@ -40,10 +40,13 @@ Provides-Extra: sam
 Requires-Dist: torch>=2.3; extra == "sam"
 Requires-Dist: sam2>=1.1; extra == "sam"
 Requires-Dist: huggingface_hub>=0.20; extra == "sam"
+Provides-Extra: learned
+Requires-Dist: torch>=2.3; extra == "learned"
+Requires-Dist: kornia>=0.8; extra == "learned"
 Provides-Extra: learn
 Requires-Dist: scikit-learn>=1.3; extra == "learn"
 Provides-Extra: fast
-Requires-Dist: pyarchinit-photogrammetry-core>=0.3; extra == "fast"
+Requires-Dist: pyarchinit-photogrammetry-core>=0.4.1; extra == "fast"
 Provides-Extra: scans
 Requires-Dist: pye57>=0.4; extra == "scans"
 Provides-Extra: munsell

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-photogrammetry"
-version = "1.2.2"
+version = "1.3.0"
 description = "Open-source photogrammetry engine for archaeology and BIM, integrated with PyArchInit"
 readme = "README.md"
 license = "GPL-2.0-or-later"
@@ -42,8 +42,9 @@ bim = ["ifcopenshell>=0.8"]
 postgis = ["psycopg2-binary>=2.9; sys_platform != 'win32' or platform_machine != 'ARM64'",
            "psycopg>=3.1; sys_platform == 'win32' and platform_machine == 'ARM64'"]  # psycopg 3 over libpq on Windows ARM64
 sam = ["torch>=2.3", "sam2>=1.1", "huggingface_hub>=0.20"]  # the weights come from the Hugging Face hub
+learned = ["torch>=2.3", "kornia>=0.8"]  # learned key points + LightGlue (engine.learned), run in a worker process
 learn = ["scikit-learn>=1.3"]  # trainable point classification (ai.learn)
-fast = ["pyarchinit-photogrammetry-core>=0.3"]  # native kernels in Rust (native/), optional
+fast = ["pyarchinit-photogrammetry-core>=0.4.1"]  # native kernels in Rust (native/), optional
 scans = ["pye57>=0.4"]  # laser scans in E57 (io.scans; PTX needs nothing)
 munsell = ["colour-science>=0.4.4"]  # Munsell notation of the colours (archaeo.munsell)
 gui = ["PySide6>=6.6", "pyvista>=0.43", "pyvistaqt>=0.13", "qtawesome>=1.3", "scikit-learn>=1.3",

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

@@ -19,9 +19,12 @@ Quick start::
     chunk.build_orthomosaic()
     doc.save("scavo.ppg")
 """
+from ._env import glog_flushes_each_line as _glog_flushes_each_line
 from ._env import load_open3d_first as _load_open3d_first
 from ._env import use_bundled_proj_data as _use_bundled_proj_data
 
+_glog_flushes_each_line()  # before pycolmap loads: its log is tailed for the progress (see _env.py)
+
 _load_open3d_first()  # Open3D's OpenMP runtime must be bound before rasterio/scipy (see _env.py)
 
 _use_bundled_proj_data()  # before anything opens a CRS (see _env.py)
@@ -32,7 +35,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.2"
+__version__ = "1.3.0"
 
 __all__ = ["app", "Document", "Chunk", "Camera", "Sensor", "Marker", "Projection", "Reference", "ScaleBar",
            "PointCloud", "ASPRS_CLASSES", "ARCHAEO_CLASSES", "Progress", "Cancelled", "print_progress", "__version__"]

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.0}/src/pyarchinit_photogrammetry/_env.py

@@ -82,3 +82,10 @@ def skip_open3d_extras() -> None:
 
         plotly.draw_plotly = plotly.draw_plotly_server = unavailable
         sys.modules[plotly.__name__] = plotly
+
+
+def glog_flushes_each_line() -> None:
+    """COLMAP's log (glog) written to a file line by line: by default glog keeps 30 seconds of
+    lines in a buffer, and :mod:`engine.colmap_log` tails that file to show the progress of a
+    step while COLMAP runs it. Read when the library loads: call before importing pycolmap."""
+    os.environ.setdefault("GLOG_logbufsecs", "0")

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.0}/src/pyarchinit_photogrammetry/_native.py

@@ -116,3 +116,42 @@ def gpu_forget() -> None:
     fn = getattr(core, "gpu_forget", None) if core is not None else None
     if fn is not None:
         fn()
+
+
+def gpu_fuse(reference, neighbours, min_pixels: int = 3, max_reproj: float = 2.0, max_depth_rel: float = 0.01,
+             max_normal_deg: float = 20.0, support_tol: float = 0.01, device: int = -1):
+    """The dense points of one depth map fused with its covisible maps on the GPU (API 7): every
+    map ``(key, depth (h x w float32) or None when the GPU holds it, (fx, fy, cx, cy), rotation
+    3x3, translation, order)``; returns ``(xyz, normals, pixel, pixels, support)``."""
+    fn = kernel("gpu_fuse")
+    if fn is None:
+        raise RuntimeError("the GPU fusion needs pyarchinit-photogrammetry-core 0.4 (API 7)")
+    return fn(reference, neighbours, int(min_pixels), float(max_reproj), float(max_depth_rel), float(max_normal_deg),
+              float(support_tol), int(device))
+
+
+def gpu_fuse_cached(device: int = -1) -> list[int]:
+    """The keys of the depth maps the GPU keeps for the fusion."""
+    fn = kernel("gpu_fuse_cached")
+    return list(fn(int(device))) if fn is not None else []
+
+
+def gpu_fuse_forget(device: int = -1) -> None:
+    """Drop the depth maps the GPU keeps for the fusion: their keys are image ids, unique within
+    one workspace only."""
+    fn = kernel("gpu_fuse_forget")
+    if fn is not None:
+        fn(int(device))
+
+
+def gpu_sift(image, max_features: int = 8192, first_octave: int = -1, num_octaves: int = 4, octave_resolution: int = 3,
+             peak_threshold: float = 0.02 / 3.0, edge_threshold: float = 10.0, max_orientations: int = 2,
+             upright: bool = False, device: int = -1):
+    """SIFT key points ``(n, 4)`` float32 (x, y, scale, orientation; the centre of the first pixel
+    at (0, 0), as VLFeat) and descriptors ``(n, 128)`` uint8 of a grey float image in [0, 1] on
+    the GPU, as COLMAP's CPU extractor computes them (API 6 of the extension)."""
+    fn = kernel("gpu_sift")
+    if fn is None:
+        raise RuntimeError("the GPU SIFT needs pyarchinit-photogrammetry-core 0.4 (API 6)")
+    return fn(image, int(max_features), int(first_octave), int(num_octaves), int(octave_resolution),
+              float(peak_threshold), float(edge_threshold), int(max_orientations), bool(upright), int(device))

pyarchinit_photogrammetry-1.3.0/src/pyarchinit_photogrammetry/ai/learned_net.py

@@ -0,0 +1,117 @@
+"""Learned key points and LightGlue with kornia: the part that needs PyTorch, on its own.
+
+The program imports it through :mod:`pyarchinit_photogrammetry.engine.learned` when PyTorch and
+kornia are installed beside it. The packaged application has no PyTorch: there it runs in the
+separate environment of SAM 2.1 through ``learned_worker.py``. So it imports nothing but numpy,
+torch and kornia.
+
+ALIKED (Zhao et al. 2023, BSD-3-Clause) or DISK (Tyszkiewicz et al. 2020, Apache-2.0) find the key points and
+describe them with a small network; LightGlue (Lindenberger et al. 2023, Apache-2.0) matches two
+sets of them with attention and leaves out the pairs it is not sure of. The key points come back
+with the centre of the first pixel at 0, as OpenCV.
+"""
+from __future__ import annotations
+
+from collections import OrderedDict
+
+import numpy as np
+
+KINDS = {"disk": "DISK + LightGlue", "aliked": "ALIKED + LightGlue"}
+MAX_KEYPOINTS = 4096
+CACHED_FILES = 96  # descriptor files kept in memory while the pairs are matched
+
+
+def pick_device(name: str | None = None):
+    """CUDA, else Apple's GPU (Metal), else the CPU; ``name`` forces one."""
+    import torch
+
+    if name:
+        return torch.device(name)
+    if torch.cuda.is_available():
+        return torch.device("cuda")
+    mps = getattr(torch.backends, "mps", None)
+    if mps is not None and mps.is_available():
+        return torch.device("mps")
+    return torch.device("cpu")
+
+
+class Features:
+    """The extractor of one kind and LightGlue for it, on the device."""
+
+    def __init__(self, kind: str = "disk", max_keypoints: int = MAX_KEYPOINTS, device: str | None = None):
+        import kornia.feature as KF
+        import torch
+
+        if kind not in KINDS:
+            raise ValueError(f"unknown learned features {kind!r}: {', '.join(KINDS)}")
+        self.kind = kind
+        self.max_keypoints = int(max_keypoints)
+        self.dev = pick_device(device)
+        self._torch = torch
+        self._KF = KF
+        if kind == "aliked":
+            # threshold 0: the strongest points up to the limit, whatever their score (thermal frames have weak ones)
+            self.net = KF.ALIKED.from_pretrained("aliked-n16", max_num_keypoints=self.max_keypoints,
+                                                 detection_threshold=0.0, device=self.dev).eval()
+        else:
+            self.net = KF.DISK.from_pretrained("depth", device=self.dev).eval()
+        self.matcher = KF.LightGlueMatcher(kind).to(self.dev).eval()
+        self._files: OrderedDict[str, tuple] = OrderedDict()
+
+    @property
+    def device(self) -> str:
+        return self.dev.type
+
+    def extract(self, grey: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """Key points ``(N, 2)`` float32 (x, y) and descriptors ``(N, D)`` float16 of a grey image
+        (uint8, or float in 0..1)."""
+        torch = self._torch
+        img = np.asarray(grey)
+        scale = 255.0 if img.dtype == np.uint8 else 1.0
+        t = torch.from_numpy(np.ascontiguousarray(img, np.float32) / scale)[None, None].repeat(1, 3, 1, 1).to(self.dev)
+        with torch.inference_mode():
+            if self.kind == "disk":
+                out = self.net(t, n=self.max_keypoints, pad_if_not_divisible=True)
+            else:
+                out = self.net(t)
+        kp = out[0].keypoints.float().cpu().numpy().astype(np.float32)
+        desc = out[0].descriptors.float().cpu().numpy().astype(np.float16)
+        h, w = img.shape[:2]
+        inside = (kp[:, 0] <= w - 1) & (kp[:, 1] <= h - 1)  # DISK pads to a multiple of 16
+        return np.ascontiguousarray(kp[inside]), np.ascontiguousarray(desc[inside])
+
+    def match(self, kp1, desc1, size1, kp2, desc2, size2) -> np.ndarray:
+        """LightGlue's matches ``(M, 2)`` uint32 (indices into the two sets); ``size`` = (height, width)
+        of the image the points were found on."""
+        torch, KF = self._torch, self._KF
+        if len(kp1) < 2 or len(kp2) < 2:
+            return np.zeros((0, 2), np.uint32)
+        dev = self.dev
+        k1 = torch.from_numpy(np.ascontiguousarray(kp1, np.float32)).to(dev)
+        k2 = torch.from_numpy(np.ascontiguousarray(kp2, np.float32)).to(dev)
+        d1 = torch.from_numpy(np.ascontiguousarray(desc1, np.float32)).to(dev)
+        d2 = torch.from_numpy(np.ascontiguousarray(desc2, np.float32)).to(dev)
+        with torch.inference_mode():
+            laf1 = KF.laf_from_center_scale_ori(k1[None], torch.ones(1, len(k1), 1, 1, device=dev))
+            laf2 = KF.laf_from_center_scale_ori(k2[None], torch.ones(1, len(k2), 1, 1, device=dev))
+            _dist, idx = self.matcher(d1, d2, laf1, laf2, hw1=tuple(int(v) for v in size1),
+                                      hw2=tuple(int(v) for v in size2))
+        return np.ascontiguousarray(idx.cpu().numpy().astype(np.uint32).reshape(-1, 2))
+
+    def _load(self, path: str) -> tuple:
+        got = self._files.get(path)
+        if got is None:
+            with np.load(path) as z:
+                got = (z["kp"], z["desc"], tuple(int(v) for v in z["size"]))
+            self._files[path] = got
+            if len(self._files) > CACHED_FILES:
+                self._files.popitem(last=False)
+        else:
+            self._files.move_to_end(path)
+        return got
+
+    def match_files(self, a: str, b: str) -> np.ndarray:
+        """:meth:`match` on two files written by the extraction (``kp``, ``desc``, ``size``)."""
+        ka, da, sa = self._load(str(a))
+        kb, db, sb = self._load(str(b))
+        return self.match(ka, da, sa, kb, db, sb)

pyarchinit_photogrammetry-1.3.0/src/pyarchinit_photogrammetry/ai/learned_worker.py

@@ -0,0 +1,67 @@
+"""Worker process of the learned key points (ALIKED or DISK) and LightGlue.
+
+Run by the separate Python environment of the packaged application (the one of SAM 2.1, with
+PyTorch and kornia), so it imports nothing from pyarchinit_photogrammetry, only
+``learned_net.py`` beside it. Same protocol as ``sam_worker.py``: on stdin/stdout each message is
+an 8-byte big-endian length followed by a pickle. Requests are dicts with ``op``:
+
+* ``init``    ``{"kind", "max_keypoints", "device"?}`` -> ``{"device"}``
+* ``extract`` ``{"image"}`` (grey uint8) -> ``{"kp", "desc"}``
+* ``match``   ``{"a", "b"}`` (descriptor files) -> ``{"matches"}``
+* ``quit``
+
+Replies are ``{"ok": True, ...}`` or ``{"ok": False, "error": traceback}``.
+"""
+from __future__ import annotations
+
+import os
+import pickle
+import struct
+import sys
+import traceback
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+
+def _read(stream):
+    head = stream.read(8)
+    if len(head) < 8:
+        return None
+    (n,) = struct.unpack(">Q", head)
+    return pickle.loads(stream.read(n))
+
+
+def _write(stream, obj) -> None:
+    data = pickle.dumps(obj, protocol=4)
+    stream.write(struct.pack(">Q", len(data)) + data)
+    stream.flush()
+
+
+def main() -> None:
+    stdin, stdout = sys.stdin.buffer, sys.stdout.buffer
+    sys.stdout = sys.stderr  # anything the libraries print must not break the protocol
+    feats = None
+    while True:
+        req = _read(stdin)
+        if req is None or req.get("op") == "quit":
+            break
+        try:
+            op = req["op"]
+            if op == "init":
+                from learned_net import Features
+
+                feats = Features(req.get("kind", "disk"), int(req.get("max_keypoints", 4096)), req.get("device"))
+                _write(stdout, {"ok": True, "device": feats.device})
+            elif op == "extract":
+                kp, desc = feats.extract(req["image"])
+                _write(stdout, {"ok": True, "kp": kp, "desc": desc})
+            elif op == "match":
+                _write(stdout, {"ok": True, "matches": feats.match_files(req["a"], req["b"])})
+            else:
+                _write(stdout, {"ok": False, "error": f"unknown op {op!r}"})
+        except Exception:  # noqa: BLE001 - every error goes back to the program
+            _write(stdout, {"ok": False, "error": traceback.format_exc()})
+
+
+if __name__ == "__main__":
+    main()

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.0}/src/pyarchinit_photogrammetry/ai/sam_env.py

@@ -9,9 +9,14 @@ its official GitHub release when it is not on the system):
 The model runs in a worker process of that environment (``sam_worker.py``) and
 :class:`ExternalSam2Segmenter` talks to it; it has the same methods as
 :class:`~pyarchinit_photogrammetry.ai.sam.Sam2Segmenter`, so everything else is unchanged.
+
+When PyTorch and sam2 are installed beside the program (the ``[sam]`` extra) the same worker runs
+with this Python: never PyTorch in the program's process, where pycolmap is loaded. Each brings
+its own OpenMP runtime, and the second to start aborts the process (``OMP: Error #15``).
 """
 from __future__ import annotations
 
+import importlib.util
 import io
 import json
 import os
@@ -28,7 +33,7 @@ from pathlib import Path
 
 import numpy as np
 
-PACKAGES = ["torch", "sam2", "huggingface_hub", "numpy", "pillow"]
+PACKAGES = ["torch", "sam2", "huggingface_hub", "numpy", "pillow", "kornia"]  # kornia: learned key points (engine.learned)
 UV_URL = "https://github.com/astral-sh/uv/releases/latest/download/uv-{target}.{ext}"
 
 
@@ -57,22 +62,21 @@ def is_installed(env: Path | None = None) -> bool:
 
 
 def in_process_available() -> bool:
-    """PyTorch and sam2 importable in this interpreter (pip installs with the [sam] extra),
-    with huggingface_hub that downloads the weights (sam2 does not require it)."""
+    """PyTorch and sam2 installed for this Python (pip installs with the [sam] extra), with
+    huggingface_hub that downloads the weights (sam2 does not require it). Looked up, not
+    imported: importing PyTorch here would start its OpenMP runtime beside pycolmap's."""
+    if getattr(sys, "frozen", False):  # the packaged application: its executable is not a Python
+        return False
     try:
-        import huggingface_hub  # noqa: F401
-        import sam2  # noqa: F401
-        import torch  # noqa: F401
-
-        return True
-    except Exception:
+        return all(importlib.util.find_spec(name) is not None for name in ("torch", "sam2", "huggingface_hub"))
+    except (ImportError, ValueError):
         return False
 
 
 def available() -> str | None:
-    """``"inprocess"``, ``"external"`` or None."""
+    """``"local"`` (the worker runs with this Python), ``"external"`` or None."""
     if in_process_available():
-        return "inprocess"
+        return "local"
     if is_installed():
         return "external"
     return None
@@ -272,12 +276,11 @@ class ExternalSam2Segmenter:
 
 
 def make_segmenter(model: str = "small"):
-    """The SAM 2.1 segmenter available here: in process, external environment, or ImportError."""
+    """The SAM 2.1 segmenter available here, always in a worker process (see the module): with
+    this Python, with the external environment, or ImportError."""
     mode = available()
-    if mode == "inprocess":
-        from .sam import Sam2Segmenter
-
-        return Sam2Segmenter(model)
+    if mode == "local":
+        return ExternalSam2Segmenter(model, python=sys.executable)
     if mode == "external":
         return ExternalSam2Segmenter(model)
     raise ImportError("SAM 2.1 non e' installato")

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.0}/src/pyarchinit_photogrammetry/cli.py

@@ -473,19 +473,28 @@ def align(project: Path, quality: str = typer.Option("high", help="the accuracy:
                                              help="the GPS positions of the photos hold the block during the "
                                                   "incremental alignment (default: when they exist)"),
           keep: bool = typer.Option(False, help="keep the current alignment and add the photos not yet in it"),
-          mapper: str = typer.Option("auto", help="auto, incremental (one photo after the other) or global (all at "
-                                                  "once, much faster with many photos)"),
+          mapper: str = typer.Option("auto", help="auto, incremental (one photo after the other), global (all at "
+                                                  "once, much faster with many photos) or hierarchical (clusters of "
+                                                  "photos on the cores, then merged)"),
+          ba_ratio: Optional[float] = typer.Option(None, help="the incremental mapper adjusts the whole block when it "
+                                                               "grows by this ratio (default 1.1; 1.3 adjusts a third "
+                                                               "as often)"),
+          ba_refinements: Optional[int] = typer.Option(None, help="refinements of every global adjustment (default 5)"),
           gpu: Optional[str] = typer.Option(None, help="the GPU for the matching, shared with the CPU: auto (the "
                                                        "best one), off, an adapter index or part of its name "
                                                        "(default: PPG_GPU, else auto; ppg doctor lists them)"),
+          matcher: str = typer.Option("sift", help="the points: sift (COLMAP), or learned key points matched by "
+                                                   "LightGlue, disk or aliked (thermal frames, surfaces with little "
+                                                   "texture; need PyTorch and kornia, the [learned] extra)"),
           chunk: Optional[str] = None):
     """Match photos and align cameras, with the choices of Metashape's Align Photos."""
     doc, ch = _open(project, chunk)
     ch.match_photos(quality=quality, pair_selection=pairs, keypoint_limit=keypoints, tiepoint_limit=tiepoints,
                     generic=generic, reference=None if reference == "none" else reference, neighbours=neighbours,
                     apply_masks=masks, guided_matching=guided, exclude_stationary=stationary, reset=not keep,
-                    gpu=gpu, progress=print_progress)
-    n = ch.align_cameras(progress=print_progress, mapper=mapper, reset=not keep, use_gps=gps, adaptive_fitting=adaptive)
+                    gpu=gpu, matcher=matcher, progress=print_progress)
+    n = ch.align_cameras(progress=print_progress, mapper=mapper, reset=not keep, use_gps=gps, adaptive_fitting=adaptive,
+                         ba_global_ratio=ba_ratio, ba_global_refinements=ba_refinements)
     doc.save()
     typer.echo(f"aligned {n}/{len(ch.cameras)} photos")
 
@@ -659,7 +668,7 @@ def dense(project: Path, quality: str = "medium", filter_mode: str = "moderate",
     doc, ch = _open(project, chunk)
     ch.build_depth_maps(quality=quality, filter_mode=filter_mode, backend=backend, progress=print_progress,
                         skip_unreadable=skip_unreadable, gpu=gpu)
-    pc = ch.build_point_cloud(progress=print_progress)
+    pc = ch.build_point_cloud(progress=print_progress, gpu=gpu)
     doc.save()
     typer.echo(f"{len(pc):,} points")
 
@@ -1684,9 +1693,13 @@ def plugins_disable(name: str):
     typer.echo(f"{name} disabled")
 
 
-@app.command("plugin", context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
+@app.command("plugin", context_settings={"allow_extra_args": True, "ignore_unknown_options": True,
+                                         "help_option_names": []})
 def plugin_command(ctx: typer.Context, name: Optional[str] = typer.Argument(None, help="command of a plugin")):
-    """Run a command of a plugin: ``ppg plugin NAME [ARGS]...``; without NAME, the commands available."""
+    """Run a command of a plugin: ``ppg plugin NAME [ARGS]...``; without NAME, the commands available.
+    ``--help`` goes to the plugin (``ppg plugin NAME --help`` is the plugin's own help)."""
+    if name in ("--help", "-h"):
+        name = None
     from .plugins import Manager
 
     m = Manager()
@@ -1714,6 +1727,8 @@ def multispectral(project: Path, what: str = typer.Argument(..., help="add, pane
                                                                      "photo of the panel (a reference-band file or "
                                                                      "its capture name)"),
                   reference: Optional[str] = typer.Option(None, help="add: the band to align (Red by default)"),
+                  thermal: bool = typer.Option(False, help="add: the frames of a thermal camera (every radiometric image "
+                                                           "without a band: FLIR JPEGs, TIFFs of temperatures or integers)"),
                   region: Optional[str] = typer.Option(None, help="panel: x0,y0,x1,y1 of the panel in the images"),
                   reflectance: float = typer.Option(0.5, help="panel: its known reflectance (0-1)"),
                   index: str = typer.Option("NDVI", help="index/zoning: one of the indices, or a formula over the band names"),
@@ -1722,6 +1737,8 @@ def multispectral(project: Path, what: str = typer.Argument(..., help="add, pane
                   method: str = typer.Option("quantiles", help="zoning: quantiles, equal or kmeans"),
                   out: Optional[Path] = typer.Option(None, help="zoning: the GeoPackage to write (default beside the project)"),
                   resolution: Optional[float] = typer.Option(None, help="reflectance: metres per pixel (the orthomosaic's)"),
+                  balance: bool = typer.Option(True, help="reflectance: bring the photos to the same reflectance where "
+                                                          "they overlap (against the strips between flight lines)"),
                   chunk: Optional[str] = None):
     """Multispectral captures: add (one file per band, side by side), the calibration panel, the
     reflectance orthomosaic (a band per band), an index raster, the zoning polygons."""
@@ -1731,10 +1748,11 @@ def multispectral(project: Path, what: str = typer.Argument(..., help="add, pane
     if what == "add":
         if source is None:
             raise typer.BadParameter("add needs the folder of the captures")
-        cams = ms.add_captures(ch, [source], reference=reference)
+        cams = ms.add_captures(ch, [source], reference=reference, recursive=True, thermal=thermal)
         doc.save()
         info = ch.meta["multispectral"]
-        typer.echo(f"{len(cams)} captures, bands {', '.join(info['bands'])}, reference {info['reference']}")
+        typer.echo(f"{len(cams)} captures added ({info['captures']} in the chunk), bands {', '.join(info['bands'])}, "
+                   f"reference {info['reference']}")
     elif what == "bands":
         info = ch.meta.get("multispectral") or {}
         typer.echo(json.dumps({k: v for k, v in info.items() if k != "registration"}, indent=1))
@@ -1750,9 +1768,11 @@ def multispectral(project: Path, what: str = typer.Argument(..., help="add, pane
         doc.save()
         typer.echo("panel factors: " + ", ".join(f"{b} {f:.4g}" for b, f in factors.items()))
     elif what == "reflectance":
-        path = ms.build_reflectance(ch, resolution=resolution, progress=print_progress)
+        path = ms.build_reflectance(ch, resolution=resolution, balance=balance, progress=print_progress)
         doc.save()
-        typer.echo(f"reflectance orthomosaic: {path}")
+        spread = (ch.meta["multispectral"].get("balance") or {}).get("spread") or {}
+        typer.echo(f"reflectance orthomosaic: {path}" + (" (photos balanced: " + ", ".join(
+            f"{b} {v * 100:.1f} %" for b, v in spread.items()) + ")" if spread else ""))
     elif what == "index":
         if formula is None and index not in ms.INDICES:
             raise typer.BadParameter(f"{index}: one of {', '.join(ms.INDICES)} or --formula")
@@ -1768,6 +1788,84 @@ def multispectral(project: Path, what: str = typer.Argument(..., help="add, pane
         raise typer.BadParameter("what: add, bands, panel, reflectance, index or zoning")
 
 
+@app.command("thermal-sdk")
+def thermal_sdk(install: bool = typer.Option(False, help="download DJI's Thermal SDK from DJI into the program's data"),
+                accept_license: bool = typer.Option(False, "--accept-license",
+                                                    help="you accept DJI's terms: the MIT licence for the samples and "
+                                                         "utilities such as dji_irp, DJI's SDK EULA for the rest"),
+                folder: Optional[Path] = typer.Option(None, help="install: another folder (default: <app data>/dji_tsdk)")):
+    """DJI's Thermal SDK, which reads the temperatures of DJI's R-JPEGs: how the frames would be decoded
+    here, or (``--install --accept-license``) the SDK downloaded from DJI. It is not shipped with the
+    program; on macOS it runs in Docker Desktop."""
+    from .engine import thermal as th
+
+    if install:
+        if not accept_license:
+            typer.echo(f"DJI's Thermal SDK is DJI's: its samples and utilities (dji_irp) are under the MIT licence, the "
+                       f"rest under DJI's SDK EULA ({th.SDK_EULA_URL}). Run again with --accept-license to download it "
+                       f"from DJI ({th.SDK_URL}, about 74 MB).")
+            raise typer.Exit(1)
+        path = th.install_sdk(progress=print_progress, folder=folder)
+        typer.echo(f"DJI's Thermal SDK in {path}")
+    typer.echo(json.dumps(th.decoder_status(), indent=1))
+
+
+@app.command()
+def thermal(project: Path, what: str = typer.Argument(..., help="status, params, build, anomalies or export"),
+            target: Optional[Path] = typer.Argument(None, help="export: the file to write (.tif, .csv, .jpg)"),
+            emissivity: Optional[float] = typer.Option(None, help="params: emissivity (factory 0.95)"),
+            reflected: Optional[float] = typer.Option(None, help="params: reflected temperature, degrees (factory 22)"),
+            ambient: Optional[float] = typer.Option(None, help="params: ambient temperature, degrees (factory 22)"),
+            humidity: Optional[float] = typer.Option(None, help="params: relative humidity, percent (70)"),
+            distance: Optional[float] = typer.Option(None, help="params: distance to the ground, metres (default: the flight height, 1-25)"),
+            scale: Optional[float] = typer.Option(None, help="params: TIFFs of integers (WIRIS and others): degrees = value x scale + offset"),
+            offset: Optional[float] = typer.Option(None, help="params: the offset of that conversion, degrees (centikelvin: "
+                                                              "--scale 0.01 --offset -273.15)"),
+            resolution: Optional[float] = typer.Option(None, help="build: metres per pixel (default: a thermal pixel on the ground)"),
+            balance: bool = typer.Option(True, help="build: take away the offsets between frames"),
+            radius: float = typer.Option(2.0, help="anomalies: the radius of the surroundings, metres"),
+            fmt: Optional[str] = typer.Option(None, "--format", help="export: tif (degrees, float32), tif16 (centikelvin), "
+                                                                     "csv, or flir (FLIR radiometric JPEGs in tiles with world files)"),
+            tile: int = typer.Option(2048, help="export flir: the side of the tiles, cells (at most 2800)"),
+            palette: str = typer.Option("iron", help="export flir: the colours of the picture (iron, inferno, rainbow, grey)"),
+            chunk: Optional[str] = None):
+    """Thermal frames (a DJI R-JPEG camera, MicaSense LWIR, temperature TIFFs) added with
+    ``ppg multispectral PROJECT add``: the measure's parameters, the temperature orthomosaic in
+    degrees Celsius (DJI's Thermal SDK decodes the R-JPEGs; on macOS it runs in Docker), its
+    anomalies, the exports that keep degrees."""
+    from .engine import thermal as th
+
+    doc, ch = _open(project, chunk)
+    if what == "status":
+        st = th.decoder_status()
+        typer.echo(json.dumps({"decoder": st, "params": th.params_of(ch),
+                               "thermal": {k: v for k, v in (ch.meta.get("thermal") or {}).items() if k != "registration"}},
+                              indent=1, default=str))
+    elif what == "params":
+        given = {k: v for k, v in (("emissivity", emissivity), ("reflected", reflected), ("ambient", ambient),
+                                    ("humidity", humidity), ("distance", distance), ("scale", scale), ("offset", offset))
+                 if v is not None}
+        typer.echo(json.dumps(th.set_params(ch, **given), indent=1))
+        doc.save()
+    elif what == "build":
+        path = th.build_thermal(ch, resolution=resolution, balance=balance, progress=print_progress)
+        doc.save()
+        info = ch.meta["thermal"]
+        typer.echo(f"temperature orthomosaic: {path} ({info['resolution'] * 100:.1f} cm/px"
+                   + (f", {info['stats']['p2']:.1f} - {info['stats']['p98']:.1f} degrees" if info.get("stats") else "")
+                   + (f", offsets between frames {info['offsets']['spread']:.2f} degrees" if info.get("offsets") else "") + ")")
+    elif what == "anomalies":
+        path = th.anomalies(ch, radius_m=radius)
+        doc.save()
+        typer.echo(f"thermal anomalies: {path}")
+    elif what == "export":
+        if target is None:
+            raise typer.BadParameter("export needs the file to write")
+        typer.echo(str(th.export(ch, target, fmt, tile=tile, palette=palette)))
+    else:
+        raise typer.BadParameter("what: status, params, build, anomalies or export")
+
+
 @app.command()
 def satellite(project: Path, what: str = typer.Argument(..., help="info, ortho or dsm"),
               scene: Path = typer.Argument(..., help="the scene (GeoTIFF with its RPC, or a sidecar beside it)"),

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.0}/src/pyarchinit_photogrammetry/core/chunk.py

@@ -242,7 +242,7 @@ class Chunk:
                      pair_selection: str = "auto", progress: ProgressCallback | None = None,
                      exclude_stationary: bool = False, generic: bool | None = None, reference: str | None = None,
                      neighbours: int = 20, apply_masks: str = "keypoints", guided_matching: bool = False,
-                     reset: bool = True, gpu: str | None = None) -> None:
+                     reset: bool = True, gpu: str | None = None, matcher: str = "sift") -> None:
         """Detect and match features (SIFT) between photos, with the choices of Metashape's
         *Align Photos* (see :func:`engine.sfm.match_photos`): ``quality`` (the accuracy), the
         ``generic`` preselection (None: from 40 photos up), the ``reference`` preselection
@@ -254,17 +254,20 @@ class Chunk:
         there are and only matches the photos added since. The older ``pair_selection`` word
         stands in when ``generic`` and ``reference`` are not given. ``gpu``: ``auto`` (the best
         GPU shares the pairs with the CPU), ``off``, an adapter index or part of its name
-        (None: the ``PPG_GPU`` environment variable, ``auto`` by default)."""
+        (None: the ``PPG_GPU`` environment variable, ``auto`` by default). ``matcher``: ``sift``,
+        or learned key points matched by LightGlue, ``disk`` or ``aliked`` (:mod:`engine.learned`:
+        more matches on thermal frames and on surfaces with little texture)."""
         from ..engine import sfm
 
         sfm.match_photos(self, quality=quality, keypoint_limit=keypoint_limit, tiepoint_limit=tiepoint_limit,
                          pair_selection=pair_selection, progress=as_progress(progress),
                          exclude_stationary=exclude_stationary, generic=generic, reference=reference,
                          neighbours=neighbours, apply_masks=apply_masks, guided_matching=guided_matching,
-                         reset=reset, gpu=gpu)
+                         reset=reset, gpu=gpu, matcher=matcher)
 
     def align_cameras(self, progress: ProgressCallback | None = None, mapper: str = "auto", reset: bool = True,
-                      use_gps: bool | None = None, adaptive_fitting: bool = False) -> int:
+                      use_gps: bool | None = None, adaptive_fitting: bool = False, tiepoint_limit: int | None = None,
+                      ba_global_ratio: float | None = None, ba_global_refinements: int | None = None) -> int:
         """Estimate camera poses and sparse tie points. Returns the number of aligned photos.
         ``mapper``: ``incremental``, ``global`` or ``auto``; ``use_gps`` (None: when the photos
         have them): the GPS positions of the photos hold the block during the incremental
@@ -279,7 +282,8 @@ class Chunk:
         from ..engine import sfm
 
         n = sfm.align_cameras(self, progress=as_progress(progress), mapper=mapper, reset=reset, use_gps=use_gps,
-                              adaptive_fitting=adaptive_fitting)
+                              adaptive_fitting=adaptive_fitting, tiepoint_limit=tiepoint_limit,
+                              ba_global_ratio=ba_global_ratio, ba_global_refinements=ba_global_refinements)
         self.transform = geometry.identity()
         self.meta.pop("levelled", None)
         self.forget_precision()
@@ -540,10 +544,11 @@ class Chunk:
         dense.build_depth_maps(self, quality=quality, filter_mode=filter_mode, backend=backend,
                                progress=as_progress(progress), skip_unreadable=skip_unreadable, gpu=gpu)
 
-    def build_point_cloud(self, point_colors: bool = True, progress: ProgressCallback | None = None) -> PointCloud:
+    def build_point_cloud(self, point_colors: bool = True, progress: ProgressCallback | None = None,
+                          gpu: str | None = None) -> PointCloud:
         from ..engine import dense
 
-        return dense.build_point_cloud(self, point_colors=point_colors, progress=as_progress(progress))
+        return dense.build_point_cloud(self, point_colors=point_colors, progress=as_progress(progress), gpu=gpu)
 
     def crop_point_cloud(self, zmin: float | None = None, zmax: float | None = None, radius: float | None = None,
                          center=(0.0, 0.0), bounds=None, region=None) -> "PointCloud":