Better and Faster

.dockerignore

@@ -11,8 +11,9 @@
 !doc
 !LICENSE
 !opensfm
+!pyproject.toml
+!conda.yml
 !README.md
-!requirements.txt
 !setup.cfg
 !setup.py
 !viewer

.github/copilot-instructions.md

@@ -0,0 +1,52 @@
+# OpenSfM AI Coding Instructions
+
+## 1. Architecture & "Big Picture"
+OpenSfM is a Structure-from-Motion library with a hybrid architecture:
+- **Core Logic (C++)**: Heavy computational tasks (geometry, bundle adjustment, features) are implemented in C++ under `opensfm/src/`. These are exposed to Python as compiled modules (e.g., `pygeometry`, `pymap`, `pfm`) using **PyBind11**.
+- **Pipeline Layout (Python)**: The application logic, pipeline orchestration, and user interface are in Python (`opensfm/` package).
+- **Data Abstraction**: The `DataSet` class (`opensfm/dataset.py`) is the central definition for filesystem interactions. All pipeline stages read/write to a hardcoded directory structure (`images/`, `config.yaml`, `reconstruction.json`) managed by this class.
+- **State Management**: The `Reconstruction` class (`opensfm/types.py`) wraps the C++ `pymap.Map` object. This pattern (Python class holding a C++ handle) is pervasive.
+
+## 2. Key Developer Workflows
+
+### Building
+The project uses `scikit-build-core` to compile C++ extensions.
+- **Full Build**: `pip install -e .[test]` (Builds C++ extensions and tests, and installs the package in editable mode).
+- **Rebuild C++**: Re-running `pip install -e .` is usually required after changing `.cc` files.
+- **Dependencies**: Managed via `pyproject.toml` for managing Python dependencies. Outer envinvironment (C++ toolchain, libraries) is set up through `conda` and the `conda.yml` file. Any change to `conda.yml` requires recreating the conda environment with `conda env create --file conda.yml --yes`, then activating it with `conda activate opensfm`. Note that before running the build commands, the conda environment must be activated once.
+
+### Testing
+- **Framework**: `pytest` is used for all tests.
+- **Location**: `opensfm/test/` for Python tests. C++ tests are in `./cmake_build`.
+- **Synthetic Data**: Python tests heavily rely on synthetic scenes generated in `opensfm/test/conftest.py`. Look for fixtures like `scene_synthetic` or `scene_synthetic_cube`.
+- **Run Tests**: `pytest opensfm/test/` for Python tests. C++ tests can be run via `ctest` with `cd cmake_build && ctest --output-on-failure && cd ..`.
+
+### Running the Pipeline
+- **Entry Point**: `bin/opensfm` (shell script) -> `bin/opensfm_main.py`.
+- **Commands**: Each CLI command (e.g., `detect_features`, `reconstruct`) is implemented as a module in `opensfm/commands/`.
+- **Example**: `bin/opensfm reconstruct path/to/dataset` invokes the `run()` method in `opensfm/commands/reconstruct.py`.
+
+## 3. Coding Conventions & Patterns
+
+### Python/C++ Interop
+- **Wrappers**: Do not use C++ objects directly if a Python wrapper exists (e.g., use `opensfm.types.Reconstruction` instead of `opensfm.pymap.Map` where possible). 
+- **Extensions**: C++ extensions are imported from the root package (e.g., `from opensfm import pygeometry`).
+
+### Type Hinting
+- **Strictness**: The codebase uses `pyre-strict`. Ensure all new code has complete type annotations. A comment `# pyre-strict` is often present at the top of files.
+
+### Configuration
+- **Definition**: Default parameters are in `opensfm/config.py` (dataclass `OpenSfMConfig`).
+- **Overrides**: Parameters are overridden by `config.yaml` in the dataset directory.
+- **Access**: Access config values via `data.config['param_name']` (where `data` is a `DataSet` instance).
+
+## 4. Essential Files
+- `opensfm/dataset.py`: **READ THIS FIRST** when dealing with file I/O. Defines where every file lives.
+- `opensfm/types.py`: Defines key data structures (`Reconstruction`, `Shot`, `Camera`).
+- `opensfm/config.py`: Documentation for all tunable parameters.
+- `opensfm/src/map/map.cc`: The backing C++ implementation for `Reconstruction`.
+- `opensfm/commands/`: Implementation of individual pipeline steps.
+
+## 5. Common Pitfalls
+- **Direct File Access**: Avoid manual `open()` calls. Use `dataset.load_*` and `dataset.save_*` methods to ensure consistency with the expected directory structure.
+- **Geometry Types**: Be careful with rotation representations (angle-axis vs matrices). `pygeometry` exposes helper functions; check `opensfm/src/geometry/` for implementation details if behavior is unclear.

.github/workflows/conda.yml

