colmap · ahojnnes · Nov 24, 2025 · Nov 23, 2025 · Nov 24, 2025 · Nov 24, 2025
diff --git a/src/glomap/controllers/global_mapper.h b/src/glomap/controllers/global_mapper.h
@@ -6,7 +6,6 @@
 #include "glomap/estimators/global_rotation_averaging.h"
 #include "glomap/estimators/relpose_estimation.h"
 #include "glomap/estimators/view_graph_calibration.h"
-#include "glomap/types.h"

 #include "colmap/scene/database.h"


diff --git a/src/glomap/estimators/global_rotation_averaging.cc b/src/glomap/estimators/global_rotation_averaging.cc
@@ -19,9 +19,9 @@ namespace {
 double RelAngleError(double angle_12, double angle_1, double angle_2) {
  double est = (angle_2 - angle_1) - angle_12;

-  while (est >= EIGEN_PI) est -= TWO_PI;
+  while (est >= EIGEN_PI) est -= 2 * EIGEN_PI;

-  while (est < -EIGEN_PI) est += TWO_PI;
+  while (est < -EIGEN_PI) est += 2 * EIGEN_PI;

  // Inject random noise if the angle is too close to the boundary to break the
  // possible balance at the local minima
@@ -525,11 +525,12 @@ bool RotationEstimator::SolveL1Regression(

    // Check the residual. If it is small, stop
    // TODO: strange bug for the L1 solver: update norm state constant
+    constexpr double kEps = 1e-12;
    if (ComputeAverageStepSize(frames) <
            options_.l1_step_convergence_threshold ||
-        std::abs(last_norm - curr_norm) < EPS) {
-      if (std::abs(last_norm - curr_norm) < EPS)
-        LOG(INFO) << "std::abs(last_norm - curr_norm) < EPS";
+        std::abs(last_norm - curr_norm) < kEps) {
+      if (std::abs(last_norm - curr_norm) < kEps)
+        LOG(INFO) << "std::abs(last_norm - curr_norm) < " << kEps;
      iteration++;
      break;
    }

diff --git a/src/glomap/math/rigid3d.cc b/src/glomap/math/rigid3d.cc
@@ -44,7 +44,7 @@ Eigen::Vector3d RotationToAngleAxis(const Eigen::Matrix3d& rot) {

 Eigen::Matrix3d AngleAxisToRotation(const Eigen::Vector3d& aa_vec) {
  double aa_norm = aa_vec.norm();
-  if (aa_norm > EPS) {
+  if (aa_norm > 1e-12) {
    return Eigen::AngleAxis<double>(aa_norm, aa_vec.normalized())
        .toRotationMatrix();
  } else {

diff --git a/src/glomap/math/two_view_geometry.cc b/src/glomap/math/two_view_geometry.cc
@@ -71,25 +71,25 @@ double SampsonError(const Eigen::Matrix3d& E,
 double SampsonError(const Eigen::Matrix3d& E,
                    const Eigen::Vector3d& x1,
                    const Eigen::Vector3d& x2) {
-  Eigen::Vector3d Ex1 = E * x1 / (EPS + x1[2]);
-  Eigen::Vector3d Etx2 = E.transpose() * x2 / (EPS + x2[2]);
-
-  double C = Ex1.dot(x2);
-  double Cx = Ex1.head(2).squaredNorm();
-  double Cy = Etx2.head(2).squaredNorm();
-  double r2 = C * C / (Cx + Cy);
-
-  return r2;
+  const Eigen::Vector3d Ex1 = E * x1 / x1[2];
+  const Eigen::Vector3d Etx2 = E.transpose() * x2 / x2[2];
+  const double C = Ex1.dot(x2);
+  const double denom = Ex1.head(2).squaredNorm() + Etx2.head(2).squaredNorm();
+  if (denom == 0) {
+    return std::numeric_limits<double>::max();
+  }
+  return C * C / denom;
 }

 double HomographyError(const Eigen::Matrix3d& H,
                       const Eigen::Vector2d& x1,
                       const Eigen::Vector2d& x2) {
+  constexpr double kEps = 1e-12;
  Eigen::Vector3d Hx1 = H * x1.homogeneous();
-  Eigen::Vector2d Hx1_norm = Hx1.head(2) / (EPS + Hx1[2]);
+  Eigen::Vector2d Hx1_norm = Hx1.head(2) / (kEps + Hx1[2]);
  double r2 = (Hx1_norm - x2).squaredNorm();

  return r2;
 }

-}  // namespace glomap
+}  // namespace glomap
diff --git a/src/glomap/processors/image_pair_inliers.cc b/src/glomap/processors/image_pair_inliers.cc
@@ -100,7 +100,7 @@ double ImagePairInliers::ScoreErrorFundamental() {

  bool status = false;
  for (auto i = 0; i < 3; i++) {
-    if ((epipole(i) > EPS) || (epipole(i) < -EPS)) {
+    if (std::abs(epipole(i)) > 1e-12) {
      status = true;
      break;
    }

diff --git a/src/glomap/processors/track_filter.cc b/src/glomap/processors/track_filter.cc
@@ -17,7 +17,8 @@ int TrackFilter::FilterTracksByReprojection(
    for (auto& [image_id, feature_id] : track.observations) {
      const Image& image = images.at(image_id);
      Eigen::Vector3d pt_calc = image.CamFromWorld() * track.xyz;
-      if (pt_calc(2) < EPS) continue;
+      constexpr double kEps = 1e-12;
+      if (pt_calc(2) < kEps) continue;

      double reprojection_error = max_reprojection_error;
      if (in_normalized_image) {
@@ -26,7 +27,7 @@ int TrackFilter::FilterTracksByReprojection(

        Eigen::Vector2d pt_reproj = pt_calc.head(2) / pt_calc(2);
        reprojection_error =
-            (pt_reproj - feature_undist.head(2) / (feature_undist(2) + EPS))
+            (pt_reproj - feature_undist.head(2) / (feature_undist(2) + kEps))
                .norm();
      } else {
        Eigen::Vector2d pt_dist;
@@ -62,21 +63,17 @@ int TrackFilter::FilterTracksByAngle(
  double thres_uncalib = std::cos(DegToRad(max_angle_error * 2));
  for (auto& [track_id, track] : tracks) {
    std::vector<Observation> observation_new;
-    for (auto& [image_id, feature_id] : track.observations) {
+    for (const auto& [image_id, feature_id] : track.observations) {
      const Image& image = images.at(image_id);
-      // const Camera& camera = image.camera;
      const Eigen::Vector3d& feature_undist =
          image.features_undist.at(feature_id);
-      Eigen::Vector3d pt_calc = image.CamFromWorld() * track.xyz;
-      if (pt_calc(2) < EPS) continue;
-
-      pt_calc = pt_calc.normalized();
-      double thres_cam = (cameras.at(image.camera_id).has_prior_focal_length)
+      const Eigen::Vector3d pt_calc = (image.CamFromWorld() * track.xyz).normalized();
+      const double thres_cam = (cameras.at(image.camera_id).has_prior_focal_length)
                             ? thres
                             : thres_uncalib;

      if (pt_calc.dot(feature_undist) > thres_cam) {
-        observation_new.emplace_back(std::make_pair(image_id, feature_id));
+        observation_new.emplace_back(image_id, feature_id);
      }
    }
    if (observation_new.size() != track.observations.size()) {
@@ -126,4 +123,4 @@ int TrackFilter::FilterTrackTriangulationAngle(
  return counter;
 }

-}  // namespace glomap
+}  // namespace glomap
diff --git a/src/glomap/processors/view_graph_manipulation.cc b/src/glomap/processors/view_graph_manipulation.cc
@@ -290,7 +290,7 @@ void ViewGraphManipulater::DecomposeRelPose(
      image_pair.config = two_view_geometry.config;
      image_pair.cam2_from_cam1 = two_view_geometry.cam2_from_cam1;

-      if (image_pair.cam2_from_cam1.translation.norm() > EPS) {
+      if (image_pair.cam2_from_cam1.translation.norm() > 1e-12) {
        image_pair.cam2_from_cam1.translation =
            image_pair.cam2_from_cam1.translation.normalized();
      }

diff --git a/src/glomap/types.h b/src/glomap/types.h
@@ -1,20 +1,7 @@
 #pragma once

-#include "colmap/util/logging.h"
-
-#include <iostream>
-#include <limits>
-#include <string>
-#include <vector>
-
-#include <Eigen/Core>
-
 namespace glomap {

-constexpr double EPS = 1e-12;
-constexpr double HALF_PI = 3.141592653589793238462643383279502884L / 2;
-constexpr double TWO_PI = 2 * 3.141592653589793238462643383279502884L;
-
 struct InlierThresholdOptions {
  // Thresholds for 3D-2D matches
  double max_angle_error = 1.;           // in degree, for global positioning