update doc.

Author: B1ueber2y

_sources/cli.rst.txt

@@ -85,7 +85,7 @@ If you want to run COLMAP on a computer without an attached display (e.g.,
 cluster or cloud service), COLMAP automatically switches to use CUDA if
 supported by your system. If no CUDA enabled device is available, you can
 manually select to use CPU-based feature extraction and matching by setting the
-``--SiftExtraction.use_gpu 0`` and ``--SiftMatching.use_gpu 0`` options.
+``--FeatureExtraction.use_gpu 0`` and ``--FeatureMatching.use_gpu 0`` options.
 
 Help
 ----
@@ -149,7 +149,6 @@ The available commands can be listed using the command::
           poisson_mesher
           project_generator
           rig_configurator
-          rig_bundle_adjuster
           sequential_matcher
           spatial_matcher
           stereo_fusion
@@ -166,32 +165,44 @@ the available options, e.g.::
         Options can either be specified via command-line or by defining
         them in a .ini project file passed to ``--project_path``.
 
-          -h [ --help ]
-          --project_path arg
-          --database_path arg
-          --image_path arg
-          --image_list_path arg
-          --ImageReader.camera_model arg (=SIMPLE_RADIAL)
-          --ImageReader.single_camera arg (=0)
-          --ImageReader.camera_params arg
-          --ImageReader.default_focal_length_factor arg (=1.2)
-          --SiftExtraction.num_threads arg (=-1)
-          --SiftExtraction.use_gpu arg (=1)
-          --SiftExtraction.gpu_index arg (=-1)
-          --SiftExtraction.max_image_size arg (=3200)
-          --SiftExtraction.max_num_features arg (=8192)
-          --SiftExtraction.first_octave arg (=-1)
-          --SiftExtraction.num_octaves arg (=4)
-          --SiftExtraction.octave_resolution arg (=3)
-          --SiftExtraction.peak_threshold arg (=0.0066666666666666671)
-          --SiftExtraction.edge_threshold arg (=10)
-          --SiftExtraction.estimate_affine_shape arg (=0)
-          --SiftExtraction.max_num_orientations arg (=2)
-          --SiftExtraction.upright arg (=0)
-          --SiftExtraction.domain_size_pooling arg (=0)
-          --SiftExtraction.dsp_min_scale arg (=0.16666666666666666)
-          --SiftExtraction.dsp_max_scale arg (=3)
-          --SiftExtraction.dsp_num_scales arg (=10)
+            -h [ --help ]
+            --default_random_seed arg (=0)
+            --log_to_stderr arg (=1)
+            --log_level arg (=0)
+            --project_path arg
+            --database_path arg
+            --image_path arg
+            --camera_mode arg (=-1)
+            --image_list_path arg
+            --descriptor_normalization arg (=l1_root)
+                                                  {'l1_root', 'l2'}
+            --ImageReader.mask_path arg
+            --ImageReader.camera_model arg (=SIMPLE_RADIAL)
+            --ImageReader.single_camera arg (=0)
+            --ImageReader.single_camera_per_folder arg (=0)
+            --ImageReader.single_camera_per_image arg (=0)
+            --ImageReader.existing_camera_id arg (=-1)
+            --ImageReader.camera_params arg
+            --ImageReader.default_focal_length_factor arg (=1.2)
+            --ImageReader.camera_mask_path arg
+            --FeatureExtraction.type arg (=SIFT)
+            --FeatureExtraction.max_image_size arg (=3200)
+            --FeatureExtraction.num_threads arg (=-1)
+            --FeatureExtraction.use_gpu arg (=1)
+            --FeatureExtraction.gpu_index arg (=-1)
+            --SiftExtraction.max_num_features arg (=8192)
+            --SiftExtraction.first_octave arg (=-1)
+            --SiftExtraction.num_octaves arg (=4)
+            --SiftExtraction.octave_resolution arg (=3)
+            --SiftExtraction.peak_threshold arg (=0.0066666666666666671)
+            --SiftExtraction.edge_threshold arg (=10)
+            --SiftExtraction.estimate_affine_shape arg (=0)
+            --SiftExtraction.max_num_orientations arg (=2)
+            --SiftExtraction.upright arg (=0)
+            --SiftExtraction.domain_size_pooling arg (=0)
+            --SiftExtraction.dsp_min_scale arg (=0.16666666666666666)
+            --SiftExtraction.dsp_max_scale arg (=3)
+            --SiftExtraction.dsp_num_scales arg (=10)
 
 
 The available options can either be provided directly from the command-line or

