cosmetics

limap/base/camera_view.cc

@@ -4,7 +4,7 @@
 namespace limap {
 
 CameraImage::CameraImage(py::dict dict) {
-  ASSIGN_PYDICT_ITEM(dict, cam_id, int)
+  ASSIGN_PYDICT_ITEM(dict, cam_id, int);
   pose = CameraPose(dict["pose"]);
 
   // load image name

limap/base/line_dists.h

@@ -183,7 +183,6 @@ double dist_innerseg(const LineType &l1, const LineType &l2) {
     return MAX_DIST;
   if (!get_innerseg<LineType>(l1, l2, l2_innerseg))
     return MAX_DIST;
-  // return dist_minpoint<Line3d>(l1_innerseg, l2_innerseg);
   return dist_endpoints_perpendicular<LineType>(l1_innerseg, l2_innerseg);
 }
 

limap/base/line_linker.cc

@@ -1,16 +1,40 @@
 #include "limap/base/line_linker.h"
 #include "limap/base/line_dists.h"
+#include "limap/_limap/helpers.h"
 #include <cmath>
 
 namespace limap {
 
+namespace {
+double get_multiplier(const double &score_th) {
+  // exp(- (val / sigma)^2 / 2.0) >= 0.5 <--> val <= 1.1774100 sigma
+  return 1.0 / sqrt(-log(score_th) * 2.0);
+}
+}
+
 double expscore(const double &val, const double &sigma) {
   return exp(-pow(val / sigma, 2) / 2.0);
 }
 
-double get_multiplier(const double &score_th) {
-  // exp(- (val / sigma)^2 / 2.0) >= 0.5 <--> val <= 1.1774100 sigma
-  return 1.0 / sqrt(-log(score_th) * 2.0);
+LineLinker2dConfig::LineLinker2dConfig() {}
+
+LineLinker2dConfig::LineLinker2dConfig(py::dict dict) {
+  ASSIGN_PYDICT_ITEM(dict, score_th, double);
+  ASSIGN_PYDICT_ITEM(dict, th_angle, double);
+  ASSIGN_PYDICT_ITEM(dict, th_overlap, double);
+  ASSIGN_PYDICT_ITEM(dict, th_smartoverlap, double);
+  ASSIGN_PYDICT_ITEM(dict, th_smartangle, double);
+  ASSIGN_PYDICT_ITEM(dict, th_perp, double);
+  ASSIGN_PYDICT_ITEM(dict, th_innerseg, double);
+  ASSIGN_PYDICT_ITEM(dict, use_angle, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_overlap, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_smartangle, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_perp, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_innerseg, bool);
+}
+
+LineLinker2dConfig::multipler() const {
+  return get_multiplier(score_th);
 }
 
 double LineLinker2d::compute_score_angle(const Line2d &l1,
@@ -135,6 +159,29 @@ double LineLinker2d::compute_score(const Line2d &l1, const Line2d &l2) const {
   return score;
 }
 
+LineLinker3dConfig::LineLinker3dConfig() {}
+
+LineLinker3dConfig::LineLinker3dConfig(py::dict dict) {
+  ASSIGN_PYDICT_ITEM(dict, score_th, double);
+  ASSIGN_PYDICT_ITEM(dict, th_angle, double);
+  ASSIGN_PYDICT_ITEM(dict, th_overlap, double);
+  ASSIGN_PYDICT_ITEM(dict, th_smartoverlap, double);
+  ASSIGN_PYDICT_ITEM(dict, th_smartangle, double);
+  ASSIGN_PYDICT_ITEM(dict, th_perp, double);
+  ASSIGN_PYDICT_ITEM(dict, th_innerseg, double);
+  ASSIGN_PYDICT_ITEM(dict, th_scaleinv, double);
+  ASSIGN_PYDICT_ITEM(dict, use_angle, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_overlap, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_smartangle, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_perp, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_innerseg, bool);
+  ASSIGN_PYDICT_ITEM(dict, use_scaleinv, bool);
+}
+
+LineLinker3dConfig::multiplier() const {
+  return get_multiplier(score_th);
+}
+
 double LineLinker3d::compute_score_angle(const Line3d &l1,
                                          const Line3d &l2) const {
   double angle = compute_angle<Line3d>(l1, l2);

limap/base/line_linker.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "limap/_limap/helpers.h"
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 
@@ -14,29 +13,15 @@ namespace py = pybind11;
 namespace limap {
 
 double expscore(const double &val, const double &sigma);
-double get_multiplier(const double &score_th);
 
 class LineLinker2dConfig {
 public:
-  LineLinker2dConfig() {}
-  LineLinker2dConfig(py::dict dict) {
-    ASSIGN_PYDICT_ITEM(dict, score_th, double)
-    ASSIGN_PYDICT_ITEM(dict, th_angle, double)
-    ASSIGN_PYDICT_ITEM(dict, th_overlap, double)
-    ASSIGN_PYDICT_ITEM(dict, th_smartoverlap, double)
-    ASSIGN_PYDICT_ITEM(dict, th_smartangle, double)
-    ASSIGN_PYDICT_ITEM(dict, th_perp, double)
-    ASSIGN_PYDICT_ITEM(dict, th_innerseg, double)
-    ASSIGN_PYDICT_ITEM(dict, use_angle, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_overlap, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_smartangle, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_perp, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_innerseg, bool)
-  }
+  LineLinker2dConfig();
+  LineLinker2dConfig(py::dict dict);
 
   // for scoring
   double score_th = 0.5; // only score that is higher than 0.5 survives the test
-  double multiplier() const { return get_multiplier(score_th); }
+  double multiplier() const;
 
   // angle
   double th_angle = 8.0;
@@ -93,27 +78,12 @@ class LineLinker2d {
 
 class LineLinker3dConfig {
 public:
-  LineLinker3dConfig() {}
-  LineLinker3dConfig(py::dict dict) {
-    ASSIGN_PYDICT_ITEM(dict, score_th, double)
-    ASSIGN_PYDICT_ITEM(dict, th_angle, double)
-    ASSIGN_PYDICT_ITEM(dict, th_overlap, double)
-    ASSIGN_PYDICT_ITEM(dict, th_smartoverlap, double)
-    ASSIGN_PYDICT_ITEM(dict, th_smartangle, double)
-    ASSIGN_PYDICT_ITEM(dict, th_perp, double)
-    ASSIGN_PYDICT_ITEM(dict, th_innerseg, double)
-    ASSIGN_PYDICT_ITEM(dict, th_scaleinv, double)
-    ASSIGN_PYDICT_ITEM(dict, use_angle, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_overlap, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_smartangle, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_perp, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_innerseg, bool)
-    ASSIGN_PYDICT_ITEM(dict, use_scaleinv, bool)
-  }
+  LineLinker3dConfig();
+  LineLinker3dConfig(py::dict dict);
 
   // for scoring
   double score_th = 0.5; // only score that is higher than 0.5 survives the test
-  double multiplier() const { return get_multiplier(score_th); }
+  double multiplier() const;
 
   // angle
   double th_angle = 10.0;

limap/base/linetrack.cc

@@ -53,10 +53,10 @@ LineTrack::LineTrack(py::dict dict) {
   else
     throw std::runtime_error("Error! Key \"line\" does not exist!");
   line = Line3d(py_line);
-  ASSIGN_PYDICT_ITEM(dict, image_id_list, std::vector<int>)
-  ASSIGN_PYDICT_ITEM(dict, line_id_list, std::vector<int>)
-  ASSIGN_PYDICT_ITEM(dict, node_id_list, std::vector<int>)
-  ASSIGN_PYDICT_ITEM(dict, score_list, std::vector<double>)
+  ASSIGN_PYDICT_ITEM(dict, image_id_list, std::vector<int>);
+  ASSIGN_PYDICT_ITEM(dict, line_id_list, std::vector<int>);
+  ASSIGN_PYDICT_ITEM(dict, node_id_list, std::vector<int>);
+  ASSIGN_PYDICT_ITEM(dict, score_list, std::vector<double>);
   std::vector<Eigen::MatrixXd> py_line2d_list, py_line3d_list;
   if (dict.contains("line2d_list")) {
     py_line2d_list = dict["line2d_list"].cast<std::vector<Eigen::MatrixXd>>();
@@ -68,7 +68,7 @@ LineTrack::LineTrack(py::dict dict) {
     for (auto it = py_line3d_list.begin(); it != py_line3d_list.end(); ++it)
       line3d_list.push_back(Line3d(*it));
   }
-  ASSIGN_PYDICT_ITEM(dict, active, bool)
+  ASSIGN_PYDICT_ITEM(dict, active, bool);
 }
 
 std::vector<int> LineTrack::GetSortedImageIds() const {

limap/base/pointtrack.cc

@@ -28,10 +28,10 @@ py::dict PointTrack::as_dict() const {
 }
 
 PointTrack::PointTrack(py::dict dict) {
-  ASSIGN_PYDICT_ITEM(dict, p, V3D)
-  ASSIGN_PYDICT_ITEM(dict, image_id_list, std::vector<int>)
-  ASSIGN_PYDICT_ITEM(dict, p2d_id_list, std::vector<int>)
-  ASSIGN_PYDICT_ITEM(dict, p2d_list, std::vector<V2D>)
+  ASSIGN_PYDICT_ITEM(dict, p, V3D);
+  ASSIGN_PYDICT_ITEM(dict, image_id_list, std::vector<int>);
+  ASSIGN_PYDICT_ITEM(dict, p2d_id_list, std::vector<int>);
+  ASSIGN_PYDICT_ITEM(dict, p2d_list, std::vector<V2D>);
 }
 
 } // namespace limap

limap/base/pointtrack.h

@@ -19,8 +19,10 @@ template <typename PTYPE> struct Feature2dWith3dIndex {
   Feature2dWith3dIndex(PTYPE p_, int point3D_id_ = -1)
       : p(p_), point3D_id(point3D_id_) {}
   Feature2dWith3dIndex(py::dict dict){
-      ASSIGN_PYDICT_ITEM(dict, p, PTYPE)
-          ASSIGN_PYDICT_ITEM(dict, point3D_id, int)} py::dict as_dict() const {
+      ASSIGN_PYDICT_ITEM(dict, p, PTYPE);
+      ASSIGN_PYDICT_ITEM(dict, point3D_id, int);
+  } 
+  py::dict as_dict() const {
     py::dict output;
     output["p"] = p;
     output["point3D_id"] = point3D_id;

limap/ceresbase/ceres_extensions.h

@@ -31,20 +31,20 @@ class PyLossFunction : public ceres::LossFunction {
 
 inline void AssignSolverOptionsFromDict(ceres::Solver::Options &solver_options,
                                         py::dict dict) {
-  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, function_tolerance, double)
-  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, gradient_tolerance, double)
+  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, function_tolerance, double);
+  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, gradient_tolerance, double);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, parameter_tolerance,
-                               double)
+                               double);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict,
-                               minimizer_progress_to_stdout, bool)
+                               minimizer_progress_to_stdout, bool);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict,
-                               max_linear_solver_iterations, int)
-  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, max_num_iterations, int)
+                               max_linear_solver_iterations, int);
+  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, max_num_iterations, int);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict,
-                               max_num_consecutive_invalid_steps, int)
+                               max_num_consecutive_invalid_steps, int);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict,
-                               max_consecutive_nonmonotonic_steps, int)
-  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, use_inner_iterations, bool)
+                               max_consecutive_nonmonotonic_steps, int);
+  ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, use_inner_iterations, bool);
   ASSIGN_PYDICT_ITEM_TO_MEMBER(solver_options, dict, inner_iteration_tolerance,
-                               double)
+                               double);
 }

