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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyarchinit-photogrammetry
-Version: 1.3.0
+Version: 1.3.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
@@ -26,9 +26,13 @@ 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
+Requires-Dist: threadpoolctl>=3.1
 Provides-Extra: mesh
 Requires-Dist: open3d!=0.20.0,>=0.18; extra == "mesh"
 Provides-Extra: bim

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyarchinit-photogrammetry"
-version = "1.3.0"
+version = "1.3.2"
 description = "Open-source photogrammetry engine for archaeology and BIM, integrated with PyArchInit"
 readme = "README.md"
 license = "GPL-2.0-or-later"
@@ -31,9 +31,13 @@ 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)
+    "threadpoolctl>=3.1",  # BLAS on one thread where results must not depend on the threads (engine.ortho)
 ]
 
 [project.optional-dependencies]

{pyarchinit_photogrammetry-1.3.0 → pyarchinit_photogrammetry-1.3.2}/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.3.0 → pyarchinit_photogrammetry-1.3.2}/src/pyarchinit_photogrammetry/__init__.py

@@ -35,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.3.0"
+__version__ = "1.3.2"
 
 __all__ = ["app", "Document", "Chunk", "Camera", "Sensor", "Marker", "Projection", "Reference", "ScaleBar",
            "PointCloud", "ASPRS_CLASSES", "ARCHAEO_CLASSES", "Progress", "Cancelled", "print_progress", "__version__"]

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