_sources/faq.rst.txt

@@ -83,7 +83,7 @@ To increase the number of matches, you should use the more discriminative
 DSP-SIFT features instead of plain SIFT and also estimate the affine feature
 shape using the options: ``--SiftExtraction.estimate_affine_shape=true`` and
 ``--SiftExtraction.domain_size_pooling=true``. In addition, you should enable
-guided feature matching using: ``--SiftMatching.guided_matching=true``.
+guided feature matching using: ``--FeatureMatching.guided_matching=true``.
 
 By default, COLMAP ignores two-view feature tracks in triangulation, resulting
 in fewer 3D points than possible. Triangulation of two-view tracks can in rare
@@ -121,7 +121,7 @@ Example of images.txt::
 
     4 0.698777 0.714625 -0.023996 0.021129 -0.048184 0.004529 -0.313427 2 image0004.png
 
-Each image above must have the same ``image_id`` (first column) as in the database (next step). 
+Each image above must have the same ``image_id`` (first column) as in the database (next step).
 This database can be inspected either in the GUI (under ``Database management > Processing``),
 or, one can create a reconstruction with colmap and later export  it as text in order to see
 the images.txt file it creates.
@@ -217,9 +217,9 @@ camera centers of a subset or all registered images. The 3D similarity
 transformation between the reconstructed model and the target coordinate frame
 of the geo-registration is determined from these correspondences.
 
-The geo-registered 3D coordinates can either be extracted from the database 
-(tvec_prior field) or from a user specified text file. 
-For text-files, the geo-registered 3D coordinates of the camera centers for 
+The geo-registered 3D coordinates can either be extracted from the database
+(tvec_prior field) or from a user specified text file.
+For text-files, the geo-registered 3D coordinates of the camera centers for
 images must be specified with the following format::
 
     image_name1.jpg X1 Y1 Z1
@@ -232,7 +232,7 @@ In case of GPS coordinates, a conversion will be performed to turn those into
 cartesian coordinates.  The conversion can be done from GPS to ECEF
 (Earth-Centered-Earth-Fixed) or to ENU (East-North-Up) coordinates. If ENU coordinates
 are used, the first image GPS coordinates will define the origin of the ENU frame.
-It is also possible to use ECEF coordinates for alignment and then rotate the aligned 
+It is also possible to use ECEF coordinates for alignment and then rotate the aligned
 reconstruction into the ENU plane.
 
 Note that at least 3 images must be specified to estimate a 3D similarity
@@ -339,22 +339,22 @@ external dense reconstruction software as an alternative, as described in the
 :ref:`Tutorial <dense-reconstruction>`. If you have a GPU with low compute power
 or you want to execute COLMAP on a machine without an attached display and
 without CUDA support, you can run all steps on the CPU by specifying the
