Fix static code analysis warnings

src/base/camera_models.h

@@ -1136,14 +1136,14 @@ void FOVCameraModel::ImageToWorld(const T* params, const T x, const T y, T* u,
 }
 
 template <typename T>
-void FOVCameraModel::Distortion(const T* extra_params, const T uu, const T vv,
-                                T* u, T* v) {
+void FOVCameraModel::Distortion(const T* extra_params, const T u, const T v,
+                                T* du, T* dv) {
   const T omega = extra_params[0];
 
   // Chosen arbitrarily.
   const T kEpsilon = T(1e-4);
 
-  const T radius2 = uu * uu + vv * vv;
+  const T radius2 = u * u + v * v;
   const T omega2 = omega * omega;
 
   T factor;
@@ -1170,19 +1170,19 @@ void FOVCameraModel::Distortion(const T* extra_params, const T uu, const T vv,
     factor = numerator / (radius * omega);
   }
 
-  *u = uu * factor;
-  *v = vv * factor;
+  *du = u * factor;
+  *dv = v * factor;
 }
 
 template <typename T>
-void FOVCameraModel::Undistortion(const T* extra_params, const T uu, const T vv,
-                                  T* u, T* v) {
+void FOVCameraModel::Undistortion(const T* extra_params, const T u, const T v,
+                                  T* du, T* dv) {
   T omega = extra_params[0];
 
   // Chosen arbitrarily.
   const T kEpsilon = T(1e-4);
 
-  const T radius2 = uu * uu + vv * vv;
+  const T radius2 = u * u + v * v;
   const T omega2 = omega * omega;
 
   T factor;
@@ -1207,8 +1207,8 @@ void FOVCameraModel::Undistortion(const T* extra_params, const T uu, const T vv,
     factor = numerator / (radius * T(2) * ceres::tan(omega / T(2)));
   }
 
-  *u = uu * factor;
-  *v = vv * factor;
+  *du = u * factor;
+  *dv = v * factor;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

src/base/cost_functions.h

@@ -31,7 +31,7 @@ class BundleAdjustmentCostFunction {
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-  BundleAdjustmentCostFunction(const Eigen::Vector2d& point2D)
+  explicit BundleAdjustmentCostFunction(const Eigen::Vector2d& point2D)
       : point2D_(point2D) {}
 
   static ceres::CostFunction* Create(const Eigen::Vector2d& point2D) {
@@ -138,7 +138,7 @@ class RigBundleAdjustmentCostFunction {
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-  RigBundleAdjustmentCostFunction(const Eigen::Vector2d& point2D)
+  explicit RigBundleAdjustmentCostFunction(const Eigen::Vector2d& point2D)
       : point2D_(point2D) {}
 
   static ceres::CostFunction* Create(const Eigen::Vector2d& point2D) {
@@ -233,8 +233,9 @@ class RelativePoseCostFunction {
     const Eigen::Matrix<T, 3, 1> Ex1 = E * x1_h;
     const Eigen::Matrix<T, 3, 1> Etx2 = E.transpose() * x2_h;
     const T x2tEx1 = x2_h.transpose() * Ex1;
-    residuals[0] = x2tEx1 * x2tEx1 / (Ex1(0) * Ex1(0) + Ex1(1) * Ex1(1) +
-                                      Etx2(0) * Etx2(0) + Etx2(1) * Etx2(1));
+    residuals[0] = x2tEx1 * x2tEx1 /
+                   (Ex1(0) * Ex1(0) + Ex1(1) * Ex1(1) + Etx2(0) * Etx2(0) +
+                    Etx2(1) * Etx2(1));
 
     return true;
   }

src/base/database.cc

@@ -465,9 +465,8 @@ void Database::ReadInlierMatchesGraph(
   image_pairs->reserve(num_inlier_matches);
   num_inliers->reserve(num_inlier_matches);
 
-  int rc;
-  while ((rc = SQLITE3_CALL(sqlite3_step(
-              sql_stmt_read_inlier_matches_graph_))) == SQLITE_ROW) {
+  while (SQLITE3_CALL(sqlite3_step(sql_stmt_read_inlier_matches_graph_)) ==
+         SQLITE_ROW) {
     image_t image_id1;
     image_t image_id2;
     const image_pair_t pair_id = static_cast<image_pair_t>(

src/base/database.h

@@ -49,7 +49,7 @@ class Database {
   const static size_t kMaxNumImages;
 
   Database();
-  Database(const std::string& path);
+  explicit Database(const std::string& path);
   ~Database();
 
   // Open and close database. The same database should not be opened
@@ -276,7 +276,7 @@ class Database {
 // destruction, respectively.
 class DatabaseTransaction {
  public:
-  DatabaseTransaction(Database* database);
+  explicit DatabaseTransaction(Database* database);
   ~DatabaseTransaction();
 
  private:

src/base/database_cache.cc

@@ -76,7 +76,7 @@ void DatabaseCache::Load(const Database& database, const size_t min_num_matches,
             << std::endl;
 
   auto UseInlierMatchesCheck = [min_num_matches, ignore_watermarks](
-      const TwoViewGeometry& two_view_geometry) {
+                                   const TwoViewGeometry& two_view_geometry) {
     return static_cast<size_t>(two_view_geometry.inlier_matches.size()) >=
                min_num_matches &&
            (!ignore_watermarks ||
@@ -162,8 +162,8 @@ void DatabaseCache::Load(const Database& database, const size_t min_num_matches,
       image_t image_id2;
       Database::PairIdToImagePair(image_pair_ids[i], &image_id1, &image_id2);
       if (image_ids.count(image_id1) > 0 && image_ids.count(image_id2) > 0) {
-         scene_graph_.AddCorrespondences(image_id1, image_id2,
-                                         two_view_geometries[i].inlier_matches);
+        scene_graph_.AddCorrespondences(image_id1, image_id2,
+                                        two_view_geometries[i].inlier_matches);
       } else {
         num_ignored_image_pairs += 1;
       }

src/base/feature.cc

@@ -79,8 +79,9 @@ FeatureDescriptors ExtractTopScaleDescriptors(
     }
 
     std::partial_sort(scales.begin(), scales.begin() + num_features,
-                      scales.end(), [](const std::pair<size_t, float> scale1,
-                                       const std::pair<size_t, float> scale2) {
+                      scales.end(),
+                      [](const std::pair<size_t, float> scale1,
+                         const std::pair<size_t, float> scale2) {
                         return scale1.second > scale2.second;
                       });
 

src/base/feature_extraction.h

@@ -102,7 +102,7 @@ class ImageReader {
     void Check() const;
   };
 
-  ImageReader(const Options& options);
+  explicit ImageReader(const Options& options);
 
   bool Next(Image* image, Bitmap* bitmap);
   size_t NextIndex() const;

src/base/feature_matching.cc

@@ -1599,8 +1599,9 @@ void MatchGuidedSiftFeaturesCPU(const SiftMatchOptions& match_options,
       const Eigen::Vector3f Fx1 = F * p1;
       const Eigen::Vector3f Ftx2 = F.transpose() * p2;
       const float x2tFx1 = p2.transpose() * Fx1;
-      return x2tFx1 * x2tFx1 / (Fx1(0) * Fx1(0) + Fx1(1) * Fx1(1) +
-                                Ftx2(0) * Ftx2(0) + Ftx2(1) * Ftx2(1)) >
+      return x2tFx1 * x2tFx1 /
+                 (Fx1(0) * Fx1(0) + Fx1(1) * Fx1(1) + Ftx2(0) * Ftx2(0) +
+                  Ftx2(1) * Ftx2(1)) >
              max_residual;
     };
   } else if (two_view_geometry->config == TwoViewGeometry::PLANAR ||

src/base/feature_matching_test.cc

@@ -225,9 +225,9 @@ BOOST_AUTO_TEST_CASE(TestMatchSiftFeaturesCPUvsGPU) {
       BOOST_CHECK(CreateSiftGPUMatcher(SiftMatchOptions(), &sift_match_gpu));
 
       auto TestCPUvsGPU = [&sift_match_gpu](
-          const SiftMatchOptions& options,
-          const FeatureDescriptors& descriptors1,
-          const FeatureDescriptors& descriptors2) {
+                              const SiftMatchOptions& options,
+                              const FeatureDescriptors& descriptors1,
+                              const FeatureDescriptors& descriptors2) {
         FeatureMatches matches_cpu;
         FeatureMatches matches_gpu;
 

src/base/gps.cc

@@ -37,7 +37,6 @@ GPSTransform::GPSTransform(const int ellipsoid) {
       b_ = std::numeric_limits<double>::quiet_NaN();
       f_ = std::numeric_limits<double>::quiet_NaN();
       throw std::invalid_argument("Ellipsoid not defined");
-      break;
   }
 
   e2_ = (a_ * a_ - b_ * b_) / (a_ * a_);
@@ -83,23 +82,22 @@ std::vector<Eigen::Vector3d> GPSTransform::XYZToEll(
     const double kEps = 1e-12;
 
     // Latitude
-    double lat0 = atan2(z, sqrt(xx + yy));
-    double lat = 100;
+    double lat = atan2(z, sqrt(xx + yy));
     double alt;
 
     for (size_t j = 0; j < 100; ++j) {
-      const double sin_lat0 = sin(lat0);
+      const double sin_lat0 = sin(lat);
       const double N = a_ / sqrt(1 - e2_ * sin_lat0 * sin_lat0);
-      alt = sqrt(xx + yy) / cos(lat0) - N;
-      lat = lat0;
-      lat0 = atan((z / sqrt(xx + yy)) * 1 / (1 - e2_ * N / (N + alt)));
+      alt = sqrt(xx + yy) / cos(lat) - N;
+      const double prev_lat = lat;
+      lat = atan((z / sqrt(xx + yy)) * 1 / (1 - e2_ * N / (N + alt)));
 
-      if (std::abs(lat - lat0) < kEps) {
+      if (std::abs(prev_lat - lat) < kEps) {
         break;
       }
     }
 
-    ell[i](0) = RadToDeg(lat0);
+    ell[i](0) = RadToDeg(lat);
 
     // Longitude
     ell[i](1) = RadToDeg(atan2(y, x));

src/base/gps.h

@@ -32,7 +32,7 @@ class GPSTransform {
  public:
   enum ELLIPSOID { GRS80, WGS84 };
 
-  GPSTransform(const int ellipsoid = GRS80);
+  explicit GPSTransform(const int ellipsoid = GRS80);
 
   std::vector<Eigen::Vector3d> EllToXYZ(
       const std::vector<Eigen::Vector3d>& ell) const;

src/base/image.cc

@@ -26,6 +26,8 @@ static const double kNaN = std::numeric_limits<double>::quiet_NaN();
 
 }  // namespace
 
+const int Image::kNumPoint3DVisibilityPyramidLevels = 6;
+
 Image::Image()
     : image_id_(kInvalidImageId),
       name_(""),

src/base/image.h

@@ -39,9 +39,6 @@ class Image {
  public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-  // The number of levels in the 3D point multi-resolution visibility pyramid.
-  static const int kNumPoint3DVisibilityPyramidLevels = 6;
-
   Image();
 
   // Setup / tear down the image and necessary internal data structures before
@@ -179,6 +176,9 @@ class Image {
   // Extract the viewing direction of the image.
   Eigen::Vector3d ViewingDirection() const;
 
+  // The number of levels in the 3D point multi-resolution visibility pyramid.
+  static const int kNumPoint3DVisibilityPyramidLevels;
+
  private:
   // Identifier of the image, if not specified `kInvalidImageId`.
   image_t image_id_;
@@ -335,9 +335,7 @@ class Point2D& Image::Point2D(const point2D_t point2D_idx) {
   return points2D_.at(point2D_idx);
 }
 
-const std::vector<class Point2D>& Image::Points2D() const {
-  return points2D_;
-}
+const std::vector<class Point2D>& Image::Points2D() const { return points2D_; }
 
 bool Image::IsPoint3DVisible(const point2D_t point2D_idx) const {
   return num_correspondences_have_point3D_.at(point2D_idx) > 0;

src/base/image_test.cc

@@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(TestPoint3DVisibilityScore) {
   camera.SetHeight(4);
   image.SetUp(camera);
   Eigen::Matrix<size_t, Eigen::Dynamic, 1> scores(
-      static_cast<int>(image.kNumPoint3DVisibilityPyramidLevels), 1);
+      image.kNumPoint3DVisibilityPyramidLevels, 1);
   for (size_t i = 1; i <= image.kNumPoint3DVisibilityPyramidLevels; ++i) {
     scores(i - 1) = (1 << i) * (1 << i);
   }

src/base/reconstruction.h

@@ -66,10 +66,10 @@ class Reconstruction {
       const image_t image_id1, const image_t image_id2) const;
 
   // Get reference to all objects.
-  inline const EIGEN_STL_UMAP(camera_t, class Camera)& Cameras() const;
-  inline const EIGEN_STL_UMAP(image_t, class Image)& Images() const;
+  inline const EIGEN_STL_UMAP(camera_t, class Camera) & Cameras() const;
+  inline const EIGEN_STL_UMAP(image_t, class Image) & Images() const;
   inline const std::vector<image_t>& RegImageIds() const;
-  inline const EIGEN_STL_UMAP(point3D_t, class Point3D)& Points3D() const;
+  inline const EIGEN_STL_UMAP(point3D_t, class Point3D) & Points3D() const;
   inline const std::unordered_map<image_pair_t, std::pair<size_t, size_t>>&
   ImagePairs() const;
 
@@ -351,19 +351,19 @@ std::pair<size_t, size_t>& Reconstruction::ImagePair(const image_t image_id1,
   return image_pairs_.at(pair_id);
 }
 
-const EIGEN_STL_UMAP(camera_t, Camera)& Reconstruction::Cameras() const {
+const EIGEN_STL_UMAP(camera_t, Camera) & Reconstruction::Cameras() const {
   return cameras_;
 }
 
-const EIGEN_STL_UMAP(image_t, class Image)& Reconstruction::Images() const {
+const EIGEN_STL_UMAP(image_t, class Image) & Reconstruction::Images() const {
   return images_;
 }
 
 const std::vector<image_t>& Reconstruction::RegImageIds() const {
   return reg_image_ids_;
 }
 
-const EIGEN_STL_UMAP(point3D_t, Point3D)& Reconstruction::Points3D() const {
+const EIGEN_STL_UMAP(point3D_t, Point3D) & Reconstruction::Points3D() const {
   return points3D_;
 }
 

src/base/similarity_transform.h

@@ -34,9 +34,9 @@ class SimilarityTransform3 {
 
   SimilarityTransform3();
 
-  SimilarityTransform3(const Eigen::Matrix3x4d& matrix);
+  explicit SimilarityTransform3(const Eigen::Matrix3x4d& matrix);
 
-  SimilarityTransform3(
+  explicit SimilarityTransform3(
       const Eigen::Transform<double, 3, Eigen::Affine>& transform);
 
   SimilarityTransform3(const double scale, const Eigen::Vector4d& qvec,

src/estimators/epnp.cc

@@ -306,8 +306,8 @@ void EPnPEstimator::FindBetasApprox3(const Eigen::Matrix<double, 6, 10>& L6x10,
 }
 
 void EPnPEstimator::RunGaussNewton(const Eigen::Matrix<double, 6, 10>& L6x10,
-                                const Eigen::Matrix<double, 6, 1>& rho,
-                                Eigen::Vector4d* betas) {
+                                   const Eigen::Matrix<double, 6, 1>& rho,
+                                   Eigen::Vector4d* betas) {
   Eigen::Matrix<double, 6, 4> A;
   Eigen::Matrix<double, 6, 1> b;
 

src/estimators/fundamental_matrix.cc

@@ -92,7 +92,6 @@ FundamentalMatrixSevenPointEstimator::Estimate(
               f1(8) * (f2(0) * f2(4) - f2(1) * f2(3));
   coeffs(3) = f2(0) * t3 - f2(1) * t4 + f2(2) * t5;
 
-
   Eigen::VectorXd roots_real;
   Eigen::VectorXd roots_imag;
   if (!FindPolynomialRootsCompanionMatrix(coeffs, &roots_real, &roots_imag)) {

src/estimators/gp3p_test.cc

@@ -66,10 +66,10 @@ BOOST_AUTO_TEST_CASE(Estimate) {
       for (size_t i = 0; i < kNumTforms; ++i) {
         Eigen::Vector4d rel_qvec;
         Eigen::Vector3d rel_tvec;
-        ComputeRelativePose(
-            orig_tforms[kRefTform].Rotation(),
-            orig_tforms[kRefTform].Translation(), orig_tforms[i].Rotation(),
-            orig_tforms[i].Translation(), &rel_qvec, &rel_tvec);
+        ComputeRelativePose(orig_tforms[kRefTform].Rotation(),
+                            orig_tforms[kRefTform].Translation(),
+                            orig_tforms[i].Rotation(),
+                            orig_tforms[i].Translation(), &rel_qvec, &rel_tvec);
         rel_tforms[i] = ComposeProjectionMatrix(rel_qvec, rel_tvec);
       }
 

src/estimators/p3p.cc

@@ -113,10 +113,11 @@ std::vector<P3PEstimator::M_t> P3PEstimator::Estimate(
     const double b0 =
         ((1 - a - b) * x2 + (a - 1) * q * x - a + b + 1) *
         (r3 * (a2 + b2 - 2 * a - 2 * b + (2 - r2) * a * b + 1) * x3 +
-         r2 * (p + p * a2 - 2 * r * q * a * b + 2 * r * q * b - 2 * r * q -
-               2 * p * a - 2 * p * b + p * r2 * b + 4 * r * q * a +
-               q * r3 * a * b - 2 * r * q * a2 + 2 * p * a * b + p * b2 -
-               r2 * p * b2) *
+         r2 *
+             (p + p * a2 - 2 * r * q * a * b + 2 * r * q * b - 2 * r * q -
+              2 * p * a - 2 * p * b + p * r2 * b + 4 * r * q * a +
+              q * r3 * a * b - 2 * r * q * a2 + 2 * p * a * b + p * b2 -
+              r2 * p * b2) *
              x2 +
          (r5 * (b2 - a * b) - r4 * p * q * b +
           r3 * (q2 - 4 * a - 2 * q2 * a + q2 * a2 + 2 * a2 - 2 * b2 + 2) +

src/estimators/utils.cc

@@ -109,8 +109,9 @@ void ComputeSquaredSampsonError(const std::vector<Eigen::Vector2d>& points1,
     const double x2tEx1 = x2_0 * Ex1_0 + x2_1 * Ex1_1 + Ex1_2;
 
     // Sampson distance
-    (*residuals)[i] = x2tEx1 * x2tEx1 / (Ex1_0 * Ex1_0 + Ex1_1 * Ex1_1 +
-                                         Etx2_0 * Etx2_0 + Etx2_1 * Etx2_1);
+    (*residuals)[i] =
+        x2tEx1 * x2tEx1 /
+        (Ex1_0 * Ex1_0 + Ex1_1 * Ex1_1 + Etx2_0 * Etx2_0 + Etx2_1 * Etx2_1);
   }
 }
 

src/exe/dense_fuser.cc

@@ -26,7 +26,6 @@ int main(int argc, char* argv[]) {
   std::string input_type;
   std::string workspace_format;
   std::string output_path;
-  std::string config_path;
 
   OptionManager options;
   options.AddDenseMapperOptions();