@@ -92,6 +92,106 @@ def import_scans_cmd(project: Path, files: list[Path], label: Optional[str] = No
     typer.echo(f"{ch.label}: {len(ch.point_cloud)} points from {len(ch.meta['scans'])} scans")
 
 
+@app.command("import-model")
+def import_model_cmd(project: Path, file: Path,
+                     chunk: Optional[str] = typer.Option(None, help="chunk to import into (default: the active one)"),
+                     new_chunk: Optional[str] = typer.Option(None, "--new-chunk", help="put the model in a new chunk "
+                                                             "with this name"),
+                     internal: bool = typer.Option(False, help="the file is in the internal frame of the chunk "
+                                                   "(its model.ply edited elsewhere)"),
+                     up: str = typer.Option("auto", help="vertical axis of the file: auto (Y for glTF), z or y"),
+                     scale: float = typer.Option(1.0, help="multiplies the coordinates of the file (0.001 for mm)"),
+                     offset: Optional[str] = typer.Option(None, help="X,Y,Z added after the scale (default: the "
+                                                          "origin of a GLB of this program, else 0)"),
+                     crs: Optional[str] = typer.Option(None, help="CRS of a new or empty chunk (e.g. EPSG:32633)"),
+                     overwrite: bool = typer.Option(False, help="replace the current model instead of keeping it "
+                                                    "as a version"),
+                     name: Optional[str] = typer.Option(None, help="name of the new version of the model")):
+    """A mesh of another program (OBJ, PLY, GLB/glTF, STL, ...) as the model of a chunk, with its
+    colours and texture; the current model is kept as a version."""
+    from .io.mesh_import import import_model, import_model_chunk
+
+    xyz = None
+    if offset:
+        xyz = [float(v) for v in offset.replace(";", ",").split(",")]
+        if len(xyz) != 3:
+            raise typer.BadParameter("offset: X,Y,Z")
+    kw = {"frame": "internal" if internal else "world", "up": up, "scale": scale, "offset": xyz}
+    if new_chunk is not None:
+        doc = Document.open(project)
+        ch, r = import_model_chunk(doc, file, label=new_chunk or None, crs=crs, progress=print_progress, **kw)
+    else:
+        doc, ch = _open(project, chunk)
+        r = import_model(ch, file, crs=crs, keep=not overwrite, name=name, progress=print_progress, **kw)
+    doc.save()
+    typer.echo(f"{ch.label}: {r['faces']} faces, {r['vertices']} vertices, {r['pages']} texture pages"
+               + (f", previous model kept as version {r['kept']}" if r["kept"] else ""))
+    if r["missing_textures"]:
+        typer.echo(f"textures not found: {', '.join(r['missing_textures'])}")
+    if r["distance"]:
+        typer.echo(f"warning: the model lies {r['distance']:.1f} m from the data of the chunk "
+                   "(check the coordinate system, --offset, --scale and --up)")
+
+
+@app.command("cut-model")
+def cut_model_cmd(project: Path,
+                  horizontal: Optional[float] = typer.Option(None, help="horizontal plane at this height"),
+                  vertical: Optional[str] = typer.Option(None, help="vertical plane through the line X1,Y1,X2,Y2 "
+                                                         "(above = to the left of the walker from 1 to 2)"),
+                  points: Optional[str] = typer.Option(None, help="plane through three points X1,Y1,Z1,X2,Y2,Z2,"
+                                                       "X3,Y3,Z3"),
+                  plane: Optional[str] = typer.Option(None, help="a point and the normal X,Y,Z,NX,NY,NZ"),
+                  dip: Optional[str] = typer.Option(None, help="X,Y,Z,DIP_DIRECTION,DIP (degrees, from north)"),
+                  keep: str = typer.Option("above", help="above, below, slab, both or series"),
+                  thickness: Optional[float] = typer.Option(None, help="metres: the slab, or each slice of a series"),
+                  step: Optional[float] = typer.Option(None, help="metres between the slices of a series"),
+                  count: Optional[int] = typer.Option(None, help="slices of a series (default: across the model)"),
+                  out: Optional[Path] = typer.Option(None, help="file (.ply/.obj) for a part, the stem of the two "
+                                                     "parts, the folder of a series; without it the part kept "
+                                                     "becomes the model"),
+                  overwrite: bool = typer.Option(False, help="do not keep the current model as a version"),
+                  name: Optional[str] = typer.Option(None, help="name of the new version of the model"),
+                  cap: bool = typer.Option(True, help="close the solids cut on the plane (each in its colour)"),
+                  chunk: Optional[str] = None):
+    """Cut the model with a plane: keep one side, a slice, both sides as files or a series of slices."""
+    import numpy as np
+
+    from .engine import mesh_cut
+
+    def numbers(text, n, what):
+        values = [float(v) for v in text.replace(";", ",").split(",")]
+        if len(values) != n:
+            raise typer.BadParameter(f"{what}: {n} numbers separated by commas")
+        return values
+
+    given = [v is not None for v in (horizontal, vertical, points, plane, dip)]
+    if sum(given) != 1:
+        raise typer.BadParameter("give one plane: --horizontal, --vertical, --points, --plane or --dip")
+    if horizontal is not None:
+        p, n = mesh_cut.horizontal(horizontal)
+    elif vertical is not None:
+        v = numbers(vertical, 4, "--vertical")
+        p, n = mesh_cut.vertical(v[:2], v[2:])
+    elif points is not None:
+        v = numbers(points, 9, "--points")
+        p, n = mesh_cut.through_points(v[:3], v[3:6], v[6:])
+    elif plane is not None:
+        v = numbers(plane, 6, "--plane")
+        p, n = np.asarray(v[:3]), np.asarray(v[3:]) / np.linalg.norm(v[3:])
+    else:
+        v = numbers(dip, 5, "--dip")
+        p, n = mesh_cut.dipping(v[:3], v[3], v[4])
+    doc, ch = _open(project, chunk)
+    r = ch.cut_model(p, n, keep=keep, thickness=thickness, step=step, count=count, out=out,
+                     as_version=not overwrite, name=name, cap=cap, progress=print_progress)
+    if not r["files"]:
+        doc.save()
+        typer.echo(f"{ch.label}: model cut, {r['faces']} -> {r['faces_kept']} faces"
+                   + (f", previous model kept as version {r['kept']}" if r["kept"] else ""))
+    for f in r["files"]:
+        typer.echo(f)
+
+
 @app.command("colour-scan")
 def colour_scan(project: Path, scan: str = typer.Option(..., help="label of the chunk to colour"),
                 photos: str = typer.Option(..., help="label of the chunk with the aligned photos")):
@@ -861,6 +961,62 @@ def export(project: Path, ortho: Optional[Path] = None, dem: Optional[Path] = No
         typer.echo(str(ch.export_cameras(cameras, fmt="csv" if cameras.suffix == ".csv" else "colmap")))
 
 
+def _language(lang: Optional[str]) -> Optional[str]:
+    if lang and lang.strip().lower()[:2] not in ("it", "en"):
+        raise typer.BadParameter(f"--lang: it or en, not {lang!r}")
+    return lang.strip().lower()[:2] if lang else None
+
+
+@app.command()
+def report(project: Path,
+           pdf: Optional[Path] = typer.Option(None, help="the PDF to write (default: <project>_report.pdf beside the "
+                                                         "project when --html is not given)"),
+           html: Optional[Path] = typer.Option(None, help="also, or only, the report as an HTML page"),
+           lang: Optional[str] = typer.Option(None, help="it or en (default: the language of the interface or of the "
+                                                         "system)"),
+           chunk: Optional[str] = typer.Option(None, help="only this chunk (label or key); default: every enabled chunk"),
+           title: Optional[str] = typer.Option(None, help="title on the first page"),
+           description: str = typer.Option("", help="text on the first page")):
+    """The processing report: survey, calibration, accuracy of the references, processing parameters,
+    products with their figures, multispectral and thermal products, measuring points."""
+    from .io.pdf_report import generate_pdf_report
+    from .io.report import generate_report
+
+    language = _language(lang)
+    doc = Document.open(project)
+    if not doc.chunks:
+        raise typer.BadParameter("the project has no chunks")
+    chunks = None
+    if chunk is not None:
+        found = next((c for c in doc.chunks if c.label == chunk or str(c.key) == chunk), None)
+        if found is None:
+            raise typer.BadParameter(f"no chunk {chunk!r} in the project")
+        chunks = [found]
+    if pdf is None and html is None:
+        pdf = project.with_name(project.stem + "_report.pdf")
+    if pdf is not None:
+        typer.echo(str(generate_pdf_report(doc, pdf, language=language, chunks=chunks, title=title,
+                                           description=description, progress=print_progress)))
+    if html is not None:
+        target = chunks[0] if chunks else doc
+        typer.echo(str(generate_report(target, html, language=language)))
+
+
+@app.command()
+def tables(project: Path, out: Path = typer.Argument(..., help="the Excel workbook to write (.xlsx)"),
+           chunk: Optional[str] = typer.Option(None, help="label or key of the chunk (default: the active one)"),
+           lang: Optional[str] = typer.Option(None, help="language of the headers: it or en (default: of the "
+                                                         "interface or of the system)")):
+    """Every table of a chunk in one Excel workbook, a sheet each: cameras, sensors, markers, scale bars,
+    products, point classes, versions, parameters, multispectral bands, indices and zones, thermal measure,
+    measuring points, spot heights, units, stones, proxies, sections."""
+    from .io.tables import export_tables
+
+    language = _language(lang)
+    _, ch = _open(project, chunk)
+    typer.echo(str(export_tables(ch, out, language=language, progress=print_progress)))
+
+
 def _numbers(text: Optional[str], count: int, what: str) -> Optional[tuple]:
     """``"16,2.0"`` -> ``(16.0, 2.0)`` (None when not given)."""
     if not text:

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

@@ -821,6 +821,31 @@ class Chunk:
                               crs_wkt=crs_mod.wkt(self.crs))
         return pc.transformed(self.transform).save(path, crs_wkt=crs_mod.wkt(self.crs))
 
+    def import_model(self, path: str | os.PathLike, frame: str = "world", offset=None, scale: float = 1.0,
+                     up: str = "auto", crs: str | None = None, keep: bool = True, name: str | None = None,
+                     progress: ProgressCallback | None = None) -> dict:
+        """A mesh of another program (OBJ, PLY, GLB/glTF, STL, ...) as the model of the chunk, with
+        its colours and texture; the current model kept as a version (``keep``). See
+        :func:`io.mesh_import.import_model` for the coordinates (``frame``, ``offset``, ``scale``,
+        ``up``, ``crs``)."""
+        from ..io.mesh_import import import_model
+
+        return import_model(self, path, frame=frame, offset=offset, scale=scale, up=up, crs=crs, keep=keep,
+                            name=name, progress=as_progress(progress))
+
+    def cut_model(self, point, normal, keep: str = "above", thickness: float | None = None,
+                  step: float | None = None, count: int | None = None, out: str | os.PathLike | None = None,
+                  as_version: bool = True, name: str | None = None, cap: bool = True,
+                  progress: ProgressCallback | None = None) -> dict:
+        """Cut the model with the plane through ``point`` with ``normal`` (world coordinates): one side
+        (``keep`` "above"/"below"), a slice of ``thickness`` ("slab") as the new model or to the file
+        ``out``; both sides ("both") or slices every ``step`` ("series") to files; ``cap``: closed
+        solids closed on the plane. See :func:`engine.mesh_cut.cut_model`."""
+        from ..engine.mesh_cut import cut_model
+
+        return cut_model(self, point, normal, keep=keep, thickness=thickness, step=step, count=count, out=out,
+                         as_version=as_version, name=name, cap=cap, progress=as_progress(progress))
+
     def export_model(self, path: str | os.PathLike, region=None, zmin: float | None = None,
                      zmax: float | None = None) -> Path:
         """The model in world coordinates (OBJ with the texture when built, PLY with colours and
@@ -905,10 +930,27 @@ class Chunk:
             cut = crop_raster(src, Path(tmp) / "cut.tif", region)
             return export_cog(cut, path, compression, quality)
 
-    def generate_report(self, path: str | os.PathLike) -> Path:
+    def generate_report(self, path: str | os.PathLike, language: str | None = "en") -> Path:
+        """The processing report as an HTML page (``language``: ``en``, ``it``, None for the
+        language of the interface or of the system)."""
         from ..io import report
 
-        return report.generate_report(self, path)
+        return report.generate_report(self, path, language=language)
+
+    def generate_pdf_report(self, path: str | os.PathLike, language: str | None = None,
+                            progress: ProgressCallback | None = None, **options) -> Path:
+        """The processing report of this chunk as a printable PDF (:func:`io.pdf_report.generate_pdf_report`:
+        ``title``, ``description``, ``index_palette``, ``thermal_palette``)."""
+        from ..io.pdf_report import generate_pdf_report
+
+        return generate_pdf_report(self, path, language=language, progress=progress, **options)
+
+    def export_tables(self, path: str | os.PathLike, language: str | None = None,
+                      progress: ProgressCallback | None = None) -> Path:
+        """Every table of the chunk in one Excel workbook, a sheet each (:func:`io.tables.project_tables`)."""
+        from ..io.tables import export_tables
+
+        return export_tables(self, path, language=language, progress=progress)
 
     # ----------------------------------------------------------- serialisation
     def _base_dir(self) -> Path | None:

{pyarchinit_photogrammetry-1.3.0 → pyarchinit_photogrammetry-1.3.2}/src/pyarchinit_photogrammetry/core/versions.py

@@ -67,7 +67,8 @@ def _describe(chunk, product: str) -> str:
             bits.append(f"qualita' {meta['quality']}")
     elif product == "model" and meta.get("source"):
         bits.append({"depth_maps": "mappe di profondita'", "point_cloud": "nuvola densa",
-                     "tie_points": "punti di legame"}.get(meta["source"], meta["source"]))
+                     "tie_points": "punti di legame", "import": f"importato da {meta.get('file', 'un file')}"}
+                    .get(meta["source"], meta["source"]))
     if meta.get("classes"):
         bits.append("classi " + ", ".join(str(c) for c in meta["classes"]))
     if product == "orthomosaic" and meta.get("hidden_classes"):