Setting Up OpenDroneMap with Python

import subprocess
import logging

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")

ODM_IMAGE = "opendronemap/odm:3.5.4"  # pin the tag for reproducible runs

def ensure_odm_image(image: str = ODM_IMAGE) -> None:
    """Verify the Docker daemon is up and the pinned ODM image is present."""
    # `docker info` returns non-zero if the daemon is unreachable.
    info = subprocess.run(["docker", "info"], capture_output=True, text=True)
    if info.returncode != 0:
        raise RuntimeError("Docker daemon is not reachable. Start Docker before processing.")

    have = subprocess.run(
        ["docker", "image", "inspect", image],
        capture_output=True, text=True,
    )
    if have.returncode != 0:
        logging.info("Image %s not found locally; pulling...", image)
        pull = subprocess.run(["docker", "pull", image], capture_output=True, text=True)
        if pull.returncode != 0:
            raise RuntimeError(f"Failed to pull {image}: {pull.stderr}")
    logging.info("ODM image %s is ready.", image)

import logging
from pathlib import Path
from PIL import Image, ExifTags

def validate_and_standardize_images(input_dir: Path, output_dir: Path,
                                    min_images: int = 50) -> int:
    """Reject images without GPS EXIF and write the rest as uncompressed TIFF."""
    output_dir.mkdir(parents=True, exist_ok=True)
    valid = 0

    for img_path in sorted(input_dir.glob("*.[jJ][pP][gG]")):
        try:
            with Image.open(img_path) as img:
                exif = img.getexif()
                if not exif:
                    logging.warning("No EXIF in %s; skipping.", img_path.name)
                    continue

                # The top-level GPS tag (0x8825) is only an offset; resolve the
                # GPS sub-IFD explicitly or the latitude lookup below fails.
                gps_ifd = exif.get_ifd(ExifTags.IFD.GPSInfo)
                if not gps_ifd or ExifTags.GPS.GPSLatitude not in gps_ifd:
                    logging.warning("Missing GPS metadata in %s; skipping.", img_path.name)
                    continue

                tiff_path = output_dir / f"{img_path.stem}.tif"
                img.save(tiff_path, format="TIFF", compression=None,
                         exif=img.info.get("exif"))
                valid += 1
        except Exception as exc:  # noqa: BLE001 — log and continue the batch
            logging.error("Failed on %s: %s", img_path.name, exc)
            continue

    if valid < min_images:
        raise ValueError(f"Insufficient valid images ({valid}/{min_images}); aborting.")
    logging.info("Standardized %d images into %s", valid, output_dir)
    return valid

import psutil
import subprocess
import logging
from pathlib import Path

def run_odm(project_dir: Path, image: str = ODM_IMAGE,
            timeout_s: int = 86_400) -> None:
    """Run ODM via Docker with RAM-aware flag injection and a hard timeout."""
    gib = 1024 ** 3
    available = psutil.virtual_memory().available

    flags = [
        "docker", "run", "--rm",
        "--memory=24g", "--memory-swap=24g",  # equal values disable swap
        "-v", f"{project_dir}/images:/images:ro",
        "-v", f"{project_dir}/odm:/odm",
        image, "--project-path", "/odm",
    ]

    if available < 16 * gib:
        logging.warning("Low RAM (%.1f GiB); enabling conservative flags.", available / gib)
        flags += ["--feature-quality", "low",
                  "--split", "500", "--split-overlap", "100"]
    else:
        flags += ["--feature-quality", "high", "--dsm", "--orthophoto"]

    logging.info("Launching ODM container...")
    try:
        result = subprocess.run(flags, capture_output=True, text=True, timeout=timeout_s)
    except subprocess.TimeoutExpired:
        logging.error("ODM exceeded the %d s timeout; terminating.", timeout_s)
        raise

    if result.returncode != 0:
        # Exit 137 is the OOM killer; 1 is usually alignment / bundle failure.
        logging.error("ODM exited %d: %s", result.returncode, result.stderr[-2000:])
        raise RuntimeError("ODM processing failed; inspect the tail of stderr.")
    logging.info("ODM processing completed.")

from pyodm import Node

