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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-photogrammetry
-Version: 1.2.2
+Version: 1.3.1
 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
@@ -26,9 +26,12 @@ Requires-Dist: shapely>=2.0
 Requires-Dist: trimesh>=4.0
 Requires-Dist: contourpy>=1.1
 Requires-Dist: ezdxf>=1.1
+Requires-Dist: matplotlib>=3.7
 Requires-Dist: laspy[lazrs]>=2.4
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: typer>=0.9
+Requires-Dist: fpdf2>=2.8
+Requires-Dist: openpyxl>=3.1
 Provides-Extra: mesh
 Requires-Dist: open3d!=0.20.0,>=0.18; extra == "mesh"
 Provides-Extra: bim
@@ -40,10 +43,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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-photogrammetry"
-version = "1.2.2"
+version = "1.3.1"
 description = "Open-source photogrammetry engine for archaeology and BIM, integrated with PyArchInit"
 readme = "README.md"
 license = "GPL-2.0-or-later"
@@ -31,9 +31,12 @@ dependencies = [
     "trimesh>=4.0",
     "contourpy>=1.1",
     "ezdxf>=1.1",
+    "matplotlib>=3.7",  # drawings (pottery, plugins' sections and logs); came only through pyvista before
     "laspy[lazrs]>=2.4",
     "sqlalchemy>=2.0",
     "typer>=0.9",
+    "fpdf2>=2.8",  # the processing report as PDF (io.pdf_report)
+    "openpyxl>=3.1",  # the tables as Excel workbooks (io.tables)
 ]
 
 [project.optional-dependencies]
@@ -42,8 +45,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.1}/src/ppg_launcher.py

@@ -263,6 +263,41 @@ def _persistent_matplotlib_cache() -> None:
 _crash_file = None  # kept open while the application runs
 
 
+def _log_folder() -> str:
+    """The log folder of the interface (as ``gui.logging_setup``; ``PPG_LOG_DIR`` overrides it)."""
+    folder = os.environ.get("PPG_LOG_DIR")
+    if folder:
+        return folder
+    if sys.platform == "darwin":
+        return os.path.expanduser("~/Library/Logs/pyarchinit-photogrammetry")
+    if os.name == "nt":
+        return os.path.join(os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/AppData/Local"),
+                            "pyarchinit-photogrammetry", "logs")
+    return os.path.join(os.environ.get("XDG_STATE_HOME") or os.path.expanduser("~/.local/state"),
+                        "pyarchinit-photogrammetry", "logs")
+
+
+_hang_file = None
+
+
+def check_watchdog() -> bool:
+    """The smoke test of a build (``--check``) that stalls says where: after ``PPG_CHECK_TIMEOUT``
+    seconds (420 by default, less than the build script waits) the traceback of every thread goes
+    to ``check-hang.txt`` in the log folder and the process ends. True when it is armed."""
+    global _hang_file
+    import faulthandler
+
+    try:
+        seconds = float(os.environ.get("PPG_CHECK_TIMEOUT", "420"))
+        folder = _log_folder()
+        os.makedirs(folder, exist_ok=True)
+        _hang_file = open(os.path.join(folder, "check-hang.txt"), "w", encoding="utf-8")
+        faulthandler.dump_traceback_later(seconds, exit=True, file=_hang_file)
+        return True
+    except (OSError, ValueError):
+        return False
+
+
 def crash_log() -> bool:
     """Native crashes (segfault, abort) written to ``crash.log`` in the log folder of the
     interface (as ``gui.logging_setup``, ``PPG_LOG_DIR`` overrides it) from the very start,
@@ -274,16 +309,7 @@ def crash_log() -> bool:
 
     if faulthandler.is_enabled():
         return True
-    folder = os.environ.get("PPG_LOG_DIR")
-    if not folder:
-        if sys.platform == "darwin":
-            folder = os.path.expanduser("~/Library/Logs/pyarchinit-photogrammetry")
-        elif os.name == "nt":
-            folder = os.path.join(os.environ.get("LOCALAPPDATA") or os.path.expanduser("~/AppData/Local"),
-                                  "pyarchinit-photogrammetry", "logs")
-        else:
-            folder = os.path.join(os.environ.get("XDG_STATE_HOME") or os.path.expanduser("~/.local/state"),
-                                  "pyarchinit-photogrammetry", "logs")
+    folder = _log_folder()
     try:
         os.makedirs(folder, exist_ok=True)
         _crash_file = open(os.path.join(folder, "crash.log"), "a", encoding="utf-8")
@@ -306,6 +332,8 @@ def main(argv: list[str] | None = None) -> int:
 
         return gui_main(argv)
     crash_log()
+    if "--check" in argv:
+        check_watchdog()
     os.environ.setdefault("QT_API", "pyside6")  # qtpy (pyvistaqt) must not pick another binding
     os.environ.setdefault("GLOG_minloglevel", "2")
     try:

{pyarchinit_photogrammetry-1.2.2 → pyarchinit_photogrammetry-1.3.1}/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.1"
 
 __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.1}/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.1}/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.1/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.1/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.1}/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")