@@ -0,0 +1,37 @@
+name: Conda
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build conda environment and run tests
+
+    strategy:
+      matrix:
+        os: [ubuntu-24.04, ubuntu-22.04, macos-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Setup Miniconda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          environment-file: conda.yml
+          activate-environment: opensfm
+
+      - name: Build OpenSfM
+        shell: bash -l {0}
+        run: pip install -e .[test]
+
+      - name: Run C++ tests
+        shell: bash -l {0}
+        run: cd cmake_build && ctest
+
+      - name: Run Python tests
+        shell: bash -l {0}
+        run: export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest

.github/workflows/docker_ubuntu20.yml

@@ -0,0 +1,23 @@
+name: Docker Ubuntu 20.04
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build docker and run tests on Ubuntu 20.04
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Build the Docker image
+        run: docker build . --file Dockerfile.ubuntu20 --tag mapillary/opensfm.ubuntu20:$GITHUB_SHA
+
+      - name: Run C++ tests
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm &&  cd cmake_build && ctest'
+
+      - name: Run Python tests
+        run: docker run mapillary/opensfm.ubuntu20:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python3 -m pytest'

.github/workflows/docker_ubuntu24.yml

@@ -0,0 +1,23 @@
+name: Docker Ubuntu 24.04
+
+on: [push, pull_request]
+
+jobs:
+
+  build-test:
+    name: Build docker and run tests on Ubuntu 24.04
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Build the Docker image
+        run: docker build . --file Dockerfile.ubuntu24 --tag mapillary/opensfm.ubuntu24:$GITHUB_SHA
+
+      - name: Run C++ tests
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && cd cmake_build && ctest --output-on-failure'
+
+      - name: Run Python tests
+        run: docker run mapillary/opensfm.ubuntu24:$GITHUB_SHA /bin/bash -c 'source ~/.bashrc && conda activate opensfm && export LD_PRELOAD=$CONDA_PREFIX/lib/libtcmalloc.so && python -m pytest -v'

.gitignore

@@ -6,6 +6,8 @@ xcode
 launch.json
 .vscode
 .idea
+.claude
+uv.lock
 
 # Ignore generated files
 /build
@@ -29,3 +31,5 @@ data/berlin/*
 
 # Ignore virtualenv files
 env/*
+
+PACKAGE

Dockerfile.ubuntu20

@@ -0,0 +1,36 @@
+FROM ubuntu:20.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+    && apt-get install -y \
+        build-essential \
+        cmake \
+        git \
+        wget \
+        python3-dev \
+        python3-pip \
+        python3-venv \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Install Miniconda
+FROM continuumio/miniconda3
+
+# Setup source
+COPY . /source/OpenSfM
+WORKDIR /source/OpenSfM
+
+# Create conda environment from conda.yml
+RUN conda env create --file conda.yml --yes
+
+# Override default shell and use bash in the conda environment
+SHELL ["conda", "run", "-n", "opensfm", "/bin/bash", "-c"]
+
+# Build and install OpenSfM using pip with pyproject.toml
+# C++ tests are built automatically (OPENSFM_BUILD_TESTS=ON in pyproject.toml)
+# and will be available in cmake_build/ directory for running with ctest
+RUN pip install --no-cache-dir -e .[test]
+
+# Ensure we always activate the conda environment when starting a bash shell
+RUN echo "conda activate opensfm" >> ~/.bashrc

Dockerfile.ubuntu24

@@ -0,0 +1,36 @@
+FROM ubuntu:24.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update \
+    && apt-get install -y \
+        build-essential \
+        cmake \
+        git \
+        wget \
+        python3-dev \
+        python3-pip \
+        python3-venv \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Install Miniconda
+FROM continuumio/miniconda3
+
+# Setup source
+COPY . /source/OpenSfM
+WORKDIR /source/OpenSfM
+
+# Create conda environment from conda.yml
+RUN conda env create --file conda.yml --yes
+
+# Override default shell and use bash in the conda environment
+SHELL ["conda", "run", "-n", "opensfm", "/bin/bash", "-c"]
+
+# Build and install OpenSfM using pip with pyproject.toml
+# C++ tests are built automatically (OPENSFM_BUILD_TESTS=ON in pyproject.toml)
+# and will be available in cmake_build/ directory for running with ctest
+RUN pip install --no-cache-dir -e .[test]
+
+# Ensure we always activate the conda environment when starting a bash shell
+RUN echo "conda activate opensfm" >> ~/.bashrc

README.md

@@ -6,6 +6,7 @@ Please note that all such changes are released under the AGPLv3 license, not BSD
 
 OpenSfM ![Docker workflow](https://github.com/mapillary/opensfm/workflows/Docker%20CI/badge.svg)
 =======
+[![Conda](https://github.com/mapillary/OpenSfM/actions/workflows/conda.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/conda.yml) [![Docker Ubuntu 20.04](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu20.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu20.yml) [![Docker Ubuntu 24.04](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu24.yml/badge.svg)](https://github.com/mapillary/OpenSfM/actions/workflows/docker_ubuntu24.yml)
 
 ## Overview
 OpenSfM is a Structure from Motion library written in Python. The library serves as a processing pipeline for reconstructing camera poses and 3D scenes from multiple images. It consists of basic modules for Structure from Motion (feature detection/matching, minimal solvers) with a focus on building a robust and scalable reconstruction pipeline. It also integrates external sensor (e.g. GPS, accelerometer) measurements for geographical alignment and robustness. A JavaScript viewer is provided to preview the models and debug the pipeline.

annotation_gui_gcp/lib/GUI.py

@@ -1,3 +1,4 @@
+# pyre-unsafe
 import os
 import random
 import subprocess
@@ -6,12 +7,13 @@
 from collections import defaultdict
 
 import flask
-from annotation_gui_gcp.lib.views.cad_view import CADView
-from annotation_gui_gcp.lib.views.cp_finder_view import ControlPointFinderView
-from annotation_gui_gcp.lib.views.image_view import ImageView
-from annotation_gui_gcp.lib.views.tools_view import ToolsView
 from opensfm import dataset
 
+from .views.cad_view import CADView
+from .views.cp_finder_view import ControlPointFinderView
+from .views.image_view import ImageView
+from .views.tools_view import ToolsView
+
 
 class Gui:
     def __init__(