Merge branch 'main' into ceres-loss-function

Author: kielnino

.github/workflows/conda.yml

@@ -0,0 +1,37 @@
+name: Conda CI
+
+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@v2
+        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: python setup.py build
+
+      - name: Run C++ tests
+        shell: bash -l {0}
+        run: cd cmake_build && ctest
+
+      - name: Run Python tests
+        shell: bash -l {0}
+        run: python -m pytest

conda.yml

@@ -1,31 +1,31 @@
 name: opensfm
 dependencies:
-    - python=3.8
+    - python=3.10
     - cmake=3.31
     - make
     - libxcrypt
-    - opencv
+    - libopencv *=headless*
+    - py-opencv
     - ceres-solver=2.1
     - conda-forge::llvm-openmp
     - conda-forge::cxx-compiler
     - pip
     - pip:
-        - cloudpickle==0.4.0
-        - exifread==2.1.2
-        - flask==2.3.2
-        - fpdf2==2.4.6
-        - joblib==0.14.1
-        - matplotlib
-        - networkx==2.5
-        - numpy>=1.19
-        - Pillow>=8.1.1
-        - pyproj>=1.9.5.1
-        - pytest==6.2.0
-        - python-dateutil>=2.7
-        - pyyaml>5.4
-        - scipy>=1.10.0
+        - cloudpickle==3.1.1
+        - ExifRead==3.3.1
+        - Flask==3.1.1
+        - fpdf2==2.8.3
+        - joblib==1.5.1
+        - matplotlib==3.5.1
+        - networkx==3.4.2
+        - numpy==1.21.5
+        - Pillow==9.0.1
+        - pyproj>=3.3.0
+        - pytest==8.4.0
+        - python-dateutil==2.8.1
+        - PyYAML>=5.4.1
+        - scipy==1.8.0
         - Sphinx==4.2.0
-        - six
-        - xmltodict==0.10.2
+        - xmltodict==0.14.2
         - wheel
         - sphinx_rtd_theme

opensfm/features_processing.py

@@ -3,6 +3,7 @@
 import logging
 import math
 import queue
+import sys
 import threading
 from timeit import default_timer as timer
 from typing import Any, cast, Dict, List, Optional, Tuple, Union
@@ -16,11 +17,23 @@
 
 logger: logging.Logger = logging.getLogger(__name__)
 
