Merge branch 'main' of github.com:colmap/glomap into ra_debug

Author: lpanaf

.github/workflows/ubuntu.yml

@@ -107,6 +107,7 @@ jobs:
             libmetis-dev \
             libgoogle-glog-dev \
             libgtest-dev \
+            libgmock-dev \
             libsqlite3-dev \
             libglew-dev \
             qtbase5-dev \

cmake/FindDependencies.cmake

@@ -7,11 +7,12 @@ find_package(Boost REQUIRED)
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     find_package(Glog REQUIRED)
-    if(DEFINED glog_VERSION_MAJOR)
-        # Older versions of glog don't export version variables.
-        add_definitions("-DGLOG_VERSION_MAJOR=${glog_VERSION_MAJOR}")
-        add_definitions("-DGLOG_VERSION_MINOR=${glog_VERSION_MINOR}")
-    endif()
+endif()
+
+if(DEFINED glog_VERSION_MAJOR)
+    # Older versions of glog don't export version variables.
+    add_definitions("-DGLOG_VERSION_MAJOR=${glog_VERSION_MAJOR}")
+    add_definitions("-DGLOG_VERSION_MINOR=${glog_VERSION_MINOR}")
 endif()
 
 if(TESTS_ENABLED)
@@ -24,6 +25,7 @@ FetchContent_Declare(PoseLib
     GIT_REPOSITORY    https://github.com/PoseLib/PoseLib.git
     GIT_TAG           0439b2d361125915b8821043fca9376e6cc575b9
     EXCLUDE_FROM_ALL
+    SYSTEM
 )
 message(STATUS "Configuring PoseLib...")
 if (FETCH_POSELIB) 
@@ -35,7 +37,7 @@ message(STATUS "Configuring PoseLib... done")
 
 FetchContent_Declare(COLMAP
     GIT_REPOSITORY    https://github.com/colmap/colmap.git
-    GIT_TAG           66fd8e56a0d160d68af2f29e9ac6941d442d2322
+    GIT_TAG           78f1eefacae542d753c2e4f6a26771a0d976227d
     EXCLUDE_FROM_ALL
 )
 message(STATUS "Configuring COLMAP...")

glomap/CMakeLists.txt

