Global Namespace

Overview

// namespaces

namespace math;
namespace mola;
namespace mp2p_icp;
    namespace mp2p_icp::internal;
namespace mp2p_icp_filters;
namespace mrpt;
    namespace mrpt::config;
    namespace mrpt::maps;
    namespace mrpt::obs;
    namespace mrpt::rtti;
    namespace mrpt::serialization;
    namespace mrpt::system;
namespace rosbag2_cpp;
    namespace rosbag2_cpp::readers;
namespace rosbag2_storage;
namespace std;
namespace string_literals;
namespace tf2;
namespace tsl;
    namespace tsl::detail_robin_hash;
    namespace tsl::rh;
        namespace tsl::rh::detail;

// typedefs

typedef mrpt::math::CMatrixDouble44 Matrix;
typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types;
typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types;
typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types;

// structs

struct HandlersContainer;
struct LoadedModules;
struct OLAE_LinearSystems;
struct errors;

template <class T1, class T2>
struct is_pair<std::pair<T1, T2>>;

template <class T>
struct is_pair;

// classes

template <typename T>
class TraitsTest;

class copy_only_test;

template <typename T>
class custom_allocator;

class deserializer;

template <typename T>
class identity_hash;

template <unsigned int MOD>
class mod_hash;

class move_only_test;
class self_reference_member_test;
class serializer;
class utils;

// global variables

static PyObject* markup;
static PyMethodDef module_methods[];
static struct PyModuleDef module_definition = {   PyModuleDef_HEAD_INIT,  "markupsafe._speedups",     NULL,   -1,     module_methods,  NULL,   NULL,   NULL,   NULL };
static std::string kitti_basedir;
const float lengths[] = {100, 200, 300, 400, 500, 600, 700, 800};
const int32_t num_lengths = 8;
static const char* yamlRotIntParams1 =     R"###(# Config for gtsam::RotationIntegrationParams gyroBias: [-1.0e-4, 2.0e-4, -3.0e-4] sensorLocationInVehicle:   quaternion: [0.0, 0.0, 0.0, 1.0]   translation: [0.0, 0.0, 0.0])###";
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t MAX_UNLOAD_LEN = 250;
constexpr size_t READ_AHEAD_LEN = 10;
constexpr size_t MAX_UNLOAD_LEN = 500;
static const int GZ_COMPRESS_LEVEL = 0;
std::string MOLA_MAP_STORAGE_DIR =     mrpt::get_env<std::string>("MOLA_MAP_STORAGE_DIR", "/tmp");
static mola::MolaLauncherApp app;
static std::map<std::string, LoadedModules> loaded_lib_handled;
static std::size_t nb_custom_allocs = 0;
constexpr size_t HARD_MAX_MATCHES = 3;
static const char* yamlRotIntParams1 =     R"###(# Config for gtsam::RotationIntegrationParams gyroBias: [-1.0e-4, 2.0e-4, -3.0e-4] sensorLocationInVehicle:   quaternion: [0.0, 0.0, 0.0, 1.0]   translation: [0.0, 0.0, 0.0])###";
const std::string datasetsRoot = TEST_DATASETS_ROOT;
static const unsigned int mola_icon_width = 64;
static const unsigned int mola_icon_height = 64;
static const char* mola_icon_data;
const std::string txt1 = R"###(# sample yaml a: 1.0 b: "foo" c:   - a   - b   - c d:   va: 'z')###";
static const uint8_t DIPI_SERIALIZATION_VERSION = 0;
static const uint8_t SERIALIZATION_VERSION = 1;
const bool MP2P_ICP_GENERATE_DEBUG_FILES =     mrpt::get_env<bool>("MP2P_ICP_GENERATE_DEBUG_FILES", false);
static const uint8_t SERIALIZATION_VERSION = 0;

// global functions

static int init_constants(void);
static PyObject* escape_unicode_kind1(PyUnicodeObject* in);
static PyObject* escape_unicode_kind2(PyUnicodeObject* in);
static PyObject* escape_unicode_kind4(PyUnicodeObject* in);
static PyObject* escape_unicode(PyUnicodeObject* in);