-appropriate options (e.g., ``--SiftExtraction.use_gpu=false`` for the feature
+appropriate options (e.g., ``--FeatureExtraction.use_gpu=false`` for the feature
 extraction step). But note that this might result in a significant slow-down of
 the reconstruction pipeline. Please, also note that feature extraction on the
 CPU can consume excessive RAM for large images in the default settings, which
 might require manually reducing the maximum image size using
-``--SiftExtraction.max_image_size`` and/or setting
+``--FeatureExtraction.max_image_size`` and/or setting
 ``--SiftExtraction.first_octave 0`` or by manually limiting the number of
-threads using ``--SiftExtraction.num_threads``.
+threads using ``--FeatureExtraction.num_threads``.
 
 
 Multi-GPU support in feature extraction/matching
 ------------------------------------------------
 
 You can run feature extraction/matching on multiple GPUs by specifying multiple
-indices for CUDA-enabled GPUs, e.g., ``--SiftExtraction.gpu_index=0,1,2,3`` and
-``--SiftMatching.gpu_index=0,1,2,3`` runs the feature extraction/matching on 4
+indices for CUDA-enabled GPUs, e.g., ``--FeatureExtraction.gpu_index=0,1,2,3`` and
+``--FeatureMatching.gpu_index=0,1,2,3`` runs the feature extraction/matching on 4
 GPUs in parallel. Note that you can only run one thread per GPU and this
 typically also gives the best performance. By default, COLMAP runs one feature
 extraction/matching thread per CUDA-enabled GPU and this usually gives the best
@@ -374,15 +374,15 @@ or the following:
            memory. Consider reducing the maximum number of features.
 
 during feature matching, your GPU runs out of memory. Try decreasing the option
-``--SiftMatching.max_num_matches`` until the error disappears. Note that this
+``--FeatureMatching.max_num_matches`` until the error disappears. Note that this
 might lead to inferior feature matching results, since the lower-scale input
 features will be clamped in order to fit them into GPU memory. Alternatively,
 you could change to CPU-based feature matching, but this can become very slow,
 or better you buy a GPU with more memory.
 
 The maximum required GPU memory can be approximately estimated using the
-following formula: ``4 * num_matches * num_matches + 4 * num_matches * 256``.
-For example, if you set ``--SiftMatching.max_num_matches 10000``, the maximum
+following formula: ``4 * num_matches * num_matches + 4 * num_matches * 256`` for SIFT.
+For example, if you set ``--FeatureMatching.max_num_matches 10000``, the maximum
 required GPU memory will be around 400MB, which are only allocated if one of
 your images actually has that many features.
 

_sources/install.rst.txt

@@ -88,13 +88,19 @@ Dependencies from the default Ubuntu repositories::
         libgmock-dev \
         libsqlite3-dev \
         libglew-dev \
-        qtbase5-dev \
-        libqt5opengl5-dev \
+        qt6-base-dev \
+        libqt6opengl6-dev \
+        libqt6openglwidgets6 \
         libcgal-dev \
         libceres-dev \
         libcurl4-openssl-dev \
+        libssl-dev \
         libmkl-full-dev
 
+Alternatively, you can also build against Qt 5 instead of Qt 6 using::
+
+    qtbase5-dev libqt5opengl5-dev
+
 To compile with **CUDA support**, also install Ubuntu's default CUDA package::
 
     sudo apt-get install -y \
@@ -121,11 +127,6 @@ Run COLMAP::
     colmap -h
     colmap gui
 
-Under **Ubuntu 18.04**, the CMake configuration scripts of CGAL are broken and
-you must also install the CGAL Qt5 package::
-
-    sudo apt-get install libcgal-qt5-dev
-
 Under **Ubuntu 22.04**, there is a problem when compiling with Ubuntu's default
 CUDA package and GCC, and you must compile against GCC 10::
 
@@ -157,7 +158,7 @@ Dependencies from `Homebrew <http://brew.sh/>`__::
         glog \
         googletest \
         ceres-solver \
-        qt5 \
+        qt \
         glew \
         cgal \
         sqlite3
@@ -169,18 +170,15 @@ Configure and compile COLMAP::
     cd colmap
     mkdir build
     cd build
-    cmake .. \
-        -GNinja \
-        -DQt5_DIR="$(brew --prefix qt@5)/lib/cmake/Qt5"
+    cmake -GNinja
     ninja
     sudo ninja install
 
-If you have Qt 6 installed on your system as well, you might have to temporarily
+If you have Qt 5 installed on your system as well, you might have to temporarily
 link your Qt 5 installation while configuring CMake::
 
-    brew link qt5
-    cmake ... (from previous code block)
-    brew unlink qt5
+    brew unlink qt && brew link --force qt
+    cmake ...
 
 Run COLMAP::
 
@@ -241,6 +239,45 @@ vcpkg, first run ``./vcpkg integrate install`` (under Windows use pwsh and
     cmake .. -DCMAKE_TOOLCHAIN_FILE=path/to/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_BUILD_TYPE=Release
     cmake --build . --config release --target colmap --parallel 24
 
+Anaconda
+--------
+
+Install miniconda and run the following commands::
+
+    conda create -n colmap python=3.12
+    conda config --add channels conda-forge
+    conda config --set channel_priority strict
+    conda install \
+        cmake \
+        ninja \
+        boost \
+        ccache \
+        eigen \
+        freeimage \
+        curl \
+        metis \
+        glog \
+        gtest \
+        ceres-solver \
+        qt \
+        glew \
+        sqlite \
+        glew \
+        cgal-cpp \
+        mesa-libgl-devel-cos7-x86_64 \
+        cuda-compiler==12.6.2 \
+        cuda-cudart-dev \
+        cuda-nvrtc-dev \
+        libcurand-dev
+
+    git clone https://github.com/colmap/colmap.git
+    cd colmap
+    mkdir build
+    cd build
+    cmake .. -GNinja
+    ninja
+
+
 
 .. _installation-library:
 
@@ -282,15 +319,17 @@ with the source code ``hello_world.cc``::
         std::string message;
         colmap::OptionManager options;
         options.AddRequiredOption("message", &message);
-        options.Parse(argc, argv);
+        if (!options.Parse(argc, argv)) {
+            return EXIT_FAILURE;
+        }
 
         std::cout << colmap::StringPrintf("Hello %s!\n", message.c_str());
 
         return EXIT_SUCCESS;
     }
 
 Then compile and run your code as::
-    
+
     mkdir build
     cd build
     export colmap_DIR=${CMAKE_INSTALL_PREFIX}/share/colmap

_sources/legacy.rst.txt

@@ -4,6 +4,7 @@ Legacy Documentations
 .. toctree::
    :maxdepth: 1
 
+   v3.13 (2025-11-07) <https://colmap.github.io/legacy/3.13/index.html>
    v3.12 (2025-06-30) <https://colmap.github.io/legacy/3.12/index.html>
    v3.11 (2024-11-28) <https://colmap.github.io/legacy/3.11/index.html>
    v3.10 (2024-07-23) <https://colmap.github.io/legacy/3.10/index.html>

_sources/pycolmap/index.rst.txt

@@ -13,9 +13,11 @@ Pre-built wheels for Linux, macOS, and Windows can be installed using pip::
    pip install pycolmap
 
 The wheels are automatically built and pushed to `PyPI
-<https://pypi.org/project/pycolmap/>`_ at each release. They are currently not
-built with CUDA support, which requires building from source. To build PyCOLMAP
-from source, follow these steps:
+<https://pypi.org/project/pycolmap/>`_ at each release.
+To benefit from GPU acceleration, wheels built for CUDA 12 (only for Linux - for now)
+are available under the `package pycolmap-cuda12 <https://pypi.org/project/pycolmap-cuda12/)>`_.
+
+To build PyCOLMAP from source, follow these steps:
 
 1. Install COLMAP from source following :ref:`installation`.
 2. Build PyCOLMAP:

_sources/rigs.rst.txt

@@ -210,6 +210,11 @@ Next, we sequentially match the frames, since they were captured as a video::
 
     colmap sequential_matcher --database_path terrains/database.db
 
+Depending on the accuracy of the provided sensor_from_rig poses, you can optionally
+enable the option `--FeatureMatching.rig_verification 1` or, if you know that the
+sensors within the same frame do not have visual overlap, you can enable the option
+`--FeatureMatching.skip_image_pairs_in_same_frame 1`.
+
 Finally, we reconstruct the scene using the mapper while keeping the groundtruth
 sensor rig poses and camera parameters fixed::
 
@@ -235,3 +240,6 @@ robust. We provide an example Python script to reconstruct a 360° collection::
         --input_image_path image_directory \
         --output_path output_directory
 
+Make sure to use the version of the script that corresponds to the version of
+COLMAP that you are using, as the script at HEAD is not guaranteed to be
+compatible.

_static/documentation_options.js

@@ -1,5 +1,5 @@
 const DOCUMENTATION_OPTIONS = {
-    VERSION: '3.13.0.dev0 | a5332f46 (2025-07-05)',
+    VERSION: '3.14.0.dev0 | 5b9a079a (2025-11-14)',
     LANGUAGE: 'en',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',