msceqf_options.hpp

// Copyright (C) 2023 Alessandro Fornasier.
// Control of Networked Systems, University of Klagenfurt, Austria.
//
// All rights reserved.
//
// This software is licensed under the terms of the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with the
// License. You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
//
// You can contact the authors at <alessandro.fornasier@ieee.org>
 
#ifndef OPTIONS_HPP
#define OPTIONS_HPP
 
#include <opencv2/opencv.hpp>
 
#include "types/fptypes.hpp"
 
namespace msceqf
{
enum class FeatureRepresentation
{
  ANCHORED_EUCLIDEAN,
  ANCHORED_POLAR,
  ANCHORED_INVERSE_DEPTH,
};

enum class ProjectionMethod
{
  UNIT_SPHERE,
  UNIT_PLANE,
};

enum class DistortionModel
{
  RADTAN,
  EQUIDISTANT,
};

enum class EqualizationMethod
{
  HISTOGRAM,
  CLAHE,
  NONE,
};

enum class FeatureDetector
{
  FAST,
  GFTT,
};

enum class ZeroVelocityUpdate
{
  DISABLE,
  ENABLE,
  BEGINNING,
};

enum class MaskType
{
  STATIC,
  DYNAMIC,
};

struct StateOptions
{
  Matrix9 D_init_cov_;                         
  Matrix6 delta_init_cov_;                     
  Matrix6 E_init_cov_;                         
  Matrix4 L_init_cov_;                         
  SE3 initial_camera_extrinsics_;              
  In initial_camera_intrinsics_;               
  bool enable_camera_intrinsics_calibration_;  
  fp gravity_;                                 
  uint num_clones_;                            
  uint num_persistent_features_;               
};
 
struct PropagatorOptions
{
  fp angular_velocity_std_;       
  fp acceleration_std_;           
  fp angular_velocity_bias_std_;  
  fp acceleration_bias_std_;      
  uint imu_buffer_max_size_;      
  int state_transition_order_;    
};
 
struct UpdaterOptions
{
  bool refine_traingulation_;  
  fp min_depth_;               
  fp max_depth_;               
  uint max_iterations_;        
  fp tollerance_;              
  FeatureRepresentation msc_features_representation_;  
  ProjectionMethod projection_method_;                 
  uint min_track_lenght_;                              
  fp min_angle_;                                       
  fp pixel_std_;                                       
  bool curvature_correction_;                          
};
 
struct ZeroVelocityUpdaterOptions
{
  ZeroVelocityUpdate zero_velocity_update_;  
  bool curvature_correction_;                
};
 
struct InitializerOptions
{
  fp acc_threshold_;            
  fp imu_init_window_;          
  fp gravity_;                  
  bool identity_b0_;            
  bool init_with_given_state_;  
  SE23 initial_extended_pose_;  
  Vector6 initial_bias_;        
  fp initial_timestamp_;        
};
 
struct CheckerOptions
{
  fp disparity_threshold_;  
  fp disparity_window_;     
};
 
struct CameraOptions
{
  VectorX distortion_coefficients_;  
  Vector2 resolution_;               
  fp timeshift_cam_imu_;             
  cv::Mat static_mask_;              
  MaskType mask_type_;               
};
 
struct FastOptions
{
  int fast_threshold_;  
};
 
struct GFTTOptions
{
  fp quality_level_;  
};
 
struct TrackerOptions
{
  CameraOptions cam_options_;         
  DistortionModel distortion_model_;  
  EqualizationMethod equalizer_;      
  FeatureDetector detector_;          
  uint max_features_;                 
  uint min_features_;                 
  uint grid_x_size_;                  
  uint grid_y_size_;                  
  uint min_px_dist_;                  
  uint optical_flow_pyramid_levels_;  
  uint detector_pyramid_levels_;      
  uint optical_flow_win_size_;        
  int opencv_threads_;                
  fp ransac_reprojection_;            
  FastOptions fast_opts_;             
  GFTTOptions gftt_opts_;             
};
 
struct TrackManagerOptions
{
  TrackerOptions tracker_options_;  
  size_t max_track_length_;         
};
 
struct MSCEqFOptions
{
  TrackManagerOptions track_manager_options_;     
  StateOptions state_options_;                    
  CheckerOptions checker_options_;                
  InitializerOptions init_options_;               
  PropagatorOptions propagator_options_;          
  UpdaterOptions updater_options_;                
  ZeroVelocityUpdaterOptions zvupdater_options_;  
};
 
}  // namespace msceqf
 
#endif  // OPTIONS_HPP