def submit_via_nodeodm(image_paths: list[str], host: str = "localhost",
                       port: int = 3000) -> str:
    """Submit a task to a running NodeODM instance and block until done."""
    node = Node(host, port)
    task = node.create_task(
        image_paths,
        options={"feature-quality": "high", "dsm": True, "orthophoto-resolution": 2.0},
    )
    task.wait_for_completion()       # raises on server-side failure
    task.download_assets("./odm_out")
    return task.info().uuid

import logging
from pathlib import Path
from osgeo import gdal, osr

gdal.UseExceptions()

def validate_and_assign_crs(geo_tiff: Path, target_epsg: int = 32610) -> Path:
    """Confirm a raster's CRS and reproject to the target EPSG if it differs."""
    ds = gdal.Open(str(geo_tiff))
    if ds is None:
        raise RuntimeError(f"Failed to open raster: {geo_tiff}")
    try:
        srs = osr.SpatialReference()
        srs.ImportFromWkt(ds.GetProjection())
        # AutoIdentifyEPSG populates the AUTHORITY node; without it
        # GetAuthorityCode often returns None and reprojection is skipped.
        srs.AutoIdentifyEPSG()
        current = srs.GetAuthorityCode(None)
        if current is None:
            raise RuntimeError(f"Could not identify source CRS for {geo_tiff}.")

        if int(current) == target_epsg:
            logging.info("%s already in EPSG:%d.", geo_tiff.name, target_epsg)
            return geo_tiff

        out_path = geo_tiff.parent / f"{geo_tiff.stem}_epsg{target_epsg}.tif"
        gdal.Warp(
            str(out_path), ds,
            options=gdal.WarpOptions(
                dstSRS=f"EPSG:{target_epsg}", resampleAlg="cubic",
                format="GTiff", creationOptions=["COMPRESS=LZW", "BIGTIFF=YES"],
            ),
        )
        logging.info("Reprojected %s → EPSG:%d", geo_tiff.name, target_epsg)
        return out_path
    finally:
        ds = None  # release the file descriptor even if Warp raises

import time
import logging
from pathlib import Path

def run_pipeline(project_dir: Path, target_epsg: int = 32610) -> None:
    """End-to-end ODM run with per-stage checkpoints and a single retry."""
    raw = project_dir / "raw"
    images = project_dir / "images"
    odm_out = project_dir / "odm"

    if not (images / ".validated").exists():
        validate_and_standardize_images(raw, images)
        (images / ".validated").touch()

    if not (odm_out / "odm_orthophoto" / "odm_orthophoto.tif").exists():
        for attempt in range(2):
            try:
                ensure_odm_image()
                run_odm(project_dir)
                break
            except RuntimeError as exc:
                wait = 2 ** attempt * 30  # exponential backoff
                logging.warning("ODM attempt %d failed (%s); retry in %ds.",
                                attempt + 1, exc, wait)
                time.sleep(wait)
        else:
            raise RuntimeError("ODM failed after retries; aborting promotion.")

    ortho = odm_out / "odm_orthophoto" / "odm_orthophoto.tif"
    validate_and_assign_crs(ortho, target_epsg)
    logging.info("Pipeline complete for %s", project_dir)

import logging
from pathlib import Path
from osgeo import gdal, osr

def verify_outputs(odm_out: Path, expected_epsg: int) -> None:
    """Assert ODM produced a readable, georeferenced orthophoto."""
    ortho = odm_out / "odm_orthophoto" / "odm_orthophoto.tif"
    assert ortho.exists() and ortho.stat().st_size > 0, "orthophoto missing or empty"

    ds = gdal.Open(str(ortho))
    assert ds is not None, "orthophoto is unreadable / corrupt"

    srs = osr.SpatialReference()
    srs.ImportFromWkt(ds.GetProjection())
    srs.AutoIdentifyEPSG()
    code = srs.GetAuthorityCode(None)
    assert code is not None and int(code) == expected_epsg, \
        f"orthophoto CRS is {code}, expected {expected_epsg}"

    gt = ds.GetGeoTransform()
    assert gt and abs(gt[1]) > 0, "orthophoto has a degenerate geotransform"
    logging.info("Outputs verified: %d x %d px, EPSG:%s",
                 ds.RasterXSize, ds.RasterYSize, code)
    ds = None