-ProcessQueue = queue.Queue[
-    Optional[
-        Tuple[str, NDArray, Optional[NDArray], Optional[NDArray], DataSetBase, bool]
+
+if sys.version_info >= (3, 9):
+    ProcessQueue = queue.Queue[
+        Optional[
+            Tuple[
+                str,
+                NDArray,
+                Optional[NDArray],
+                Optional[NDArray],
+                DataSetBase,
+                bool,
+            ]
+        ]
     ]
-]
+else:
+    ProcessQueue = queue.Queue
+
 ProducerArgs = Tuple[
     ProcessQueue,
     DataSetBase,

opensfm/large/metadataset.py

@@ -1,26 +1,28 @@
-# pyre-unsafe
+# pyre-strict
 import glob
 import os
 import os.path
 import shutil
 import sys
+from typing import Any, Dict, Generator, List, Tuple
 
 import numpy as np
+from numpy.typing import NDArray
 from opensfm import config, io
 from opensfm.dataset import DataSet
 
 
 class MetaDataSet:
-    def __init__(self, data_path):
+    def __init__(self, data_path: str) -> None:
         """
         Create meta dataset instance for large scale reconstruction.
 
         :param data_path: Path to directory containing meta dataset
         """
-        self.data_path = os.path.abspath(data_path)
+        self.data_path: str = os.path.abspath(data_path)
 
         config_file = os.path.join(self.data_path, "config.yaml")
-        self.config = config.load_config(config_file)
+        self.config: Dict[str, Any] = config.load_config(config_file)
 
         self._image_list_file_name = "image_list_with_gps.tsv"
         self._clusters_file_name = "clusters.npz"
@@ -32,42 +34,42 @@ def __init__(self, data_path):
 
         io.mkdir_p(self._submodels_path())
 
-    def _submodels_path(self):
+    def _submodels_path(self) -> str:
         return os.path.join(self.data_path, self.config["submodels_relpath"])
 
-    def _submodel_path(self, i):
+    def _submodel_path(self, i: int) -> str:
         """Path to submodel i folder."""
         template = self.config["submodel_relpath_template"]
         return os.path.join(self.data_path, template % i)
 
-    def _submodel_images_path(self, i):
+    def _submodel_images_path(self, i: int) -> str:
         """Path to submodel i images folder."""
         template = self.config["submodel_images_relpath_template"]
         return os.path.join(self.data_path, template % i)
 
-    def _image_groups_path(self):
+    def _image_groups_path(self) -> str:
         return os.path.join(self.data_path, "image_groups.txt")
 
-    def _image_list_path(self):
+    def _image_list_path(self) -> str:
         return os.path.join(self._submodels_path(), self._image_list_file_name)
 
-    def _clusters_path(self):
+    def _clusters_path(self) -> str:
         return os.path.join(self._submodels_path(), self._clusters_file_name)
 
-    def _clusters_with_neighbors_path(self):
+    def _clusters_with_neighbors_path(self) -> str:
         return os.path.join(
             self._submodels_path(), self._clusters_with_neighbors_file_name
         )
 
-    def _clusters_with_neighbors_geojson_path(self):
+    def _clusters_with_neighbors_geojson_path(self) -> str:
         return os.path.join(
             self._submodels_path(), self._clusters_with_neighbors_geojson_file_name
         )
 
-    def _clusters_geojson_path(self):
+    def _clusters_geojson_path(self) -> str:
         return os.path.join(self._submodels_path(), self._clusters_geojson_file_name)
 
-    def _create_symlink(self, base_path, file_path):
+    def _create_symlink(self, base_path: str, file_path: str) -> None:
         src = os.path.join(self.data_path, file_path)
         dst = os.path.join(base_path, file_path)
 
@@ -104,59 +106,61 @@ def _create_symlink(self, base_path, file_path):
                 os.path.join(*[".."] * subfolders, os.path.relpath(src, base_path)), dst
             )
 
-    def image_groups_exists(self):
+    def image_groups_exists(self) -> bool:
         return os.path.isfile(self._image_groups_path())
 
-    def load_image_groups(self):
+    def load_image_groups(self) -> Generator[List[str], None, None]:
         with open(self._image_groups_path()) as fin:
             for line in fin:
                 yield line.split()
 
-    def image_list_exists(self):
+    def image_list_exists(self) -> bool:
         return os.path.isfile(self._image_list_path())
 
-    def create_image_list(self, ills):
+    def create_image_list(self, ills: List[Tuple[str, float, float]]) -> None:
         with io.open_wt(self._image_list_path()) as csvfile:
             for image, lat, lon in ills:
                 csvfile.write("{}\t{}\t{}\n".format(image, lat, lon))
 
-    def images_with_gps(self):
+    def images_with_gps(self) -> Generator[Tuple[str, float, float], None, None]:
         with io.open_rt(self._image_list_path()) as csvfile:
             for line in csvfile:
                 image, lat, lon = line.split("\t")
                 yield image, float(lat), float(lon)
 
-    def save_clusters(self, images, positions, labels, centers):
+    def save_clusters(
+        self, images: NDArray, positions: NDArray, labels: NDArray, centers: NDArray
+    ) -> None:
         filepath = self._clusters_path()
         np.savez_compressed(
             filepath, images=images, positions=positions, labels=labels, centers=centers
         )
 
-    def load_clusters(self):
+    def load_clusters(self) -> Tuple[NDArray, NDArray, NDArray, NDArray]:
         c = np.load(self._clusters_path())
         images = c["images"].ravel()
         labels = c["labels"].ravel()
         return images, c["positions"], labels, c["centers"]
 
-    def save_clusters_with_neighbors(self, clusters):
+    def save_clusters_with_neighbors(self, clusters: List[List[int]]) -> None:
         filepath = self._clusters_with_neighbors_path()
         np.savez_compressed(filepath, clusters=np.array(clusters, dtype=object))
 
-    def load_clusters_with_neighbors(self):
+    def load_clusters_with_neighbors(self) -> NDArray:
         c = np.load(self._clusters_with_neighbors_path(), allow_pickle=True)
         return c["clusters"]
 
-    def save_cluster_with_neighbors_geojson(self, geojson):
+    def save_cluster_with_neighbors_geojson(self, geojson: Dict[str, Any]) -> None:
         filepath = self._clusters_with_neighbors_geojson_path()
         with io.open_wt(filepath) as fout:
             io.json_dump(geojson, fout)
 
-    def save_clusters_geojson(self, geojson):
+    def save_clusters_geojson(self, geojson: Dict[str, Any]) -> None:
         filepath = self._clusters_geojson_path()
         with io.open_wt(filepath) as fout:
             io.json_dump(geojson, fout)
 
-    def remove_submodels(self):
+    def remove_submodels(self) -> None:
         sm = self._submodels_path()
         paths = [
             os.path.join(sm, o)
@@ -166,7 +170,7 @@ def remove_submodels(self):
         for path in paths:
             shutil.rmtree(path)
 
-    def create_submodels(self, clusters):
+    def create_submodels(self, clusters: NDArray) -> None:
         data = DataSet(self.data_path)
         for i, cluster in enumerate(clusters):
             # create sub model dirs
@@ -216,7 +220,7 @@ def create_submodels(self, clusters):
             for filepath in filepaths:
                 self._create_symlink(submodel_path, filepath)
 
-    def get_submodel_paths(self):
+    def get_submodel_paths(self) -> List[str]:
         submodel_paths = []
         for i in range(999999):
             submodel_path = self._submodel_path(i)