limap/ceresbase/interpolation.h

@@ -40,9 +40,9 @@ enum class InterpolatorType {
 struct InterpolationConfig {
   InterpolationConfig() {}
   InterpolationConfig(py::dict dict) {
-    ASSIGN_PYDICT_ITEM(dict, l2_normalize, bool)
-    ASSIGN_PYDICT_ITEM(dict, ncc_normalize, bool)
-    ASSIGN_PYDICT_ITEM(dict, fill_channel_differences, bool)
+    ASSIGN_PYDICT_ITEM(dict, l2_normalize, bool);
+    ASSIGN_PYDICT_ITEM(dict, ncc_normalize, bool);
+    ASSIGN_PYDICT_ITEM(dict, fill_channel_differences, bool);
     ASSIGN_PYDICT_ITEM(dict, nodes,
                        SINGLE_ARG(std::vector<std::array<double, 2>>));
     if (dict.contains("type")) {

limap/optimize/global_pl_association/global_associator.h

@@ -24,20 +24,20 @@ class GlobalAssociatorConfig : public hybrid_bundle_adjustment::HybridBAConfig {
   GlobalAssociatorConfig(py::dict dict)
       : hybrid_bundle_adjustment::HybridBAConfig(dict) {
     InitConfig();
-    ASSIGN_PYDICT_ITEM(dict, constant_vp, bool)
-    ASSIGN_PYDICT_ITEM(dict, th_angle_lineline, double)
-    ASSIGN_PYDICT_ITEM(dict, th_count_lineline, int)
-    ASSIGN_PYDICT_ITEM(dict, lw_pointline_association, double)
-    ASSIGN_PYDICT_ITEM(dict, th_pixel, double)
-    ASSIGN_PYDICT_ITEM(dict, th_weight_pointline, double)
-    ASSIGN_PYDICT_ITEM(dict, lw_vpline_association, double)
-    ASSIGN_PYDICT_ITEM(dict, th_count_vpline, int)
-    ASSIGN_PYDICT_ITEM(dict, lw_vp_orthogonality, double)
-    ASSIGN_PYDICT_ITEM(dict, th_angle_orthogonality, double)
-    ASSIGN_PYDICT_ITEM(dict, lw_vp_collinearity, double)
-    ASSIGN_PYDICT_ITEM(dict, th_angle_collinearity, double)
-    ASSIGN_PYDICT_ITEM(dict, th_hard_pl_dist3d, double)
-    ASSIGN_PYDICT_ITEM(dict, th_hard_vpline_angle3d, double)
+    ASSIGN_PYDICT_ITEM(dict, constant_vp, bool);
+    ASSIGN_PYDICT_ITEM(dict, th_angle_lineline, double);
+    ASSIGN_PYDICT_ITEM(dict, th_count_lineline, int);
+    ASSIGN_PYDICT_ITEM(dict, lw_pointline_association, double);
+    ASSIGN_PYDICT_ITEM(dict, th_pixel, double);
+    ASSIGN_PYDICT_ITEM(dict, th_weight_pointline, double);
+    ASSIGN_PYDICT_ITEM(dict, lw_vpline_association, double);
+    ASSIGN_PYDICT_ITEM(dict, th_count_vpline, int);
+    ASSIGN_PYDICT_ITEM(dict, lw_vp_orthogonality, double);
+    ASSIGN_PYDICT_ITEM(dict, th_angle_orthogonality, double);
+    ASSIGN_PYDICT_ITEM(dict, lw_vp_collinearity, double);
+    ASSIGN_PYDICT_ITEM(dict, th_angle_collinearity, double);
+    ASSIGN_PYDICT_ITEM(dict, th_hard_pl_dist3d, double);
+    ASSIGN_PYDICT_ITEM(dict, th_hard_vpline_angle3d, double);
   }
 
   // association config

limap/structures/pl_bipartite.cc

@@ -48,8 +48,8 @@ PL_Bipartite2d::PL_Bipartite2d(py::dict dict) {
 
   // load connections
 #define TMPMAPTYPE std::map<int, std::set<int>>
-  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE)
-  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE);
+  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 }
 
@@ -262,8 +262,8 @@ PL_Bipartite3d::PL_Bipartite3d(py::dict dict) {
 
   // load connections
 #define TMPMAPTYPE std::map<int, std::set<int>>
-  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE)
-  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE);
+  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 }
 

limap/structures/pl_bipartite.h

@@ -22,9 +22,9 @@ typedef Junction<PointTrack> Junction3d;
 struct PL_Bipartite2dConfig {
   PL_Bipartite2dConfig() {}
   PL_Bipartite2dConfig(py::dict dict) {
-    ASSIGN_PYDICT_ITEM(dict, threshold_intersection, double)
-    ASSIGN_PYDICT_ITEM(dict, threshold_merge_junctions, double)
-    ASSIGN_PYDICT_ITEM(dict, threshold_keypoints, double)
+    ASSIGN_PYDICT_ITEM(dict, threshold_intersection, double);
+    ASSIGN_PYDICT_ITEM(dict, threshold_merge_junctions, double);
+    ASSIGN_PYDICT_ITEM(dict, threshold_keypoints, double);
   }
 
   double threshold_keypoints = 2.0;       // in pixels

limap/structures/pl_bipartite_base.cc

@@ -23,14 +23,14 @@ py::dict PL_Bipartite<PTYPE, LTYPE>::as_dict() const {
 template <typename PTYPE, typename LTYPE>
 PL_Bipartite<PTYPE, LTYPE>::PL_Bipartite(py::dict dict) {
 #define TMPMAPTYPE std::map<int, PTYPE>
-  ASSIGN_PYDICT_ITEM(dict, points_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, points_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 #define TMPMAPTYPE std::map<int, LTYPE>
-  ASSIGN_PYDICT_ITEM(dict, lines_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, lines_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 #define TMPMAPTYPE std::map<int, std::set<int>>
-  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE)
-  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE);
+  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 }
 

limap/structures/vpline_bipartite.cc

@@ -44,8 +44,8 @@ VPLine_Bipartite2d::VPLine_Bipartite2d(py::dict dict) {
 
   // load connections
 #define TMPMAPTYPE std::map<int, std::set<int>>
-  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE)
-  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE);
+  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 }
 
@@ -89,8 +89,8 @@ VPLine_Bipartite3d::VPLine_Bipartite3d(py::dict dict) {
 
   // load connections
 #define TMPMAPTYPE std::map<int, std::set<int>>
-  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE)
-  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE)
+  ASSIGN_PYDICT_ITEM(dict, np2l_, TMPMAPTYPE);
+  ASSIGN_PYDICT_ITEM(dict, nl2p_, TMPMAPTYPE);
 #undef TMPMAPTYPE
 }