namespace mola


namespace mola {

// namespaces

namespace mola::lidar_segmentation;
namespace mola::rhodes;

// typedefs

typedef std::variant<std::monostate, SensorCamera, SensorIMU> SensorEntry;
typedef uint64_t euroc_timestamp_t;
typedef std::multimap<euroc_timestamp_t, SensorEntry> euroc_dataset_t;
typedef uint64_t kaist_timestamp_t;
typedef std::multimap<kaist_timestamp_t, SensorEntry> kaist_dataset_t;
typedef std::shared_ptr<EntityBase> EntityOther;
typedef std::map<std::string, LazyLoadResource> annotations_data_t;
typedef std::variant<std::monostate, RefPose3, RelPose3, RelPose3KF, RelDynPose3KF, LandmarkPoint3, EntityOther> Entity;
typedef std::variant<std::monostate, FactorRelativePose3, FactorDynamicsConstVel, FactorStereoProjectionPose, SmartFactorStereoProjectionPose, SmartFactorIMU, FactorOther> Factor;
typedef std::shared_ptr<FactorBase> FactorOther;
typedef std::allocator<T> FastAllocator;
typedef std::set<T, Compare, FastAllocator<T>> fast_set;
typedef std::map<Key, T, Compare, FastAllocator<std::pair<const Key, T>>> fast_map;
typedef std::uint64_t id_t;
typedef std::uint64_t fid_t;
typedef mrpt::system::CTimeLogger Profiler;
typedef mrpt::system::CTimeLoggerEntry ProfilerEntry;
typedef mrpt::system::CTimeLoggerSaveAtDtor ProfilerSaverAtDtor;
typedef mrpt::obs::CObservation CObservation;
typedef std::size_t timestep_t;
typedef mola::fast_map<id_t, mola::fast_set<fid_t>> entity_connected_factors_t;
typedef mrpt::containers::yaml Yaml;
typedef ContainerDeque<Entity, WorldModelData::EntitiesContainer, EntityBase, EntityOther, id_t> EntitiesContainerDeque;
typedef ContainerDeque<Factor, WorldModelData::FactorsContainer, FactorBase, FactorOther, fid_t> FactorsContainerDeque;
typedef ContainerFastMap<Entity, WorldModelData::EntitiesContainer, EntityBase, EntityOther, id_t, e_str> EntitiesContainerFastMap;
typedef ContainerFastMap<Factor, WorldModelData::FactorsContainer, FactorBase, FactorOther, fid_t, f_str> FactorsContainerFastMap;

// enums

enum Robust;

// structs

template <class T, class BASE, class Tbase, class Tother, typename ID>
struct ContainerDeque;

template <
    class T,
    class BASE,
    class Tbase,
    class Tother,
    typename ID,
    const char* Tstr
struct ContainerFastMap;

struct SensorCamera;
struct SensorGeneric;
struct SensorIMU;
struct SensorOdometry;
struct SensorSICK;
struct SensorVelodyne;
struct StereoObservation;

template <
    typename feature_id_t,
    typename gtsam_id_t = std::size_t,
    typename mola_id_t = mola::fid_t
struct TriMap;

struct YAMLParseOptions;

template <class... Ts>
struct overloaded;

// classes

class ASLAM_gtsam;
class BackEndBase;
class ConstVelocityFactorSE3;
class EntityBase;
class EntityRelativeBase;
class EurocDataset;
class ExecutableBase;
class FactorBase;
class FactorDynamicsConstVel;
class FactorRelativePose3;
class FactorStereoProjectionPose;
class FilterBase;
class Foo;
class FrontEndBase;
class G2ODataset;
class GenericSensor;
class IMUIntegrationParams;
class IMUIntegrationPublisher;
class IMUIntegrator;
class InputROS1;
class KaistDataset;
class KeyFrameBase;
class KittiOdometryDataset;
class LandmarkPoint3;
class LazyLoadResource;
class LidarOdometry;

template <class T>
class LockHelper;

class MolaLauncherApp;
class MolaViz;
class RSLAM_gtsam;
class RawDataConsumer;
class RawDataSourceBase;
class RawlogDataset;
class RefPose3;
class RelDynPose3KF;
class RelPose3;
class RelPose3KF;
class RotationIntegrationParams;
class RotationIntegrator;
class SmartFactorIMU;
class SmartFactorStereoProjectionPose;
class VizInterface;
class WheelOdometry;
class WorldModel;
class WorldModelData;

// global variables

constexpr id_t INVALID_ID = std::numeric_limits<id_t>::max();
constexpr fid_t INVALID_FID = std::numeric_limits<fid_t>::max();
static const char e_str[] = "Entity";
static const char f_str[] = "Factor";

// global functions

gtsam::Pose3 toPose3(const mrpt::math::TPose3D& p);
mrpt::math::TPose3D toTPose3D(const gtsam::Pose3& p);
gtsam::Point3 toPoint3(const mrpt::math::TPoint3D& p);
mrpt::math::TTwist3D toTTwist3D(const gtsam::Velocity3& v);

void updateEntityPose(
    Entity& e,
    const gtsam::Pose3& x

std::array<double, 3> toVelArray(const gtsam::Velocity3& v);

void updateEntityVel(
    Entity& e,
    const gtsam::Velocity3& v

mrpt::math::CMatrixDouble33 incremental_rotation(
    const mrpt::math::TVector3D& w,
    const RotationIntegrationParams& params,
    double dt,
    const mrpt::optional_ref<mrpt::math::CMatrixDouble33>& D_incrR_integratedOmega = std::nullopt

mrpt::math::TPose3D load_pose_from_kaist_txt(const std::string& filename);
EntityBase& entity_get_base(Entity& e);
const EntityBase& entity_get_base(const Entity& e);
mrpt::math::TPose3D entity_get_pose(const Entity& e);
mrpt::math::TTwist3D entity_get_twist(const mola::Entity& e);

void entity_update_pose(
    Entity& e,
    const mrpt::math::TPose3D& p

void entity_update_vel(
    Entity& e,
    const std::array<double, 3>& v

mrpt::Clock::time_point entity_get_timestamp(const Entity& e);
FactorBase& factor_get_base(Factor& f);
const FactorBase& factor_get_base(const Factor& f);

template <class T>
LockHelper<T> lockHelper(T& t);

void pretty_print_exception(
    const std::exception& e,
    const std::string& headerLine,
    const bool use_std_cerr = true

template <class... Ts>

std::string parse_yaml(const std::string& text, const YAMLParseOptions& opts = YAMLParseOptions());

mrpt::containers::yaml parse_yaml(
    const mrpt::containers::yaml& input,
    const YAMLParseOptions& opts = YAMLParseOptions()

mrpt::containers::yaml load_yaml_file(const std::string& fileName, const YAMLParseOptions& opts = YAMLParseOptions());
std::string yaml_to_string(const mrpt::containers::yaml& cfg);

} // namespace mola

Detailed Documentation


typedef std::shared_ptr<EntityBase> EntityOther

Placeholder for generic entity of user-defined types

typedef std::shared_ptr<FactorBase> FactorOther

Placeholder for a generic factor of user-defined types

typedef std::size_t timestep_t

0-based indices of observations in a dataset

typedef mrpt::containers::yaml Yaml

Convenient typedef to save typing in the MOLA project.

Global Functions

FactorBase& factor_get_base(Factor& f)

Return a reference to the FactorBase associated to the variant f

const FactorBase& factor_get_base(const Factor& f)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template <class... Ts>

Based on