static PyObject* escape(
    PyObject* self,
    PyObject* text
    );

static PyObject* escape_silent(
    PyObject* self,
    PyObject* text
    );

static PyObject* soft_str(
    PyObject* self,
    PyObject* s
    );

PyMODINIT_FUNC PyInit__speedups(void);
static TCLAP::CmdLine cmd("kitti-metrics-eval");

static TCLAP::ValueArg<std::string> arg_kitti_basedir(
    "k",
    "kitti-basedir",
    "Path to the kitti datasets. Overrides to the default,
    which is reading " "the env var `KITTI_BASE_DIR`.",
    false,
    "",
    "",
    cmd
    );

static TCLAP::ValueArg<std::string> arg_result_path(
    "r",
    "result-tum-path",
    "File to evaluate,
    in TUM format",
    true,
    "result.txt|result_%02i.txt",
    "result.txt",
    cmd
    );

static TCLAP::ValueArg<std::string> argSavePathKittiFormat(
    "",
    "save-as-kitti",
    "If given,
    will transform the input path from the LIDAR frame to the cam0 " "frame and save the path to a TXT file in the format expected by KITTI dev " "kit.",
    false,
    "result.kitti",
    "result.kitti",
    cmd
    );

static TCLAP::MultiArg<int> arg_seq(
    "s",
    "sequence",
    "The sequence number of the path(s) file(s) to evaluate,
    used to find out " "GT and calibration files for the Kitti dataset.",
    false,
    "01",
    cmd
    );

static TCLAP::ValueArg<std::string> arg_override_gt_file(
    "",
    "gt-tum-path",
    "If provided,
    the --sequence flag will be ignored and this particular file " "in TUM format will be read and used as ground truth to compare against " "the resulting odometry path.",
    false,
    "trajectory_gt.txt",
    "trajectory_gt.txt",
    cmd
    );

static TCLAP::SwitchArg argSkipFigures(
    "",
    "no-figures",
    "Skip generating the error figures",
    cmd
    );

static bool eval();
static void do_kitti_eval_error();

int main(
    int argc,
    char** argv
    );

static void parse_calib_line(
    const std::string& line,
    Eigen::Matrix<double, 3, 4>& M
    );

std::vector<Matrix> loadPoses_tum_format(
    const std::string& file_name,
    const std::string& calib_file,
    bool isGT
    );

std::vector<Matrix> loadPoses(string file_name);
vector<float> trajectoryDistances(vector<Matrix>& poses);

int32_t lastFrameFromSegmentLength(
    vector<float>& dist,
    int32_t first_frame,
    float len
    );

float rotationError(Matrix& pose_error);
float translationError(Matrix& pose_error);

vector<errors> calcSequenceErrors(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void saveSequenceErrors(
    vector<errors>& err,
    string file_name
    );

void savePathPlot(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result,
    string file_name
    );

vector<int32_t> computeRoi(
    vector<Matrix>& poses_gt,
    vector<Matrix>& poses_result
    );

void plotPathPlot(
    string dir,
    vector<int32_t>& roi,
    int32_t idx
    );

void saveErrorPlots(
    vector<errors>& seq_err,
    string plot_error_dir,
    const char* prefix
    );

void plotErrorPlots(
    string dir,
    const char* prefix
    );

void saveStats(
    vector<errors> err,
    string dir
    );

MRPT_INITIALIZER(do_register_InputROS2);
MRPT_INITIALIZER(do_register_imu_preintegration);
MRPT_INITIALIZER(do_register_mrpt_kernel);
MRPT_INITIALIZER(do_register_mola_metric_maps);
MRPT_INITIALIZER(do_register_navstate_fuse);
MRPT_INITIALIZER(register_mp2p_icp);
MRPT_INITIALIZER(register_mola_lidar_segmentation);
MRPT_INITIALIZER(register_mp2p_icp_map);
static void test_rotation_integration();

int main(
    ] int argc,
    ] char** argv
    );

