Turn Photos Into Measurable 3D: Meet OpenReco

An open-source photogrammetry and 3D reconstruction platform that takes a folder of drone photos and hands you a georeferenced, measurable model — no account, no subscription, no lock-in.

OpenReco Application User Interface

A drone can fly over a quarry, a construction site, a wheat field or a heritage facade and come back with a few dozen overlapping photos. Somewhere inside those photos is a precise 3D model of the real world: every volume you’d want to measure, every elevation contour, every square meter of crop health. The hard part has never been capturing the images. It’s turning them into something you can measure.

For years, the good tools for that job have been commercial, expensive, and closed. You pay per seat or per cloud-credit, your project lives inside a format only that vendor reads, and the box stays mostly shut — you can’t see how the model was solved, you can’t script it cleanly into a pipeline, and you certainly can’t fix it yourself.

OpenReco is my attempt at the opposite of all that.

What OpenReco is

OpenReco is an open-source photogrammetry and 3D reconstruction platform. You point it at a folder of overlapping drone or camera images, and it reconstructs them into a dense point cloud, a textured mesh, an orthomosaic, and elevation models — all georeferenced, all measurable, and all reproducible. One desktop app runs the entire pipeline, and the same engine is available as a command-line tool and a Python API.

It’s MIT licensed and built clean-room from published research and permissively-licensed open source only — BSD, MIT, Apache, with no copyleft and no non-commercial restrictions anywhere in the dependency tree. The goal was capability parity with the commercial suites, not copying them: no third-party code, no borrowed UI assets, no trademarks. Just an open pipeline you can read, script, and trust.

And to be clear about where it stands: OpenReco is at v0.1.0. It’s early, but it’s real — the UAV mapping pipeline runs end-to-end and has been validated on actual drone data. More on exactly what’s solid versus approximate below, because I think that honesty matters more than a polished pitch.

From a folder of photos to a model you can measure

The whole thing is one pipeline, and every stage lives in a single node-based workspace. You can run the entire graph or any single stage on its own. The flow looks like this:

Photos → align → georeference → dense cloud → mesh → texture → DEM → orthomosaic → export.

OpenReco Application Workflow

Concretely, that means:

• Add photos. Drop in a folder; OpenReco ingests them, reads EXIF/GPS, and culls blurry frames.
• Align. It detects and matches features, then solves the camera poses into a sparse point cloud — using either incremental structure-from-motion or GLOMAP global SfM.
• Georeference. The model is placed into a real coordinate reference system, either from EXIF GPS or from ground control points you mark by hand.
• Build the dense cloud. Multi-view stereo fuses depth maps into a cloud of hundreds of thousands of points.
• Mesh and texture. A polygonal surface is reconstructed and a UV texture atlas is baked straight from the source imagery.
• Rasterize. It produces a digital surface model, contour lines at any interval, a coverage map, and an orthomosaic ready for GIS.

Then you measure. Pick a tool, click on the 3D model, and read real-world quantities: volume with a cut/fill breakdown for stockpiles and earthworks, elevation cross-section profiles with slope percentage, areas and distances annotated right in the viewport. For agriculture and forestry there are vegetation indices — NDVI, ExG, VARI — computed straight off the orthomosaic.

Elevation based views and modifying dense cloud

Measurement on mesh or dense cloud

Why it’s built the way it is

Two design decisions shaped everything.

It runs like a measuring instrument, not a black box. The whole pipeline sits on a typed DAG engine with a content-addressed cache. Every stage is keyed by a hash of its inputs and resolved parameters, which has a few quietly powerful consequences: re-running a project is a no-op, changing one parameter only recomputes the part of the graph it affects, and every run is byte-for-byte reproducible and auditable. You get an HTML processing report with registration stats, reprojection error, GPS/GCP residuals and overlap — the kind of numbers a surveyor actually needs to sign off on a deliverable. The project itself is a project.toml manifest: pipeline-as-code you can version, diff, and review.

