UpdaterZeroVelocity.h

Go to the documentation of this file.

/*
 * OpenVINS: An Open Platform for Visual-Inertial Research
 * Copyright (C) 2018-2023 Patrick Geneva
 * Copyright (C) 2018-2023 Guoquan Huang
 * Copyright (C) 2018-2023 OpenVINS Contributors
 * Copyright (C) 2018-2019 Kevin Eckenhoff
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef OV_MSCKF_UPDATER_ZEROVELOCITY_H
#define OV_MSCKF_UPDATER_ZEROVELOCITY_H
 
#include <memory>
 
#include "utils/sensor_data.h"
 
#include "UpdaterOptions.h"
#include "utils/NoiseManager.h"
 
namespace ov_core {
class Feature;
class FeatureDatabase;
} // namespace ov_core
namespace ov_type {
class Landmark;
} // namespace ov_type
 
namespace ov_msckf {
 
class State;
class Propagator;
 
class UpdaterZeroVelocity {
 
public:
  UpdaterZeroVelocity(UpdaterOptions &options, NoiseManager &noises, std::shared_ptr<ov_core::FeatureDatabase> db,
                      std::shared_ptr<Propagator> prop, double gravity_mag, double zupt_max_velocity, double zupt_noise_multiplier,
                      double zupt_max_disparity);
 
  void feed_imu(const ov_core::ImuData &message, double oldest_time = -1) {
 
    // Append it to our vector
    imu_data.emplace_back(message);
 
    // Sort our imu data (handles any out of order measurements)
    // std::sort(imu_data.begin(), imu_data.end(), [](const IMUDATA i, const IMUDATA j) {
    //    return i.timestamp < j.timestamp;
    //});
 
    // Clean old measurements
    // std::cout << "ZVUPT: imu_data.size() " << imu_data.size() << std::endl;
    clean_old_imu_measurements(oldest_time - 0.10);
  }
 
  void clean_old_imu_measurements(double oldest_time) {
    if (oldest_time < 0)
      return;
    auto it0 = imu_data.begin();
    while (it0 != imu_data.end()) {
      if (it0->timestamp < oldest_time) {
        it0 = imu_data.erase(it0);
      } else {
        it0++;
      }
    }
  }
 
  bool try_update(std::shared_ptr<State> state, double timestamp);
 
protected:
  UpdaterOptions _options;
 
  NoiseManager _noises;
 
  std::shared_ptr<ov_core::FeatureDatabase> _db;
 
  std::shared_ptr<Propagator> _prop;
 
  Eigen::Vector3d _gravity;
 
  double _zupt_max_velocity = 1.0;
 
  double _zupt_noise_multiplier = 1.0;
 
  double _zupt_max_disparity = 1.0;
 
  std::map<int, double> chi_squared_table;
 
  std::vector<ov_core::ImuData> imu_data;
 
  double last_prop_time_offset = 0.0;
  bool have_last_prop_time_offset = false;
 
  double last_zupt_state_timestamp = 0.0;
 
  int last_zupt_count = 0;
};
 
} // namespace ov_msckf
 
#endif // OV_MSCKF_UPDATER_ZEROVELOCITY_H