MRPT_INITIALIZER(do_register_EurocDataset);
MRPT_INITIALIZER(do_register_Kitti360Dataset);
MRPT_INITIALIZER(do_register_KittiOdometryDataset);

static void build_list_files(
    const std::string& dir,
    const std::string& file_extension,
    std::vector<std::string>& out_lst
    );

static void parse_calib_line(
    const std::string& line,
    Eigen::Matrix<double, 3, 4>& M
    );

MRPT_INITIALIZER(do_register_MulranDataset);
MRPT_INITIALIZER(do_register_ParisLucoDataset);

static void build_list_files(
    const std::string& dir,
    const std::string& file_extension,
    std::vector<std::string>& out_lst
    );

MRPT_INITIALIZER(do_register_RawlogDataset);
MRPT_INITIALIZER(do_register_Rosbag2Dataset);

IMPLEMENTS_VIRTUAL_SERIALIZABLE(
    EntityBase,
    mrpt::serialization::CSerializable,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    LandmarkPoint3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RefPose3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelDynPose3KF,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelPose3,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    RelPose3KF,
    EntityBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorDynamicsConstVel,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorRelativePose3,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    FactorStereoProjectionPose,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    SmartFactorIMU,
    FactorBase,
    mola
    );

IMPLEMENTS_SERIALIZABLE(
    SmartFactorStereoProjectionPose,
    FactorBase,
    mola
    );

IMPLEMENTS_VIRTUAL_MRPT_OBJECT(
    FilterBase,
    mrpt::rtti::CObject,
    mp2p_icp_filters
    );

IMPLEMENTS_SERIALIZABLE(
    WorldModelData,
    mrpt::serialization::CSerializable,
    mola
    );

static TCLAP::CmdLine cmd("mola-cli");

static TCLAP::UnlabeledValueArg<std::string> arg_yaml_cfg(
    "config",
    "Input YAML config file(required)(*.yaml)",
    false,
    "",
    "mola-system.yaml",
    cmd
    );

static TCLAP::ValueArg<std::string> arg_verbosity_level(
    "v",
    "verbosity",
    "Verbosity level: ERROR|WARN|INFO|DEBUG(Default: INFO)",
    false,
    "",
    "INFO",
    cmd
    );

static TCLAP::SwitchArg arg_enable_profiler(
    "p",
    "profiler",
    "Enable time profiler by default in all modules(Default: NO)",
    cmd
    );

static TCLAP::SwitchArg arg_enable_profiler_whole(
    "",
    "profiler-whole",
    "Enable whole-history time profiler in all modules(Default: NO).**DO " "NOT** use in production,
    only to benchmark short runs(unbounded memory " "usage)",
    cmd
    );

static TCLAP::SwitchArg arg_rtti_list_all(
    "",
    "rtti-list-all",
    "Loads all MOLA modules,
    then list all classes registered via mrpt::rtti,
    " "and exits.",
    cmd
    );

static TCLAP::ValueArg<std::string> arg_rtti_list_children(
    "",
    "rtti-children-of",
    "Loads all MOLA modules,
    then list all known classes that inherit from the " "given one,
    and exits.",
    false,
    "",
    "mp2p_icp::ICP_Base",
    cmd
    );

static TCLAP::SwitchArg arg_list_modules(
    "",
    "list-modules",
    "Loads all MOLA modules,
    then list them. It also shows the list of paths " "in which the program looks for module dynamic libraries,
    then exits.",
    cmd
    );

static TCLAP::SwitchArg arg_list_module_shared_dirs(
    "",
    "list-module-shared-dirs",
    "Finds all MOLA module source/shared directories,
    then list them. Paths " "can be added with the environment variable MOLA_MODULES_SHARED_PATH.",
    cmd
    );

static TCLAP::SwitchArg arg_ros_args(
    "",
    "ros-args",
    "Dummy flag,
    defined just to allow the program invocation from ROS 2 " "launch files.",
    cmd
    );

void mola_signal_handler(int s);
void mola_install_signal_handler();
static int mola_cli_launch_slam();
int mola_cli_rtti_list_all();
int mola_cli_rtti_list_child();
int mola_cli_list_modules();
int mola_cli_list_module_shared_dirs();

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