It’s GPU-agnostic on purpose. Top-quality dense reconstruction runs on an NVIDIA CUDA COLMAP backend, but not everyone has an NVIDIA card — so there’s a portable PyTorch plane-sweep backend that runs on CUDA, Apple MPS, AMD ROCm, or plain CPU, with a sparse-cloud fallback when there’s no GPU at all. OpenReco auto-selects the right path, and a single openreco doctor command tells you exactly what's active on your machine.

The same engine drives all three interfaces. The desktop UI gives you a layer tree of the pipeline’s stages with live status, schema-driven parameter panels, and a three.js 3D viewport with eye-dome lighting and scientific colormaps. The CLI gives you run, resume, diff, report, export, volume, profile and more. And the Python API mirrors the CLI one-to-one:

import openreco
proj = openreco.Project.open("samples/sceaux")
out = proj.run()                     # cache-aware; re-running is a no-op
openreco.measure_volume("output/dsm.tif", base="min")

Does it actually work? The numbers

Claims are cheap in photogrammetry, so here’s real validation data.

On an 11-image close-range set of Sceaux Castle, all 11 images registered with a 0.63-pixel reprojection error. On a 48-image UAV set from Colorado, all 48 registered; OpenReco auto-picked the correct projection (UTM 13N), hit a GPS RMS of 2.74 m and a GCP RMS of 0.04 m, produced a true-elevation surface model, generated 38 contour levels, and computed a 21.3 million m³ volume over 6.4 hectares. The exported GeoTIFFs open correctly georeferenced in QGIS.

That last detail matters: the outputs leave in standard, open formats your existing stack already speaks — LAS/LAZ, PLY, OBJ, glTF, GeoTIFF, GeoJSON, DXF, CSV, contours, and 3D Tiles. No proprietary container, no export tax.

The honest maturity picture

I’d rather you trust OpenReco because I’m straight with you about its edges than oversell it.

Solid and validated on real data: the DAG engine, caching, CLI, Python API, project format and reporting; structure-from-motion; GPS/GCP georeferencing; the surface model, contours, coverage maps, volumes and exports; and texturing (decimate, UV-unwrap, atlas bake).

Approximate today: the orthophoto is point-cloud-based rather than image-resampled, and the bare-earth terrain model is morphological rather than from true ground classification. Usable, improving, not yet survey-perfect.

Implemented but environment-gated: there’s a neural branch — a 3D Gaussian Splatting stage that trains on the same SfM camera solution as the metric geometry, so one capture gives you both a measurable mesh and a photoreal, real-time splat. It exports a standard 3DGS .ply for any splat viewer. It needs a working CUDA toolchain, so it's there but not yet validated on every machine.

Not yet built: multi-image texture blending and PBR, a true ground-classified terrain model, learned feature matching, USD/COPC/3D-Tiles streaming, and cloud collaboration. They’re on the roadmap, and that roadmap is public.

Who it’s for

OpenReco is built for people who measure the real world: surveyors and mappers, agriculture and forestry, VFX and heritage preservation, construction and earthworks, and robotics and research. If you’ve ever wanted a photogrammetry pipeline you can actually read, script, reproduce, and extend — rather than rent — this is aimed squarely at you.

Try it in a few minutes

There’s a standalone binary for Windows, macOS and Linux that needs no Python at all — download it, run openreco doctor to check your setup, and go. If you already live in Python, it's a two-line install:

pip install -e ".[slice]"          # permissive deps only
openreco doctor                    # check GPU / deps
python scripts/fetch_sample.py     # grab the 11-image sample
openreco run samples/sceaux        # photos → shareable 3D bundle

No account. No subscription. Drop in a folder of photos and run the pipeline.

The code, the docs, and the full roadmap are on GitHub: **github.com/abhibagul/OpenReco**,

and there’s a project site at **abhibagul.github.io/OpenReco**.

If you work with drone imagery, I’d love for you to run it on your own data and tell me where it breaks. And if you build photogrammetry tools, the contributing guide is short: implement a stage, declare its inputs, and the engine handles caching, scheduling and reporting for you. Stars, issues and pull requests all genuinely help an early project find its footing.

Open-source photogrammetry, for everyone who measures the real world. Give it a folder of photos and see what comes back.