asp-plot 1.17.0__tar.gz → 1.18.0__tar.gz

{asp_plot-1.17.0 → asp_plot-1.18.0}/AGENTS.md

@@ -4,7 +4,7 @@ This file provides guidance to AI coding agents (Claude Code and others) when wo
 
 ## Project Overview
 
-`asp_plot` (current version: 1.17.0) is a Python package for visualizing output from the NASA Ames Stereo Pipeline (ASP). It processes stereo satellite imagery results (both terrestrial and planetary), generates diagnostic plots, and creates comprehensive PDF reports similar to those from commercial SfM software like Agisoft Metashape. Requires Python >= 3.11. Published on PyPI and conda-forge.
+`asp_plot` (current version: 1.18.0) is a Python package for visualizing output from the NASA Ames Stereo Pipeline (ASP). It processes stereo satellite imagery results (both terrestrial and planetary), generates diagnostic plots, and creates comprehensive PDF reports similar to those from commercial SfM software like Agisoft Metashape. Requires Python >= 3.11. Published on PyPI and conda-forge.
 
 The package supports:
 - Stereo DEM processing visualization
@@ -129,7 +129,7 @@ The package is organized by functionality, with each module focused on a specifi
 - `ReportMetadata`: Dataclass for DEM metadata displayed on the title page (dimensions, GSD, CRS, nodata %, elevation range, DEM filename, reference DEM, acquisition dates). The "Acquisition Date(s)" row is added to the summary table only when `acquisition_dates` is non-empty.
 - `ASPReportPDF`: FPDF subclass with custom header/footer and page numbers
 - `compile_report()`: Assembles title page, Processing Parameters (page 2), figure sections with captions, and any trailing alignment pages into a PDF. Accepts optional `report_command` string to record the CLI invocation. Figures are automatically scaled to fit page dimensions, preventing overflow/cutoff. `sections` is a mixed list of `ReportSection | AlignmentReportPage`; dispatch is by `isinstance` check.
-- `_add_processing_parameters_page()`: helper that renders the runtime summary table plus the bundle_adjust / stereo / point2dem / report commands on page 2 (moved from the trailing page as of v1.13.0).
+- `_add_processing_parameters_page()`: helper that renders the runtime summary table plus the bundle_adjust / stereo / point2dem / report commands on page 2 (moved from the trailing page as of v1.13.0). Also renders the reconstructed `mapproject` command(s) (from the optional `mapproject` list key; see `mapproject.py`) with a "reconstructed from output metadata" note.
 - `_fmt_sig()`: formats a number compactly — 2 decimals for |x| < 10, 1 decimal for 10 ≤ |x| < 100, 0 decimals above, "n/a" for non-finite. Used for alignment stats.
 - Title page displays: processing date, ASP version (from logs), asp_plot version (from package metadata)
 - Page order: title + DEM summary → Processing Parameters → diagnostic figures → (if `--pc_align` ran) alignment report page + aligned-DEM figures.
@@ -151,9 +151,14 @@ The package is organized by functionality, with each module focused on a specifi
 
 **`processing_parameters.py`** - `ProcessingParameters` class
 - Delegates all ASP-log parsing to `asp_log.AspLog` (no more inline string surgery; the bare `except:` clauses became directory guards)
-- Extracts command lines, run times, and processing parameters; `from_log_files()` returns a dict including the `asp_version` key
+- Extracts command lines, run times, and processing parameters; `from_log_files()` returns a dict including the `asp_version` key and a `mapproject` key (list of reconstructed mapproject commands; see `mapproject.py`)
 - Used by report generation to document processing settings
 