static TCLAP::CmdLine cmd("mola-yaml-parser");

static TCLAP::SwitchArg arg_no_includes(
    "",
    "no-includes",
    "Disables solving YAML `$include{}`s(Default: NO)",
    cmd
    );

static TCLAP::SwitchArg arg_no_cmd_runs(
    "",
    "no-cmd-runs",
    "Disables solving YAML `$(cmd)`s(Default: NO)",
    cmd
    );

static TCLAP::SwitchArg arg_no_env_vars(
    "",
    "no-env-vars",
    "Disables solving YAML `${xxx}`s(Default: NO)",
    cmd
    );

static TCLAP::UnlabeledValueArg<std::string> arg_input_files(
    "YAML_file",
    "Input YAML file(required)(*.yml)",
    true,
    "params.yml",
    "YAML files",
    cmd
    );

int main(
    int argc,
    char** argv
    );

MRPT_TODO("Improvement: automatic scanning libraries and extract their classes");
const std::map<std::string, LoadedModules>& get_loaded_modules();

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    );

static void internal_unload_lib_modules();

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    );

const std::map<std::string, LoadedModules>& get_loaded_modules();

template <class T, class U>
bool operator == (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

template <class T, class U>
bool operator != (
    const custom_allocator<T>&,
    const custom_allocator<U>&
    );

BOOST_AUTO_TEST_CASE(test_custom_allocator_1);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_min_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_policy_max_bucket_count,
    Policy,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(test_insert, HMap, test_types);
BOOST_AUTO_TEST_CASE(test_range_insert);
BOOST_AUTO_TEST_CASE(test_rehash_0);
BOOST_AUTO_TEST_CASE(test_insert_with_hint);
BOOST_AUTO_TEST_CASE(test_emplace_hint);
BOOST_AUTO_TEST_CASE(test_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace);
BOOST_AUTO_TEST_CASE(test_try_emplace_2);
BOOST_AUTO_TEST_CASE(test_try_emplace_hint);
BOOST_AUTO_TEST_CASE(test_insert_or_assign);
BOOST_AUTO_TEST_CASE(test_insert_or_assign_hint);
BOOST_AUTO_TEST_CASE(test_range_erase_all);
BOOST_AUTO_TEST_CASE(test_range_erase);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_erase_loop_range,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert_erase_insert,
    HMap,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_range_erase_same_iterators);
BOOST_AUTO_TEST_CASE(test_max_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor_extreme_factors);
BOOST_AUTO_TEST_CASE(test_min_load_factor);
BOOST_AUTO_TEST_CASE(test_min_load_factor_range_erase);
BOOST_AUTO_TEST_CASE(test_rehash_empty);
BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_clear);
BOOST_AUTO_TEST_CASE(test_clear_with_min_load_factor);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator);
BOOST_AUTO_TEST_CASE(test_modify_value_through_iterator_with_const_qualifier);
BOOST_AUTO_TEST_CASE(test_extreme_bucket_count_value_construction);
BOOST_AUTO_TEST_CASE(test_range_construct);
BOOST_AUTO_TEST_CASE(test_assign_operator);
BOOST_AUTO_TEST_CASE(test_move_constructor);
BOOST_AUTO_TEST_CASE(test_move_constructor_empty);
BOOST_AUTO_TEST_CASE(test_move_operator);
BOOST_AUTO_TEST_CASE(test_move_operator_empty);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_constructor);
BOOST_AUTO_TEST_CASE(test_reassign_moved_object_move_operator);
BOOST_AUTO_TEST_CASE(test_use_after_move_constructor);
BOOST_AUTO_TEST_CASE(test_use_after_move_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_and_operator);
BOOST_AUTO_TEST_CASE(test_copy_constructor_empty);
BOOST_AUTO_TEST_CASE(test_copy_operator_empty);
BOOST_AUTO_TEST_CASE(test_at);
BOOST_AUTO_TEST_CASE(test_contains);
BOOST_AUTO_TEST_CASE(test_equal_range);
BOOST_AUTO_TEST_CASE(test_access_operator);
BOOST_AUTO_TEST_CASE(test_swap);
BOOST_AUTO_TEST_CASE(test_swap_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_empty);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_store_hash);
BOOST_AUTO_TEST_CASE(test_serialize_desearialize_with_different_hash);
BOOST_AUTO_TEST_CASE(test_key_equal);
BOOST_AUTO_TEST_CASE(test_heterogeneous_lookups);
BOOST_AUTO_TEST_CASE(test_empty_map);
BOOST_AUTO_TEST_CASE(test_precalculated_hash);