@@ -19,6 +19,7 @@ set(SOURCES
     math/two_view_geometry.cc
     processors/image_pair_inliers.cc
     processors/image_undistorter.cc
+    processors/reconstruction_normalizer.cc
     processors/reconstruction_pruning.cc
     processors/relpose_filter.cc
     processors/track_filter.cc
@@ -51,6 +52,7 @@ set(HEADERS
     math/union_find.h
     processors/image_pair_inliers.h
     processors/image_undistorter.h
+    processors/reconstruction_normalizer.h
     processors/reconstruction_pruning.h
     processors/relpose_filter.h
     processors/track_filter.h

glomap/controllers/global_mapper.cc

@@ -1,12 +1,15 @@
 #include "global_mapper.h"
 
+#include "glomap/io/colmap_converter.h"
 #include "glomap/processors/image_pair_inliers.h"
 #include "glomap/processors/image_undistorter.h"
+#include "glomap/processors/reconstruction_normalizer.h"
 #include "glomap/processors/reconstruction_pruning.h"
 #include "glomap/processors/relpose_filter.h"
 #include "glomap/processors/track_filter.h"
 #include "glomap/processors/view_graph_manipulation.h"
 
+#include <colmap/util/file.h>
 #include <colmap/util/timer.h>
 
 namespace glomap {
@@ -166,6 +169,10 @@ bool GlobalMapper::Solve(const colmap::Database& database,
         images,
         tracks,
         options_.inlier_thresholds.max_angle_error);
+
+    // Normalize the structure
+    NormalizeReconstruction(cameras, images, tracks);
+
     run_timer.PrintSeconds();
   }
 
@@ -208,6 +215,9 @@ bool GlobalMapper::Solve(const colmap::Database& database,
       if (ite != options_.num_iteration_bundle_adjustment - 1)
         run_timer.PrintSeconds();
 
+      // Normalize the structure
+      NormalizeReconstruction(cameras, images, tracks);
+
       // 6.3. Filter tracks based on the estimation
       // For the filtering, in each round, the criteria for outlier is
       // tightened. If only few tracks are changed, no need to start bundle
@@ -291,6 +301,9 @@ bool GlobalMapper::Solve(const colmap::Database& database,
       run_timer.PrintSeconds();
     }
 
+    // Normalize the structure
+    NormalizeReconstruction(cameras, images, tracks);
+
     // Filter tracks based on the estimation
     UndistortImages(cameras, images, true);
     LOG(INFO) << "Filtering tracks by reprojection ...";
@@ -325,4 +338,4 @@ bool GlobalMapper::Solve(const colmap::Database& database,
   return true;
 }
 
-}  // namespace glomap
+}  // namespace glomap

glomap/controllers/track_retriangulation.cc

@@ -2,10 +2,12 @@
 
 #include "glomap/io/colmap_converter.h"
 
-#include <colmap/controllers/incremental_mapper.h>
+#include <colmap/controllers/incremental_pipeline.h>
 #include <colmap/estimators/bundle_adjustment.h>
 #include <colmap/scene/database_cache.h>
 
+#include <set>
+
 namespace glomap {
 
 bool RetriangulateTracks(const TriangulatorOptions& options,
@@ -40,7 +42,7 @@ bool RetriangulateTracks(const TriangulatorOptions& options,
                         std::unordered_map<track_t, Track>(),
                         *reconstruction_ptr);
 
-  colmap::IncrementalMapperOptions options_colmap;
+  colmap::IncrementalPipelineOptions options_colmap;
   options_colmap.triangulation.complete_max_reproj_error =
       options.tri_complete_max_reproj_error;
   options_colmap.triangulation.merge_max_reproj_error =
@@ -57,13 +59,13 @@ bool RetriangulateTracks(const TriangulatorOptions& options,
   const auto tri_options = options_colmap.Triangulation();
   const auto mapper_options = options_colmap.Mapper();
 
-  const std::vector<image_t>& reg_image_ids = reconstruction_ptr->RegImageIds();
+  const std::set<image_t>& reg_image_ids = reconstruction_ptr->RegImageIds();
 
-  for (size_t i = 0; i < reg_image_ids.size(); ++i) {
-    std::cout << "\r Triangulating image " << i + 1 << " / "
+  size_t image_idx = 0;
+  for (const image_t image_id : reg_image_ids) {
+    std::cout << "\r Triangulating image " << image_idx++ + 1 << " / "
               << reg_image_ids.size() << std::flush;
 
-    const image_t image_id = reg_image_ids[i];
     const auto& image = reconstruction_ptr->Image(image_id);
 
     int num_tris = mapper.TriangulateImage(tri_options, image_id);
@@ -96,10 +98,10 @@ bool RetriangulateTracks(const TriangulatorOptions& options,
     const size_t num_observations =
         reconstruction_ptr->ComputeNumObservations();
 
-    // PrintHeading1("Bundle adjustment");
-    colmap::BundleAdjuster bundle_adjuster(ba_options, ba_config);
-    // THROW_CHECK(bundle_adjuster.Solve(reconstruction.get()));
-    if (!bundle_adjuster.Solve(reconstruction_ptr.get())) {
+    std::unique_ptr<colmap::BundleAdjuster> bundle_adjuster;
+    bundle_adjuster =
+        CreateDefaultBundleAdjuster(ba_options, ba_config, *reconstruction_ptr);
+    if (bundle_adjuster->Solve().termination_type == ceres::FAILURE) {
       return false;
     }
 
@@ -128,4 +130,4 @@ bool RetriangulateTracks(const TriangulatorOptions& options,
   return true;
 }
 
-}  // namespace glomap
+}  // namespace glomap

glomap/estimators/bundle_adjustment.cc

@@ -54,6 +54,7 @@ void BundleAdjuster::Reset() {
   ceres::Problem::Options problem_options;
   problem_options.loss_function_ownership = ceres::DO_NOT_TAKE_OWNERSHIP;
   problem_ = std::make_unique<ceres::Problem>(problem_options);
+  loss_function_ = options_.CreateLossFunction();
 }
 
 void BundleAdjuster::AddPointToCameraConstraints(
@@ -70,14 +71,14 @@ void BundleAdjuster::AddPointToCameraConstraints(
       Image& image = images[observation.first];
 
       ceres::CostFunction* cost_function =
-          colmap::CameraCostFunction<colmap::ReprojErrorCostFunction>(
+          colmap::CreateCameraCostFunction<colmap::ReprojErrorCostFunctor>(
               cameras[image.camera_id].model_id,
               image.features[observation.second]);
 
       if (cost_function != nullptr) {
         problem_->AddResidualBlock(
             cost_function,
-            options_.loss_function.get(),
+            loss_function_.get(),
             image.cam_from_world.rotation.coeffs().data(),
             image.cam_from_world.translation.data(),
             tracks[track_id].xyz.data(),

glomap/estimators/bundle_adjustment.h

@@ -21,9 +21,12 @@ struct BundleAdjusterOptions : public OptimizationBaseOptions {
 
   BundleAdjusterOptions() : OptimizationBaseOptions() {
     thres_loss_function = 1.;
-    loss_function = std::make_shared<ceres::HuberLoss>(thres_loss_function);
     solver_options.max_num_iterations = 200;
   }
+
+  std::shared_ptr<ceres::LossFunction> CreateLossFunction() {
+    return std::make_shared<ceres::HuberLoss>(thres_loss_function);
+  }
 };
 
 class BundleAdjuster {
@@ -65,6 +68,7 @@ class BundleAdjuster {
   BundleAdjusterOptions options_;
 
   std::unique_ptr<ceres::Problem> problem_;
+  std::shared_ptr<ceres::LossFunction> loss_function_;
 };
 
 }  // namespace glomap

glomap/estimators/global_positioning.cc

@@ -87,6 +87,8 @@ void GlobalPositioner::SetupProblem(
   ceres::Problem::Options problem_options;
   problem_options.loss_function_ownership = ceres::DO_NOT_TAKE_OWNERSHIP;
   problem_ = std::make_unique<ceres::Problem>(problem_options);
+  loss_function_ = options_.CreateLossFunction();
+
   // Allocate enough memory for the scales. One for each residual.
   // Due to possibly invalid image pairs or tracks, the actual number of
   // residuals may be smaller.
@@ -169,7 +171,7 @@ void GlobalPositioner::AddCameraToCameraConstraints(
         BATAPairwiseDirectionError::Create(translation);
     problem_->AddResidualBlock(
         cost_function,
-        options_.loss_function.get(),
+        loss_function_.get(),
         images[image_id1].cam_from_world.translation.data(),
         images[image_id2].cam_from_world.translation.data(),
         &scale);
@@ -212,19 +214,17 @@ void GlobalPositioner::AddPointToCameraConstraints(
 
   if (loss_function_ptcam_uncalibrated_ == nullptr) {
     loss_function_ptcam_uncalibrated_ =
-        std::make_shared<ceres::ScaledLoss>(options_.loss_function.get(),
+        std::make_shared<ceres::ScaledLoss>(loss_function_.get(),
                                             0.5 * weight_scale_pt,
                                             ceres::DO_NOT_TAKE_OWNERSHIP);
   }
 
   if (options_.constraint_type ==
       GlobalPositionerOptions::POINTS_AND_CAMERAS_BALANCED) {
-    loss_function_ptcam_calibrated_ =
-        std::make_shared<ceres::ScaledLoss>(options_.loss_function.get(),
-                                            weight_scale_pt,
-                                            ceres::DO_NOT_TAKE_OWNERSHIP);
+    loss_function_ptcam_calibrated_ = std::make_shared<ceres::ScaledLoss>(
+        loss_function_.get(), weight_scale_pt, ceres::DO_NOT_TAKE_OWNERSHIP);
   } else {
-    loss_function_ptcam_calibrated_ = options_.loss_function;
+    loss_function_ptcam_calibrated_ = loss_function_;
   }
 
   for (auto& [track_id, track] : tracks) {

glomap/estimators/global_positioning.h

@@ -42,7 +42,10 @@ struct GlobalPositionerOptions : public OptimizationBaseOptions {
 
   GlobalPositionerOptions() : OptimizationBaseOptions() {
     thres_loss_function = 1e-1;
-    loss_function = std::make_shared<ceres::HuberLoss>(thres_loss_function);
+  }
+
+  std::shared_ptr<ceres::LossFunction> CreateLossFunction() {
+    return std::make_shared<ceres::HuberLoss>(thres_loss_function);
   }
 };
 
@@ -104,6 +107,7 @@ class GlobalPositioner {
   std::unique_ptr<ceres::Problem> problem_;
 
   // Loss functions for reweighted terms.
+  std::shared_ptr<ceres::LossFunction> loss_function_;
   std::shared_ptr<ceres::LossFunction> loss_function_ptcam_uncalibrated_;
   std::shared_ptr<ceres::LossFunction> loss_function_ptcam_calibrated_;
 

glomap/estimators/gravity_refinement.cc

@@ -27,6 +27,8 @@ void GravityRefiner::RefineGravity(const ViewGraph& view_graph,
     return;
   }
 
+  loss_function_ = options_.CreateLossFunction();
+
   int counter_progress = 0;
   // Iterate through the error prone images
   for (auto image_id : error_prone_images) {
@@ -70,8 +72,7 @@ void GravityRefiner::RefineGravity(const ViewGraph& view_graph,
 
       ceres::CostFunction* coor_cost =
           GravError::CreateCost(gravities[counter]);
-      problem.AddResidualBlock(
-          coor_cost, options_.loss_function.get(), gravity.data());
+      problem.AddResidualBlock(coor_cost, loss_function_.get(), gravity.data());
       counter++;
     }