+**`mapproject.py`** - Reconstruct `mapproject` commands from output GeoTIFF metadata (issue #96)
+- ASP's `mapproject` writes **no log file** (unlike `bundle_adjust`/`stereo`/`point2dem`), so `asp_log.py` has nothing to parse for the mapprojection step. Instead of requiring a new ASP `--log` flag, the command is reconstructed **from the output data alone**: ASP stamps `INPUT_IMAGE_FILE` / `CAMERA_FILE` / `DEM_FILE` / `CAMERA_MODEL_TYPE` / `BUNDLE_ADJUST_PREFIX` into each mapprojected GeoTIFF header, and the raster's own CRS / resolution / bounds give `--t_srs` / `--tr` / `--t_projwin`
+- `reconstruct_mapproject_command(raster_path)`: returns the `mapproject ...` string, or `None` if the ASP mapproject tag signature (`REQUIRED_TAGS` = `INPUT_IMAGE_FILE` + `CAMERA_FILE` + `DEM_FILE`, all read back during reconstruction) is absent. Reuses the `utils.Raster` wrapper (free `NotGeoreferencedWarning` suppression + `get_epsg_code()` with the compound-CRS 2D fallback + `get_gsd()`/bounds) rather than re-opening with raw rasterio. `--t_srs` is `EPSG:XXXX` when an EPSG code exists (incl. the 2D fallback), else the quoted PROJ string (custom planetary/local frames, e.g. jitter stereographic); a malformed CRS returns `None` and logs instead of crashing the report. `_format_coord` renders coordinates to 12 significant figures, positionally — clean for large UTM northings *and* full-precision for degree-scale geographic `--tr`, with no scientific notation or float-repr noise. The reconstruction is faithful but **not byte-for-byte re-runnable** (session is the resolved `-t`, an input `--mpp` shows as the resolved `--tr`, output reads the actual filename) — the report flags this with a one-line note
+- `find_mapproject_commands(directories, stereo_command=None)`: scans dirs (processing root, BA dir, stereo dir) for all `*.tif`/`*.tiff` and keeps those carrying the tag signature — **identity is decided by the file's own metadata, never by filename**, so there is no naming-convention dependency (reading a GeoTIFF header is cheap; the `NotGeoreferencedWarning` from raw non-georef inputs is silenced). Dedupes by the reconstructed command string (identical scene reached via two dirs collapses; distinct left/right both show). When `stereo_command` is given, a discovered output is kept only if its filename appears in that command — this scopes the result to the run being reported, so a non-mapprojected run sharing a parent dir with mapprojected scenes (the `stereo/` + `stereo_no_mapproj/` layout) does **not** spuriously list a mapproject step. It's a whole-token basename membership test (the output basename must equal one of the stereo command's argument basenames — not a raw substring, so `run.tif` can't match `prun.tif`), not positional parsing. `ProcessingParameters.get_mapproject_commands(stereo_command)` passes the parsed stereo command; `report.py` renders the results under "Mapproject Command(s)" on the Processing Parameters page (via the module-level `_render_command_block` helper, shared with the bundle_adjust/stereo/point2dem commands)
+
 **`sensors.py`** - Sensor-specific scene metadata readers (issue #25)
 - `SensorMetadata` ABC defining the reader interface (`detect` + `get_scene_dicts`) and the sensor-agnostic scene-dict schema, mirroring the `bodies.py` registry pattern so adding ASTER/HiRISE/etc. is a new subclass with no change to the geometry code
 - `WorldViewMetadata(SensorMetadata)`: the WorldView/Maxar XML logic (file discovery, `dg_mosaic` tiling, per-scene extraction, ephemeris/attitude/footprint) moved verbatim out of the parser. Named after the satellite family rather than the (twice-renamed: DigitalGlobe → Maxar → Vantor) company; the same format also covers GeoEye-1/QuickBird/IKONOS

{asp_plot-1.17.0 → asp_plot-1.18.0}/CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.18.0] - 2026-06-25
+
+### Added
+- **Reconstruct `mapproject` commands in the PDF report** ([#96](https://github.com/uw-cryo/asp_plot/issues/96)). ASP's `mapproject` does not write a log file the way `bundle_adjust` / `stereo` / `point2dem` do, so the processing-parameters page never documented the mapprojection step. Rather than depend on a new ASP `--log` flag, the new `asp_plot/mapproject.py` reconstructs the command **from the output GeoTIFF metadata alone**: ASP stamps `INPUT_IMAGE_FILE` / `CAMERA_FILE` / `DEM_FILE` / `CAMERA_MODEL_TYPE` / `BUNDLE_ADJUST_PREFIX` into each mapprojected output, and combined with the raster's CRS (`--t_srs`), resolution (`--tr`), and bounds (`--t_projwin`) that is enough to rebuild the invocation. `ProcessingParameters.from_log_files()` now adds a `mapproject` key (a list — one command per mapprojected input scene found), and the report's "Processing Parameters" page renders them under a "Mapproject Command(s)" heading with a note that the values are reconstructed (resolved session/grid). Works across ASTER, WorldView/RPC, and CSM (jitter) sessions, including custom projections without an EPSG code (falls back to the PROJ string). The command(s) are rendered in ASP pipeline order (between bundle_adjust and stereo), and scoped to the run being reported via the stereo command — a non-mapprojected run that shares a parent directory with mapprojected scenes (the `stereo/` + `stereo_no_mapproj/` layout) does not spuriously list a mapproject step.
+
 ## [1.17.0] - 2026-06-24
 
 ### Changed

{asp_plot-1.17.0 → asp_plot-1.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asp_plot
-Version: 1.17.0
+Version: 1.18.0
 Summary: Package for plotting outputs Ames Stereo Pipeline processing
 Project-URL: Homepage, https://github.com/uw-cryo/asp_plot
 Project-URL: Documentation, https://asp-plot.readthedocs.io

asp_plot-1.18.0/asp_plot/mapproject.py

@@ -0,0 +1,248 @@
+"""Reconstruct ``mapproject`` commands from ASP-mapprojected GeoTIFF metadata.
+
+ASP's ``mapproject`` tool does not write a log file the way ``bundle_adjust`` /
+``stereo`` / ``point2dem`` do, so :mod:`asp_plot.asp_log` (which parses those
+logs) has nothing to read for the mapprojection step (issue #96).
+
+Fortunately ``mapproject`` stamps everything we need into the *output* GeoTIFF
+header, so the command can be reconstructed from the output data alone -- no new
+ASP ``--log`` flag required. The fields written by ASP are:
+
+- ``INPUT_IMAGE_FILE`` -- the image that was mapprojected
+- ``CAMERA_FILE`` -- the camera model
+- ``DEM_FILE`` -- the DEM used as the projection surface
+- ``CAMERA_MODEL_TYPE`` -- the resolved ``--session-type`` / ``-t``
+- ``BUNDLE_ADJUST_PREFIX`` -- the ``--bundle-adjust-prefix`` (``"NONE"`` if unset)
+
+combined with the raster's own CRS (``--t_srs``), resolution (``--tr``), and
+bounds (``--t_projwin``).
+
+The reconstruction is faithful but *not* byte-for-byte re-runnable: the session
+type is the resolved value (not necessarily what the user typed), an input
+``--mpp`` shows up resolved as ``--tr``, and the output name is read from the
+file itself. Callers that surface this to users (e.g. the PDF report) should say
+so. See ``reconstruct_mapproject_command`` for the exact argv order.
+"""
+
+import glob
+import logging
+import os
+
+import numpy as np
+import rasterio
+
+from asp_plot.utils import Raster
+
+logger = logging.getLogger(__name__)
+
+# GeoTIFF metadata tags ASP's mapproject writes into every output. This trio is
+# the signature we require to treat a raster as a mapproject output -- and the
+# *only* thing we rely on to identify mapprojected files. We deliberately do not
+# match on filename conventions (``*_map.tif`` etc.): the tags are written by ASP
+# itself, are self-validating, and survive a rename, whereas a filename glob
+# would force an external naming convention and miss anything that deviates. All
+# three are read back during reconstruction, so requiring them here also guards
+# the ``tags[...]`` lookups below.
+REQUIRED_TAGS = ("INPUT_IMAGE_FILE", "CAMERA_FILE", "DEM_FILE")
+
+# Raster extensions scanned when discovering mapproject outputs in a directory.
+RASTER_EXTENSIONS = ("*.tif", "*.tiff")
+
+
+def _format_coord(value, sig_figs=12):
+    """Format a projwin/resolution coordinate for the CLI.
+
+    Renders to ``sig_figs`` significant figures, positionally (never scientific
+    notation), trimming trailing zeros. Significant figures -- not fixed decimal
+    places -- because the two ends of the range matter: GeoTIFF bounds can be
+    large UTM northings (~5.2e6) while a geographic-CRS ``--tr`` can be ~5e-6
+    degrees. A fixed ``%.6f`` would coarsen the latter to ~1 significant figure;
+    plain shortest-repr would surface float noise on the former
+    (``3722294.979`` computed as ``3722294.9790000003``). Twelve significant
+    figures is well clear of double-precision noise (~16 figures) yet keeps
+    clean grid values clean (``0.481`` -> ``0.481``, ``15.0`` -> ``15``).
+    """
+    if not np.isfinite(value) or value == 0:
+        return "0" if value == 0 else repr(value)
+    decimals = sig_figs - 1 - int(np.floor(np.log10(abs(value))))
+    return np.format_float_positional(round(value, decimals), trim="-")
+
+
+def reconstruct_mapproject_command(raster_path):
+    """Reconstruct the ``mapproject`` command for an ASP-mapprojected GeoTIFF.
+
+    Parameters
+    ----------
+    raster_path : str
+        Path to a GeoTIFF that may be an ASP ``mapproject`` output.
+
+    Returns
+    -------
+    str or None
+        The reconstructed ``mapproject ...`` command line, or ``None`` if the
+        file is missing the ASP mapproject metadata signature (i.e. it is not a
+        mapproject output, or was written by a tool that did not stamp the
+        header).
+
+    Notes
+    -----
+    The reconstructed argv order mirrors the ASP CLI::
+
+        mapproject [-t SESSION] [--t_srs SRS] --tr TR \\
+            --t_projwin XMIN YMIN XMAX YMAX \\
+            [--bundle-adjust-prefix PREFIX] \\
+            DEM_FILE INPUT_IMAGE CAMERA OUTPUT
+
+    ``--t_srs`` is emitted as ``EPSG:XXXX`` when the CRS has an exact EPSG code,
+    otherwise as the PROJ string (quoted), so custom planetary/local projections
+    (e.g. the stereographic frames used in jitter solving) still round-trip.
+    """
+    # Reuse the package Raster wrapper: it suppresses the NotGeoreferencedWarning
+    # that the raw (non-georef) input scenes raise during discovery, and it owns
+    # the EPSG/GSD/bounds derivation (incl. the compound-CRS EPSG fallback) that
+    # _t_srs_token relies on.
+    try:
+        raster = Raster(raster_path)
+    except rasterio.errors.RasterioIOError as e:
+        logger.warning("Could not read %s for mapproject metadata: %s", raster_path, e)
+        return None
+
+    with raster.ds:
+        tags = raster.ds.tags()
+        if not all(tags.get(k) for k in REQUIRED_TAGS):
+            return None
+
+        parts = ["mapproject"]
+
+        session = tags.get("CAMERA_MODEL_TYPE")
+        if session:
+            parts += ["-t", session]
+
+        t_srs = _t_srs_token(raster)
+        if t_srs:
+            parts += ["--t_srs", t_srs]
+
+        parts += ["--tr", _format_coord(raster.get_gsd())]
+        bounds = raster.ds.bounds
+        parts += [
+            "--t_projwin",
+            _format_coord(bounds.left),
+            _format_coord(bounds.bottom),
+            _format_coord(bounds.right),
+            _format_coord(bounds.top),
+        ]
+
+        ba_prefix = tags.get("BUNDLE_ADJUST_PREFIX")
+        if ba_prefix and ba_prefix != "NONE":
+            parts += ["--bundle-adjust-prefix", ba_prefix]
+
+        parts += [
+            tags["DEM_FILE"],
+            tags["INPUT_IMAGE_FILE"],
+            tags["CAMERA_FILE"],
+            os.path.basename(raster_path),
+        ]
+        return " ".join(parts)
+
+
+def _t_srs_token(raster):
+    """Return the ``--t_srs`` token for a :class:`~asp_plot.utils.Raster`.
+
+    Prefers a compact ``EPSG:XXXX`` via ``Raster.get_epsg_code()`` (which already
+    falls back to the horizontal 2D component for compound / 3D-promoted CRSs);
+    failing that, emits the PROJ string (quoted, since it contains spaces) so
+    custom projections without an EPSG code -- e.g. the stereographic frames used
+    in jitter solving -- still round-trip. A missing or malformed CRS returns
+    ``None`` (logged) rather than raising, so one odd raster cannot abort report
+    generation.
+    """
+    crs = raster.ds.crs
+    if crs is None:
+        return None
+    try:
+        epsg = raster.get_epsg_code()
+        if epsg:
+            return f"EPSG:{epsg}"
+        proj4 = crs.to_proj4()
+        if proj4:
+            return f'"{proj4}"'
+    except Exception as e:  # malformed/exotic CRS -- don't crash the report
+        logger.warning("Could not derive --t_srs from CRS: %s", e)
+    return None
+
+
+def find_mapproject_commands(directories, stereo_command=None):
+    """Find ASP-mapprojected outputs across ``directories`` and reconstruct them.
+
+    Scans each directory (non-recursively) for GeoTIFFs and keeps those carrying
+    the ASP mapproject metadata signature (see ``REQUIRED_TAGS``) -- identity is
+    decided entirely by the file's own metadata, not by its name, so the result
+    is robust to ASP/asp_plot filename conventions. Each kept output is
+    reconstructed into a command; results are deduplicated (the same scene can be
+    reached via more than one of the passed directories) and returned sorted for
+    stable report output.
+
+    Parameters
+    ----------
+    directories : iterable of str or None
+        Directories to scan (e.g. the processing root, stereo dir, BA dir).
+        ``None`` entries are skipped.
+    stereo_command : str, optional
+        The stereo command line for the run being reported. When given, a
+        mapprojected output is kept only if its filename appears among the
+        stereo inputs (i.e. this run actually consumed it). This scopes the
+        result to the run at hand: a non-mapprojected stereo run that shares a
+        directory with leftover mapprojected scenes (e.g. ``stereo/`` and
+        ``stereo_no_mapproj/`` under one parent) no longer picks them up. A
+        mapprojected run's ``stereo`` command lists the ``*_map.tif`` inputs; a
+        non-mapprojected run lists the raw images instead, so the gate is a
+        plain filename-membership test -- no fragile positional parsing. When
+        ``None`` (or empty), no gating is applied and every discovered output is
+        returned.
+
+    Returns
+    -------
+    list of str
+        Reconstructed ``mapproject`` command lines, sorted; empty if none found.
+    """
+    # Scope to what this stereo run actually used: a mapprojected output is an
+    # input to mapprojected stereo, so its basename matches one of the stereo
+    # command's argument basenames. Compare against the set of whole-token
+    # basenames (not a raw substring of the command) so a short output name like
+    # "run.tif" can't spuriously match "prun.tif" or a path fragment.
+    stereo_input_basenames = (
+        {os.path.basename(token) for token in stereo_command.split()}
+        if stereo_command
+        else None
+    )
+
+    seen = set()
+    commands = []
+    scanned = set()
+    for directory in directories:
+        if not directory:
+            continue
+        directory = os.path.expanduser(directory)
+        if not os.path.isdir(directory):
+            continue
+        candidates = set()
+        for ext in RASTER_EXTENSIONS:
+            candidates.update(glob.glob(os.path.join(directory, ext)))
+        for path in sorted(candidates):
+            real = os.path.realpath(path)
+            if real in scanned:
+                continue
+            scanned.add(real)
+            if (
+                stereo_input_basenames is not None
+                and os.path.basename(path) not in stereo_input_basenames
+            ):
+                continue
+            command = reconstruct_mapproject_command(path)
+            # Dedupe on the reconstructed command: distinct left/right scenes
+            # differ (different input image + output name), but the same scene
+            # copied into two scanned directories yields an identical command.
+            if command and command not in seen:
+                seen.add(command)
+                commands.append(command)
+    return sorted(commands)

{asp_plot-1.17.0 → asp_plot-1.18.0}/asp_plot/processing_parameters.py

@@ -3,6 +3,7 @@ import logging
 import os
 
 from asp_plot.asp_log import STEREO_STEP_ORDER, AspLog
+from asp_plot.mapproject import find_mapproject_commands
 from asp_plot.utils import glob_file
 
 logging.basicConfig(level=logging.WARNING)
@@ -213,10 +214,45 @@ class ProcessingParameters:
             "stereo_run_time": stereo_run_time,
             "point2dem": point2dem_params,
             "point2dem_run_time": point2dem_run_time,
+            "mapproject": self.get_mapproject_commands(stereo_params),
         }
 
         return self.processing_parameters_dict
 
+    def get_mapproject_commands(self, stereo_command=None):
+        """Reconstruct ``mapproject`` commands from mapprojected scene metadata.
+
+        ASP's ``mapproject`` does not write a log file, but it stamps the
+        reconstruction inputs into each output GeoTIFF header
+        (issue #96). The mapprojected scenes live alongside the raw inputs in
+        the processing root and/or the bundle-adjust directory, so we scan those
+        plus the stereo directory.
+
+        Parameters
+        ----------
+        stereo_command : str, optional
+            The stereo command line for this run. When supplied, only
+            mapprojected outputs that the stereo run actually consumed (their
+            filename appears in the command) are reported -- so a
+            non-mapprojected run that shares a directory with mapprojected
+            scenes does not spuriously list a mapproject step.
+
+        Returns
+        -------
+        list of str
+            Reconstructed ``mapproject`` command lines (one per mapprojected
+            input image found), sorted; empty if the run was not mapprojected or
+            the outputs carry no ASP metadata.
+        """
+        return find_mapproject_commands(
+            [
+                self.processing_directory,
+                self.full_ba_directory,
+                self.full_stereo_directory,
+            ],
+            stereo_command=stereo_command,
+        )
+
     def from_bundle_adjust_log(self):
         """
         Extract parameters from the bundle adjustment log file.

{asp_plot-1.17.0 → asp_plot-1.18.0}/asp_plot/report.py

@@ -190,6 +190,11 @@ def compile_report(
     - stereo_run_time: Time to run stereo
     - point2dem: Point2dem command
     - point2dem_run_time: Time to run point2dem
+
+    Optional keys:
+    - mapproject: list of reconstructed mapproject command strings (one per
+      mapprojected input scene); rendered on the Processing Parameters page
+      when present and non-empty.
     """
     pdf = ASPReportPDF(report_title=report_title)
     pdf.alias_nb_pages()
@@ -432,6 +437,16 @@ def _add_alignment_stats_row_table(pdf, stats_row):
     pdf.ln(6)
 
 
+def _render_command_block(pdf, label, cmd):
+    """Render a single bold-labelled, monospace-wrapped command on the PDF."""
+    pdf.set_font("Helvetica", "B", 10)
+    pdf.cell(0, 7, f"{label} Command:", new_x="LMARGIN", new_y="NEXT")
+    pdf.set_font("Courier", "", 7)
+    wrapped = textwrap.fill(cmd, width=120)
+    pdf.multi_cell(0, 4, wrapped, new_x="LMARGIN", new_y="NEXT")
+    pdf.ln(4)
+
+
 def _add_processing_parameters_page(pdf, params, report_command):
     """Add the Processing Parameters page (runtime table + commands).
 
@@ -460,19 +475,39 @@ def _add_processing_parameters_page(pdf, params, report_command):
         pdf.multi_cell(0, 4, ref_dem)
         pdf.ln(4)
 
-    for key, label in [
-        ("bundle_adjust", "Bundle Adjust"),
-        ("stereo", "Stereo"),
-        ("point2dem", "point2dem"),
-    ]:
-        cmd = params.get(key, "")
-        if cmd:
-            pdf.set_font("Helvetica", "B", 10)
-            pdf.cell(0, 7, f"{label} Command:", new_x="LMARGIN", new_y="NEXT")
-            pdf.set_font("Courier", "", 7)
+    # Render commands in ASP pipeline order: bundle_adjust -> mapproject ->
+    # stereo -> point2dem. mapproject is reconstructed from output metadata
+    # (it writes no log), so it carries an explanatory note and may be a list.
+    if params.get("bundle_adjust"):
+        _render_command_block(pdf, "Bundle Adjust", params["bundle_adjust"])
+
+    mapproject_cmds = params.get("mapproject") or []
+    if mapproject_cmds:
+        label = (
+            "Mapproject Command" if len(mapproject_cmds) == 1 else "Mapproject Commands"
+        )
+        pdf.set_font("Helvetica", "B", 10)
+        pdf.cell(0, 7, f"{label}:", new_x="LMARGIN", new_y="NEXT")
+        pdf.set_font("Helvetica", "I", 7)
+        pdf.multi_cell(
+            0,
+            4,
+            "Reconstructed from output GeoTIFF metadata (mapproject writes no "
+            "log file); session type and grid size are the resolved values.",
+            new_x="LMARGIN",
+            new_y="NEXT",
+        )
+        pdf.set_font("Courier", "", 7)
+        for cmd in mapproject_cmds:
             wrapped = textwrap.fill(cmd, width=120)
-            pdf.multi_cell(0, 4, wrapped)
-            pdf.ln(4)
+            pdf.multi_cell(0, 4, wrapped, new_x="LMARGIN", new_y="NEXT")
+            pdf.ln(1)
+        pdf.ln(3)
+
+    if params.get("stereo"):
+        _render_command_block(pdf, "Stereo", params["stereo"])
+    if params.get("point2dem"):
+        _render_command_block(pdf, "point2dem", params["point2dem"])
 
     if report_command:
         pdf.set_font("Helvetica", "B", 10)

{asp_plot-1.17.0 → asp_plot-1.18.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "asp_plot"
-version = "1.17.0"
+version = "1.18.0"
 license = {text = "BSD-3-Clause"}
 authors = [
   { name="Ben Purinton", email="purinton@uw.edu" },