BOOST_AUTO_TEST_CASE_TEMPLATE(
    test_insert,
    HSet,
    test_types
    );

BOOST_AUTO_TEST_CASE(test_compare);
BOOST_AUTO_TEST_CASE(test_insert_pointer);
BOOST_AUTO_TEST_CASE(test_serialize_deserialize);
std::int32_t utils::get_key< std::int32_t >(std::size_t counter);
std::int64_t utils::get_key< std::int64_t >(std::size_t counter);
std::string utils::get_key< std::string >(std::size_t counter);
std::int32_t utils::get_value< std::int32_t >(std::size_t counter);
std::int64_t utils::get_value< std::int64_t >(std::size_t counter);
std::string utils::get_value< std::string >(std::size_t counter);
static TCLAP::CmdLine cmd("mola-myapp");

static TCLAP::ValueArg<std::string> argParam1(
    "p",
    "param",
    "Explanation",
    false,
    "",
    "",
    cmd
    );

static void do_my_app();

int main(
    int argc,
    char** argv
    );

void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    ] int argc,
    ] char** argv
    );

TEST_CLASS_MOVE_COPY_CTORS(mola::SparseVoxelPointCloud);
TEST_CLASS_MOVE_COPY_CTORS(mola::OccGrid);
void test_serialization();

int main(
    ] int argc,
    ] char** argv
    );

void test_voxelmap_basic_ops();
void test_voxelmap_insert_2d_scan();

int main(
    ] int argc,
    ] char** argv
    );

static void test_rotation_integration();

int main(
    ] int argc,
    ] char** argv
    );

static void test1();

int main(
    ] int argc,
    ] char** argv
    );

static void test1();

int main(
    ] int argc,
    ] char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

int main(
    int argc,
    char** argv
    );

MRPT_INITIALIZER(do_register_MolaViz);

static std::string::size_type findClosing(
    size_t pos,
    const std::string& s,
    const char searchEndChar,
    const char otherStartChar
    );

static std::tuple<std::string, std::string> splitVerticalBar(const std::string& s);
static std::string trimWSNL(const std::string& s);

static std::string parseEnvVars(
    const std::string& text,
    const mola::YAMLParseOptions& opts
    );

static std::string parseCmdRuns(
    const std::string& text,
    const mola::YAMLParseOptions& opts
    );

static void recursiveParseNodeForIncludes(
    yaml::node_t& n,
    const mola::YAMLParseOptions& opts
    );

static std::string parseIncludes(
    const std::string& text,
    const mola::YAMLParseOptions& opts
    );

static void test_yaml2string();
static void test_parseSimple();
static void test_parseIncludes();

int main(
    ] int argc,
    ] char** argv
    );

MRPT_FILL_ENUM(IterTermReason::Undefined);
MRPT_FILL_ENUM(IterTermReason::NoPairings);
MRPT_FILL_ENUM(IterTermReason::SolverError);
MRPT_FILL_ENUM(IterTermReason::MaxIterations);
MRPT_FILL_ENUM(IterTermReason::Stalled);
MRPT_FILL_ENUM(RobustKernel::None);
MRPT_FILL_ENUM(RobustKernel::GemanMcClure);
MRPT_FILL_ENUM(RobustKernel::Cauchy);

static void filterListByMaxDist(
    std::vector<size_t>& kddIdxs,
    std::vector<float>& kddSqrDist,
    const float maxDistForCorrespondenceSquared
    );

