Rename frame -> scan everywhere

Author: contagon

config/25.10.08_short_verify.yaml

@@ -1,6 +1,6 @@
 pipelines:
   - pipeline: form
-    name: 4_docs_match_estimates
+    name: frame_to_scan
 
 datasets:
   # ncd20

form/feature/factor.hpp

@@ -73,8 +73,8 @@ struct PlanePoint {
 
   /// @brief Evaluate the residual given two poses
   ///
-  /// @param Ti The pose of the first frame
-  /// @param Tj The pose of the second frame
+  /// @param Ti The pose of the first scan
+  /// @param Tj The pose of the second scan
   /// @param residual_D_Ti Optional Jacobian of the residual w.r.t. Ti
   /// @param residual_D_Tj Optional Jacobian of the residual w.r.t. Tj
   /// @return The residual vector
@@ -118,8 +118,8 @@ struct PointPoint {
 
   /// @brief Evaluate the residual given two poses
   ///
-  /// @param Ti The pose of the first frame
-  /// @param Tj The pose of the second frame
+  /// @param Ti The pose of the first scan
+  /// @param Tj The pose of the second scan
   /// @param residual_D_Ti Optional Jacobian of the residual w.r.t. Ti
   /// @param residual_D_Tj Optional Jacobian of the residual w.r.t. Tj
   /// @return The residual vector
@@ -151,8 +151,8 @@ class FeatureFactor : public DenseFactor {
 
   /// @brief Evaluate the residual given two poses
   ///
-  /// @param Ti The pose of the first frame
-  /// @param Tj The pose of the second frame
+  /// @param Ti The pose of the first scan
+  /// @param Tj The pose of the second scan
   /// @param residual_D_Ti Optional Jacobian of the residual w.r.t. Ti
   /// @param residual_D_Tj Optional Jacobian of the residual w.r.t. Tj
   /// @return The residual vector

form/form.cpp

@@ -45,12 +45,12 @@ Estimator::register_scan(const std::vector<Eigen::Vector3f> &scan) noexcept {
   // ############################ Feature Extraction ############################ //
   //
   // ------------------------------ Initialization ------------------------------ //
-  // This needs to go first to get the frame index
+  // This needs to go first to get the scan index
   Pose3 prediction = m_constraints.predict_next();
-  auto [frame_idx, scan_constraints] = m_constraints.step(prediction);
+  auto [scan_idx, scan_constraints] = m_constraints.step(prediction);
 
   // ----------------------------- Extract Features ----------------------------- //
-  const auto keypoints = m_extractor.extract(scan, frame_idx);
+  const auto keypoints = m_extractor.extract(scan, scan_idx);
   const auto num_keypoints =
       std::apply([](auto &...kps) { return (kps.size() + ...); }, keypoints);
 
@@ -80,7 +80,7 @@ Estimator::register_scan(const std::vector<Eigen::Vector3f> &scan) noexcept {
 
     // ---------------------- Semi-Linearized Optimization ---------------------- //
     new_values = m_constraints.optimize(true);
-    const auto after = new_values.at<Pose3>(X(frame_idx));
+    const auto after = new_values.at<Pose3>(X(scan_idx));
     const auto diff = before.localCoordinates(after).norm();
     if (diff < m_params.matcher.new_pose_threshold) {
       break;
@@ -101,14 +101,14 @@ Estimator::register_scan(const std::vector<Eigen::Vector3f> &scan) noexcept {
   });
 
   // ---------------------------- Keyscan Selection ---------------------------- //
-  const auto connections = [&](FrameIndex frame) {
-    return m_constraints.num_recent_connections(frame, m_keyscanner.oldest_rf());
+  const auto connections = [&](ScanIndex i) {
+    return m_constraints.num_recent_connections(i, m_keyscanner.oldest_rf());
   };
-  auto marg_frames = m_keyscanner.step(frame_idx, num_keypoints, connections);
+  auto marg_scans = m_keyscanner.step(scan_idx, num_keypoints, connections);
 
   // ----------------------------- Marginalization ----------------------------- //
-  m_constraints.marginalize(marg_frames);
-  tuple::for_each(m_keypoint_map, [&](auto &map) { map.remove(marg_frames); });
+  m_constraints.marginalize(marg_scans);
+  tuple::for_each(m_keypoint_map, [&](auto &map) { map.remove(marg_scans); });
 
   return keypoints;
 }

form/mapping/keyscanner.cpp

@@ -26,64 +26,64 @@
 namespace form {
 
 // ------------------------- Doers ------------------------- //
-std::vector<FrameIndex>
-KeyScanner::step(FrameIndex idx, size_t size,
-                 std::function<size_t(FrameIndex)> connections) noexcept {
+std::vector<ScanIndex>
+KeyScanner::step(ScanIndex idx, size_t size,
+                 std::function<size_t(ScanIndex)> connections) noexcept {
   if (idx == 0) {
-    m_keyframes.push_back(Scan(idx, size));
+    m_keyscans.push_back(Scan(idx, size));
   } else {
-    m_recent_frames.push_back(Scan(idx, size));
+    m_recent_scans.push_back(Scan(idx, size));
   }
 
-  std::vector<FrameIndex> marg_results;
+  std::vector<ScanIndex> marg_results;
 
-  // First we handle recent frames
-  if (m_recent_frames.size() > m_params.max_num_recent_frames) {
-    const auto rf = m_recent_frames.front();
-    m_recent_frames.pop_front();
+  // First we handle recent scans
+  if (m_recent_scans.size() > m_params.max_num_recent_scans) {
+    const auto rf = m_recent_scans.front();
+    m_recent_scans.pop_front();
 
-    // If it's a keyframe, add it to the keyframe indices
+    // If it's a keyscan, add it to the keyscan indices
     auto ratio = static_cast<double>(connections(rf.idx)) /
-                 (static_cast<double>(rf.size * m_recent_frames.size()));
+                 (static_cast<double>(rf.size * m_recent_scans.size()));
 
     if (ratio > m_params.keyscan_match_ratio) {
-      m_keyframes.push_back(rf);
+      m_keyscans.push_back(rf);
     }
     // If not, we marginalize it out
     else {
       marg_results.push_back(rf.idx);
     }
   }
 
-  std::set<FrameIndex> finished_keyframes;
-  for (auto &kf : m_keyframes) {
-    // If this keyframe is connected to a recent frame, we don't marginalize it
+  std::set<ScanIndex> finished_keyscans;
+  for (auto &kf : m_keyscans) {
+    // If this keyscan is connected to a recent scan, we don't marginalize it
     if (connections(kf.idx) > 0) {
       kf.unused_count = 0;
     } else {
       ++kf.unused_count;
     }
 
-    // If this keyframe has been unused for too long, we marginalize it out
-    if (kf.unused_count > m_params.max_steps_unused_keyframe) {
+    // If this keyscan has been unused for too long, we marginalize it out
+    if (kf.unused_count > m_params.max_steps_unused_keyscan) {
       marg_results.push_back(kf.idx);
-      finished_keyframes.insert(kf.idx);
+      finished_keyscans.insert(kf.idx);
     }
   }
 
-  m_keyframes.erase(std::remove_if(m_keyframes.begin(), m_keyframes.end(),
-                                   [&](const Scan &f) {
-                                     return finished_keyframes.find(f.idx) !=
-                                            finished_keyframes.end();
-                                   }),
-                    m_keyframes.end());
+  m_keyscans.erase(std::remove_if(m_keyscans.begin(), m_keyscans.end(),
+                                  [&](const Scan &f) {
+                                    return finished_keyscans.find(f.idx) !=
+                                           finished_keyscans.end();
+                                  }),
+                   m_keyscans.end());
 
-  // Marginalize keyframe we have too many keyframes
+  // Marginalize keyscan we have too many keyscans
   // This should ideally never be reached in actuality
-  if ((m_params.max_num_keyframes > 0 &&
-       m_keyframes.size() > m_params.max_num_keyframes)) {
-    const auto kf = m_keyframes.front();
-    m_keyframes.pop_front();
+  if ((m_params.max_num_keyscans > 0 &&
+       m_keyscans.size() > m_params.max_num_keyscans)) {
+    const auto kf = m_keyscans.front();
+    m_keyscans.pop_front();
     marg_results.push_back(kf.idx);
   }
 

form/mapping/keyscanner.hpp

@@ -27,18 +27,18 @@
 
 namespace form {
 
-using FrameIndex = size_t;
+using ScanIndex = size_t;
 
 /// @brief Scan representation
 struct Scan {
-  /// @brief Index of the frame
+  /// @brief Index of the scan
   size_t idx;
 
-  /// @brief Number of times the frame has gone unconnected to recent frames
-  /// (only used if scan becomes a keyframe)
+  /// @brief Number of times the scan has gone unconnected to recent scans
+  /// (only used if scan becomes a keyscan)
   size_t unused_count = 0;
 
-  /// @brief Size of the frame (number of features)
+  /// @brief Size of the scan (number of features)
   size_t size = 0;
 
   /// @brief Constructor
@@ -47,18 +47,18 @@ struct Scan {
 
 /// @brief Keyscan manager
 ///
-/// Maintains a set of recent frames and keyframes, adding/removing them based on
-/// connectivity to recent frames
+/// Maintains a set of recent scans and keyscans, adding/removing them based on
+/// connectivity to recent scans
 class KeyScanner {
 public:
   /// @brief Parameters for the keyscanner
   struct Params {
-    /// @brief Maximum number of keyframes to keep
-    int64_t max_num_keyframes = 50;
-    /// @brief Maximum number of steps a keyframe can go unused before being removed
-    int64_t max_steps_unused_keyframe = 10;
-    /// @brief Maximum number of recent frames to keep
-    size_t max_num_recent_frames = 10;
+    /// @brief Maximum number of keyscans to keep
+    int64_t max_num_keyscans = 50;
+    /// @brief Maximum number of steps a keyscan can go unused before being removed
+    int64_t max_steps_unused_keyscan = 10;
+    /// @brief Maximum number of recent scans to keep
+    size_t max_num_recent_scans = 10;
     /// @brief Keyscan matching ratio
     double keyscan_match_ratio = 0.1;
   };
@@ -67,11 +67,11 @@ class KeyScanner {
   /// @brief Parameters
   Params m_params;
 
-  /// @brief Recent frames
-  std::deque<Scan> m_recent_frames;
+  /// @brief Recent scans
+  std::deque<Scan> m_recent_scans;
 
-  /// @brief Key frames
-  std::deque<Scan> m_keyframes;
+  /// @brief Key scans
+  std::deque<Scan> m_keyscans;
 
 public:
   /// @brief Default constructor
@@ -81,36 +81,35 @@ class KeyScanner {
   KeyScanner(const Params &params) : m_params(params) {}
 
   // ------------------------- Doers ------------------------- //
-  /// @brief Update the keyscanner with a new frame.
+  /// @brief Update the keyscanner with a new scan.
   ///
-  /// Will perform all the transitions from recent frame to keyframe and
+  /// Will perform all the transitions from recent scan to keyscan and
   /// marginalization checks.
   ///
-  /// @param idx Index of the new frame
-  /// @param size Size of the new frame (number of features)
-  /// @param connections Function that returns the number of connections a frame
-  /// has to recent frames
-  /// @return Vector of frame indices that need to be marginalized out
-  std::vector<FrameIndex>
-  step(FrameIndex idx, size_t size,
-       std::function<size_t(FrameIndex)> connections) noexcept;
+  /// @param idx Index of the new scan
+  /// @param size Size of the new scan (number of features)
+  /// @param connections Function that returns the number of connections a scan
+  /// has to recent scans
+  /// @return Vector of scan indices that need to be marginalized out
+  std::vector<ScanIndex> step(ScanIndex idx, size_t size,
+                              std::function<size_t(ScanIndex)> connections) noexcept;
 
   // ------------------------- Getters ------------------------- //
-  /// @brief Get the number of frames being tracked
+  /// @brief Get the number of scans being tracked
   const size_t size() const noexcept {
-    return m_keyframes.size() + m_recent_frames.size();
+    return m_keyscans.size() + m_recent_scans.size();
   }
-  /// @brief Get newest recent frame index
-  const size_t newest_rf() const noexcept { return m_recent_frames.back().idx; }
+  /// @brief Get newest recent scan index
+  const size_t newest_rf() const noexcept { return m_recent_scans.back().idx; }
 
-  /// @brief Get oldest recent frame index
-  const size_t oldest_rf() const noexcept { return m_recent_frames.front().idx; }
+  /// @brief Get oldest recent scan index
+  const size_t oldest_rf() const noexcept { return m_recent_scans.front().idx; }
 
-  /// @brief Get newest keyframe index
-  const size_t newest_kf() const noexcept { return m_keyframes.back().idx; }
+  /// @brief Get newest keyscan index
+  const size_t newest_kf() const noexcept { return m_keyscans.back().idx; }
 
-  /// @brief Get oldest keyframe index
-  const size_t oldest_kf() const noexcept { return m_keyframes.front().idx; }
+  /// @brief Get oldest keyscan index
+  const size_t oldest_kf() const noexcept { return m_keyscans.front().idx; }
 };
 
 } // namespace form

form/mapping/map.hpp

@@ -99,21 +99,21 @@ struct KeypointMapParams {
   double min_dist_map = 0.1;
 };
 
-/// @brief A map of keypoints for each frame
+/// @brief A map of keypoints for each scan
 ///
-/// Stores a mapping from frame index to a vector of keypoints
+/// Stores a mapping from scan index to a vector of keypoints
 /// All keypoints are stored in their local frames
 /// When matching is needed, the keypoints can be transformed to the global
-/// frame into a voxel map using the current pose estimates.
+/// scan into a voxel map using the current pose estimates.
 template <typename Point> class KeypointMap {
-  using FrameIndex = size_t;
+  using ScanIndex = size_t;
 
 private:
   /// @brief Parameters
   KeypointMapParams m_params;
 
-  /// @brief The data structure storing the keypoints for each frame
-  tsl::robin_map<FrameIndex, std::vector<Point>> m_frame_keypoints;
+  /// @brief The data structure storing the keypoints for each scan
+  tsl::robin_map<ScanIndex, std::vector<Point>> m_scan_keypoints;
 
 public:
   /// @brief Default constructor
@@ -122,17 +122,17 @@ template <typename Point> class KeypointMap {
   /// @brief Constructor with parameters
   KeypointMap(const KeypointMapParams &params) noexcept;
 
-  /// @brief Get a reference keypoints for a given frame, adding it in if it doesn't
+  /// @brief Get a reference keypoints for a given scan, adding it in if it doesn't
   /// exist yet
-  std::vector<Point> &get(const FrameIndex &frame_j) noexcept;
+  std::vector<Point> &get(const ScanIndex &scan_j) noexcept;
 
-  /// @brief Remove the keypoints for a given frame, if they exist
-  void remove(const FrameIndex &frame_j) noexcept;
+  /// @brief Remove the keypoints for a given scan, if they exist
+  void remove(const ScanIndex &scan_j) noexcept;
 
-  /// @brief Remove the keypoints for a list of frames, if they exist
+  /// @brief Remove the keypoints for a list of scans, if they exist
   template <typename Iter> void remove(const Iter &iter) noexcept;
 
-  /// @brief Transform all keypoints to the global frame and insert them into a
+  /// @brief Transform all keypoints to the global scan and insert them into a
   /// voxel map
   VoxelMap<Point> to_voxel_map(const gtsam::Values &values,
                                double voxel_width) const noexcept;