static bool se3_l2_internal(
    const mp2p_icp::Pairings& in,
    const WeightParameters& wp,
    const mrpt::math::TPoint3D& ct_local,
    const mrpt::math::TPoint3D& ct_global,
    mrpt::math::CQuaternionDouble& out_attitude,
    OutlierIndices& in_out_outliers
    );

static mrpt::poses::CPose3D gibbs2pose(const Eigen::Vector3d& v);

static OLAE_LinearSystems olae_build_linear_system(
    const Pairings& in,
    const WeightParameters& wp,
    const mrpt::math::TPoint3D& ct_local,
    const mrpt::math::TPoint3D& ct_global,
    OutlierIndices& in_out_outliers
    );

template <typename T>
static void push_back_copy(
    const T& o,
    T& me
    );

template <typename T>
static void push_back_move(
    T&& o,
    T& me
    );

template <typename CONTAINER>
void append_container_size(
    const CONTAINER& c,
    const std::string& name,
    std::string& ret
    );

static void append_from_sorted(
    const std::multimap<double, mrpt::tfest::TMatchingPair>& sorted,
    Pairings& out,
    const double ratio
    );

IMPLEMENTS_MRPT_OBJECT(
    QualityEvaluator_RangeImageSimilarity,
    QualityEvaluator,
    mp2p_icp
    );

static void projectPoint(
    const mrpt::math::TPoint3D& P,
    const mrpt::img::TCamera& params,
    double& pixel_x,
    double& pixel_y
    );

static double phi(double x);
static double errorForMismatch(const double x);

static double errorForMismatch(
    const double DeltaRange,
    const double sigma
    );

static double loss(
    double x,
    double y
    );

IMPLEMENTS_MRPT_OBJECT(
    WeightParameters,
    mrpt::serialization::CSerializable,
    mp2p_icp
    );

MRPT_ENUM_TYPE_BEGIN_NAMESPACE(mp2p_icp_filters, mp2p_icp_filters::DecimateMethod) MRPT_FILL_ENUM(DecimateMethod MRPT_FILL_ENUM(DecimateMethod::ClosestToAverage);
MRPT_FILL_ENUM(DecimateMethod::VoxelAverage);
MRPT_FILL_ENUM(DecimateMethod::RandomPoint);

IMPLEMENTS_MRPT_OBJECT(
    FilterBoundingBox,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterByIntensity,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterByRange,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterCurvature,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterDecimateAdaptive,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterDecimateVoxels,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterDecimateVoxelsQuadratic,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterDeleteLayer,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterDeskew,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterEdgesPlanes,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterMerge,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterNormalizeIntensity,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    FilterVoxelSlice,
    mp2p_icp_filters::FilterBase,
    mp2p_icp_filters
    );

IMPLEMENTS_MRPT_OBJECT(
    GeneratorEdgesFromRangeImage,
    Generator,
    mp2p_icp_filters
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    X
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    Y
    );

MRPT_FILL_ENUM_MEMBER(
    mp2p_icp::Coordinate,
    Z
    );

IMPLEMENTS_MRPT_OBJECT(
    metric_map_t,
    mrpt::serialization::CSerializable,
    mp2p_icp
    );

// macros

#define BOOST_TEST_MODULE

#define DECLARE_PARAMETER_IN_OPT( \
    __yaml, \
    __variable, \
    __object \
    )

#define DECLARE_PARAMETER_IN_REQ( \
    __yaml, \
    __variable, \
    __object \
    )

#define DECLARE_PARAMETER_OPT( \
    __yaml, \
    __variable \
    )

#define DECLARE_PARAMETER_REQ( \
    __yaml, \
    __variable \
    )

#define DLL_EXT

#define ENSURE_YAML_ENTRY_EXISTS( \
    _c, \
    _name \
    )

#define GET_DELTA( \
    inp, \
    inp_end, \
    delta \
    )

#define HEADER_PIXEL( \
    data, \
    pixel \
    )

#define MOLA_ARG_N( \
    _1, \
    _2, \
    _3, \
    _4, \
    _5, \
    _6, \
    _7, \
    _8, \
    _9, \
    _10, \
    N, \
    ... \
    )

#define MOLA_NARG(...)
#define MOLA_NARG_I_(...)
#define MOLA_REGISTER_MODULE(_classname)
#define MOLA_RSEQ_N()

#define MOLA_VFUNC( \
    name, \
    n \
    )

#define MOLA_VFUNC_( \
    name, \
    n \
    )

#define TEST_CLASS_MOVE_COPY_CTORS(_classname)

#define TSL_RH_CHECK_THROW( \
    S, \
    E \
    )

#define TSL_RH_CHECK_THROW_EITHER( \
    S, \
    E1, \
    E2 \
    )

#define TSL_RH_LIKELY(exp)
#define TSL_RH_NB_PRIMES

#define TSL_RH_THROW_OR_TERMINATE( \
    ex, \
    msg \
    )

#define TSL_RH_UNUSED(x)

#define VFUNC( \
    func, \
    ... \
    )

#define YAML_LOAD_MEMBER_OPT( \
    _varname, \
    _type \
    )

#define YAML_LOAD_MEMBER_REQ( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT(...)

#define YAML_LOAD_OPT2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG(...)

#define YAML_LOAD_OPT_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_OPT_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ(...)

#define YAML_LOAD_REQ2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ3( \
    _param_str, \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG(...)

#define YAML_LOAD_REQ_DEG2( \
    _varname, \
    _type \
    )

#define YAML_LOAD_REQ_DEG3( \
    _param_str, \
    _varname, \
    _type \
    )

#define tsl_rh_assert(expr)

Typedefs

typedef boost::mpl::list<tsl::rh::power_of_two_growth_policy<2>, tsl::rh::power_of_two_growth_policy<4>, tsl::rh::prime_growth_policy, tsl::rh::mod_growth_policy<>, tsl::rh::mod_growth_policy<std::ratio<7, 2>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_map<std::int64_t, std::int64_t>, tsl::robin_map<std::string, std::string>, tsl::robin_map<std::int64_t, std::int64_t, mod_hash<9>>, tsl::robin_map<std::string, std::string, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<self_reference_member_test, self_reference_member_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, true, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<move_only_test, move_only_test, mod_hash<9>>, tsl::robin_map<move_only_test, move_only_test, mod_hash<9>, std::equal_to<move_only_test>, std::allocator<std::pair<move_only_test, move_only_test>>, false, tsl::rh::mod_growth_policy<>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, false, tsl::rh::power_of_two_growth_policy<4>>, tsl::robin_pg_map<copy_only_test, copy_only_test, mod_hash<9>>, tsl::robin_map<copy_only_test, copy_only_test, mod_hash<9>, std::equal_to<copy_only_test>, std::allocator<std::pair<copy_only_test, copy_only_test>>, true, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

typedef boost::mpl::list<tsl::robin_set<std::int64_t>, tsl::robin_set<std::string>, tsl::robin_set<self_reference_member_test>, tsl::robin_set<move_only_test>, tsl::robin_pg_set<self_reference_member_test>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, true, tsl::rh::prime_growth_policy>, tsl::robin_set<self_reference_member_test, std::hash<self_reference_member_test>, std::equal_to<self_reference_member_test>, std::allocator<self_reference_member_test>, true, tsl::rh::mod_growth_policy<>>, tsl::robin_set<move_only_test, std::hash<move_only_test>, std::equal_to<move_only_test>, std::allocator<move_only_test>, false, tsl::rh::mod_growth_policy<>>> test_types

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Global Variables

static std::map<std::string, LoadedModules> loaded_lib_handled

From internal_load_lib_modules()

static std::size_t nb_custom_allocs = 0

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Global Functions

const std::map<std::string, LoadedModules>& get_loaded_modules()

Returns the current list of loaded module dyanmic libraries.

void internal_load_lib_modules(
    mrpt::system::COutputLogger& app,
    const std::vector<std::string>& lib_search_paths
    )

Loads all libs under lib_search_paths_.

Macros

#define BOOST_TEST_MODULE

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define TSL_RH_CHECK_THROW(S, E)

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#define tsl_rh_assert(expr)

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.