Skip to content
Snippets Groups Projects
Commit ad1f5fb3 authored by Joan Solà Ortega's avatar Joan Solà Ortega
Browse files

Delete old fines not related to this plugin

parent 10c64adb
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 0 additions and 12284 deletions
src/yaml/processor_IMU_yaml.cpp deleted 100644 → 0
+ 0
− 51
View file @ 10c64adb
/**
* \file processor_imu_yaml.cpp
*
* Created on: jan 19, 2017
* \author: Dinesh Atchuthan
*/
// wolf yaml
#include "core/processor/processor_IMU.h"
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static ProcessorParamsBasePtr createProcessorIMUParams(const std::string & _filename_dot_yaml)
{
YAML::Node config = YAML::LoadFile(_filename_dot_yaml);
if (config["processor type"].as<std::string>() == "IMU")
{
YAML::Node kf_vote = config["keyframe vote"];
ProcessorParamsIMUPtr params = std::make_shared<ProcessorParamsIMU>();
params->max_time_span = kf_vote["max time span"] .as<Scalar>();
params->max_buff_length = kf_vote["max buffer length"] .as<SizeEigen >();
params->dist_traveled = kf_vote["dist traveled"] .as<Scalar>();
params->angle_turned = kf_vote["angle turned"] .as<Scalar>();
params->voting_active = kf_vote["voting_active"] .as<bool>();
return params;
}
std::cout << "Bad configuration file. No processor type found." << std::endl;
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_prc_odom_3D = ProcessorParamsFactory::get().registerCreator("IMU", createProcessorIMUParams);
} // namespace [unnamed]
} // namespace wolf
src/yaml/processor_image_yaml.cpp deleted 100644 → 0
+ 0
− 68
View file @ 10c64adb
/**
* \file processor_image_yaml.cpp
*
* Created on: May 21, 2016
* \author: jsola
*/
// wolf yaml
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
#include "core/processor/processor_params_image.h"
namespace wolf
{
namespace
{
static ProcessorParamsBasePtr createProcessorParamsImage(const std::string & _filename_dot_yaml)
{
using std::string;
using YAML::Node;
std::shared_ptr<ProcessorParamsTrackerFeatureImage> p = std::make_shared<ProcessorParamsTrackerFeatureImage>();
Node params = YAML::LoadFile(_filename_dot_yaml);
if (!params.IsNull())
{
Node dd_yaml = params["vision_utils"];
p->yaml_file_params_vision_utils = dd_yaml["YAML file params"].as<std::string>();
// Check if relative path
if (!p->yaml_file_params_vision_utils.empty())
{
if (p->yaml_file_params_vision_utils[0] != '/')
{
std::string wolf_root = _WOLF_ROOT_DIR;
std::cout << "Wolf root: " << wolf_root << std::endl;
std::string abs_path = wolf_root + "/src/examples/" + p->yaml_file_params_vision_utils;
p->yaml_file_params_vision_utils = abs_path;
}
}
Node alg = params["algorithm"];
p->max_new_features = alg["maximum new features"].as<unsigned int>();
p->min_features_for_keyframe = alg["minimum features for new keyframe"].as<unsigned int>();
p->min_response_for_new_features = alg["minimum response for new features"].as<float>();
p->time_tolerance= alg["time tolerance"].as<Scalar>();
p->distance= alg["distance"].as<Scalar>();
Node noi = params["noise"];
p->pixel_noise_std = noi["pixel noise std"].as<Scalar>();
p->pixel_noise_var = p->pixel_noise_std * p->pixel_noise_std;
}
return p;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_prc_image_feature_par = ProcessorParamsFactory::get().registerCreator("IMAGE FEATURE", createProcessorParamsImage);
const bool WOLF_UNUSED registered_prc_image_landmark_par = ProcessorParamsFactory::get().registerCreator("IMAGE LANDMARK", createProcessorParamsImage);
}
}
src/yaml/processor_odom_3D_yaml.cpp deleted 100644 → 0
+ 0
− 51
View file @ 10c64adb
/**
* \file processor_odom_3D_yaml.cpp
*
* Created on: Oct 25, 2016
* \author: jsola
*/
// wolf yaml
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/processor/processor_odom_3D.h"
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static ProcessorParamsBasePtr createProcessorOdom3DParams(const std::string & _filename_dot_yaml)
{
YAML::Node config = YAML::LoadFile(_filename_dot_yaml);
if (config["processor type"].as<std::string>() == "ODOM 3D")
{
YAML::Node kf_vote = config["keyframe vote"];
ProcessorParamsOdom3DPtr params = std::make_shared<ProcessorParamsOdom3D>();
params->max_time_span = kf_vote["max time span"] .as<Scalar>();
params->max_buff_length = kf_vote["max buffer length"] .as<SizeEigen >();
params->dist_traveled = kf_vote["dist traveled"] .as<Scalar>();
params->angle_turned = kf_vote["angle turned"] .as<Scalar>();
return params;
}
std::cout << "Bad configuration file. No processor type found." << std::endl;
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_prc_odom_3D = ProcessorParamsFactory::get().registerCreator("ODOM 3D", createProcessorOdom3DParams);
} // namespace [unnamed]
} // namespace wolf
src/yaml/processor_tracker_feature_trifocal_yaml.cpp deleted 100644 → 0
+ 0
− 74
View file @ 10c64adb
/*
* processor_tracker_feature_trifocal_yaml.cpp
*
* Created on: Apr 12, 2018
* Author: asantamaria
*/
// wolf yaml
#include "core/processor/processor_tracker_feature_trifocal.h"
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static ProcessorParamsBasePtr createProcessorParamsTrackerFeatureTrifocal(const std::string & _filename_dot_yaml)
{
YAML::Node config = YAML::LoadFile(_filename_dot_yaml);
if (config.IsNull())
{
WOLF_ERROR("Invalid YAML file!");
return nullptr;
}
else if (config["processor type"].as<std::string>() == "TRACKER FEATURE TRIFOCAL")
{
ProcessorParamsTrackerFeatureTrifocalPtr params = std::make_shared<ProcessorParamsTrackerFeatureTrifocal>();
YAML::Node vision_utils = config ["vision_utils"];
params->yaml_file_params_vision_utils = vision_utils["YAML file params"].as<std::string>();
// relative to global path for Vision Utils YAML
assert(params->yaml_file_params_vision_utils.at(0) != ('/') && "The parameter YAML FILE PARAMS (in processor params YAML file) must be specified with a path relative to the processor YAML file.");
unsigned first = _filename_dot_yaml.find("/");
unsigned last = _filename_dot_yaml.find_last_of("/");
std::string strNew = _filename_dot_yaml.substr (first,last-first);
params->yaml_file_params_vision_utils = _filename_dot_yaml.substr (first,last-first) + "/" + params->yaml_file_params_vision_utils;
YAML::Node algorithm = config ["algorithm"];
params->time_tolerance = algorithm["time tolerance"] .as<Scalar>();
params->voting_active = algorithm["voting active"] .as<bool>();
params->min_features_for_keyframe = algorithm["minimum features for keyframe"] .as<unsigned int>();
params->max_new_features = algorithm["maximum new features"] .as<unsigned int>();
params->n_cells_h = algorithm["grid horiz cells"] .as<int>();
params->n_cells_v = algorithm["grid vert cells"] .as<int>();
params->min_response_new_feature = algorithm["min response new features"] .as<int>();
params->min_track_length_for_factor = algorithm["min track length for factor"].as<int>();
YAML::Node noise = config["noise"];
params->pixel_noise_std = noise ["pixel noise std"].as<Scalar>();
return params;
}
else
{
WOLF_ERROR("Wrong processor type! Should be \"TRACKER FEATURE TRIFOCAL\"");
return nullptr;
}
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_prc_trifocal = ProcessorParamsFactory::get().registerCreator("TRACKER FEATURE TRIFOCAL", createProcessorParamsTrackerFeatureTrifocal);
} // namespace [unnamed]
} // namespace wolf
src/yaml/sensor_IMU_yaml.cpp deleted 100644 → 0
+ 0
− 54
View file @ 10c64adb
/**
* \file sensor_imu_yaml.cpp
*
* Created on: Jan 18, 2017
* \author: Dinesh Atchuthan
*/
// wolf yaml
#include "core/sensor/sensor_IMU.h"
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static IntrinsicsBasePtr createIntrinsicsIMU(const std::string & _filename_dot_yaml)
{
YAML::Node config = YAML::LoadFile(_filename_dot_yaml);
if (config["sensor type"].as<std::string>() == "IMU")
{
YAML::Node variances = config["motion variances"];
YAML::Node kf_vote = config["keyframe vote"];
IntrinsicsIMUPtr params = std::make_shared<IntrinsicsIMU>();
params->a_noise = variances["a_noise"] .as<Scalar>();
params->w_noise = variances["w_noise"] .as<Scalar>();
params->ab_initial_stdev = variances["ab_initial_stdev"] .as<Scalar>();
params->wb_initial_stdev = variances["wb_initial_stdev"] .as<Scalar>();
params->ab_rate_stdev = variances["ab_rate_stdev"] .as<Scalar>();
params->wb_rate_stdev = variances["wb_rate_stdev"] .as<Scalar>();
return params;
}
std::cout << "Bad configuration file. No sensor type found." << std::endl;
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_imu_intr = IntrinsicsFactory::get().registerCreator("IMU", createIntrinsicsIMU);
} // namespace [unnamed]
} // namespace wolf
src/yaml/sensor_camera_yaml.cpp deleted 100644 → 0
+ 0
− 114
View file @ 10c64adb
/**
* \file sensor_camera_yaml.cpp
*
* Created on: May 13, 2016
* \author: jsola
*/
// wolf yaml
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/sensor/sensor_camera.h"
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static IntrinsicsBasePtr createIntrinsicsCamera(const std::string & _filename_dot_yaml)
{
YAML::Node camera_config = YAML::LoadFile(_filename_dot_yaml);
// if (camera_config["sensor type"].as<std::string>() == "CAMERA") // this does not work: camera YAML files are ROS-styled
if (camera_config["camera_matrix"]) // check that at least this field exists to validate YAML file of the correct type
{
// YAML:: to Eigen::
using namespace Eigen;
unsigned int width = camera_config["image_width"] .as<unsigned int>();
unsigned int height = camera_config["image_height"] .as<unsigned int>();
VectorXd distortion = camera_config["distortion_coefficients"]["data"] .as<VectorXd>();
VectorXd intrinsic = camera_config["camera_matrix"]["data"] .as<VectorXd>();
VectorXd projection = camera_config["projection_matrix"]["data"] .as<VectorXd>();
// Eigen:: to wolf::
std::shared_ptr<IntrinsicsCamera> intrinsics_cam = std::make_shared<IntrinsicsCamera>();
intrinsics_cam->width = width;
intrinsics_cam->height = height;
intrinsics_cam->pinhole_model_raw[0] = intrinsic[2];
intrinsics_cam->pinhole_model_raw[1] = intrinsic[5];
intrinsics_cam->pinhole_model_raw[2] = intrinsic[0];
intrinsics_cam->pinhole_model_raw[3] = intrinsic[4];
intrinsics_cam->pinhole_model_rectified[0] = projection[2];
intrinsics_cam->pinhole_model_rectified[1] = projection[6];
intrinsics_cam->pinhole_model_rectified[2] = projection[0];
intrinsics_cam->pinhole_model_rectified[3] = projection[5];
assert (distortion.size() == 5 && "Distortion size must be size 5!");
WOLF_WARN_COND( distortion(2) != 0 || distortion(3) != 0 , "Wolf does not handle tangential distortion. Please consider re-calibrating without tangential distortion!");
if (distortion(4) == 0)
if (distortion(1) == 0)
if (distortion(0) == 0)
intrinsics_cam->distortion.resize(0);
else
{
intrinsics_cam->distortion.resize(1);
intrinsics_cam->distortion = distortion.head<1>();
}
else
{
intrinsics_cam->distortion.resize(2);
intrinsics_cam->distortion = distortion.head<2>();
}
else
{
intrinsics_cam->distortion.resize(3);
intrinsics_cam->distortion.head<2>() = distortion.head<2>();
intrinsics_cam->distortion.tail<1>() = distortion.tail<1>();
}
//=========================================
// ===== this part for debugging only =====
//=========================================
// std::cout << "\n--- Parameters Parsed from YAML file ---" << std::endl;
// std::cout << "sensor type: " << sensor_type << std::endl;
// std::cout << "sensor name: " << sensor_name << std::endl;
// // extrinsics discarded in this creator
// Vector3d pos = camera_config["extrinsic"]["position"].as<Vector3d>();
// Vector3d ori = camera_config["extrinsic"]["orientation"].as<Vector3d>() * M_PI / 180; // roll, pitch, yaw [rad]
// Quaternions quat; v2q(ori, quat);
// std::cout << "sensor extrinsics: " << std::endl;
// std::cout << "\tposition : " << pos.transpose() << std::endl;
// std::cout << "\torientation : " << ori.transpose() << std::endl;
// std::cout << "sensor intrinsics: " << std::endl;
// std::cout << "\timage size : " << width << "x" << height << std::endl;
// std::cout << "\tintrinsic : " << intrinsic.transpose() << std::endl;
// std::cout << "\tdistoriton : " << distortion.transpose() << std::endl;
//=========================================
return intrinsics_cam;
}
std::cout << "Bad configuration file. No or bad sensor type found." << std::endl;
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_camera_intr = IntrinsicsFactory::get().registerCreator("CAMERA", createIntrinsicsCamera);
} // namespace [unnamed]
} // namespace wolf
src/yaml/sensor_laser_2D_yaml.cpp deleted 100644 → 0
+ 0
− 35
View file @ 10c64adb
/**
* \file sensor_laser_2D_yaml.cpp
*
* Created on: May 13, 2016
* \author: jsola
*/
// wolf yaml
#include "core/yaml/yaml_conversion.h"
// wolf
//#include "core/intrinsics_factory.h"
#include "core/factory.h"
#include "core/sensor/sensor_laser_2D.h"
// yaml library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace {
// intrinsics creator
IntrinsicsBasePtr createIntrinsicsLaser2D(const std::string& _filename_dot_yaml)
{
// If required: Parse YAML
IntrinsicsLaser2DPtr params; // dummy
return params;
}
// register into factory
const bool WOLF_UNUSED registered_laser_params = IntrinsicsFactory::get().registerCreator("LASER 2D", createIntrinsicsLaser2D);
} // namespace [void]
} // namespace wolf
src/yaml/sensor_odom_3D_yaml.cpp deleted 100644 → 0
+ 0
− 52
View file @ 10c64adb
/**
* \file sensor_odom_3D_yaml.cpp
*
* Created on: Oct 25, 2016
* \author: jsola
*/
// wolf yaml
#include "core/yaml/yaml_conversion.h"
// wolf
#include "core/sensor/sensor_odom_3D.h"
#include "core/factory.h"
// yaml-cpp library
#include <yaml-cpp/yaml.h>
namespace wolf
{
namespace
{
static IntrinsicsBasePtr createIntrinsicsOdom3D(const std::string & _filename_dot_yaml)
{
YAML::Node config = YAML::LoadFile(_filename_dot_yaml);
if (config["sensor type"].as<std::string>() == "ODOM 3D")
{
YAML::Node variances = config["motion variances"];
IntrinsicsOdom3DPtr params = std::make_shared<IntrinsicsOdom3D>();
params->k_disp_to_disp = variances["disp_to_disp"] .as<Scalar>();
params->k_disp_to_rot = variances["disp_to_rot"] .as<Scalar>();
params->k_rot_to_rot = variances["rot_to_rot"] .as<Scalar>();
params->min_disp_var = variances["min_disp_var"] .as<Scalar>();
params->min_rot_var = variances["min_rot_var"] .as<Scalar>();
return params;
}
std::cout << "Bad configuration file. No sensor type found." << std::endl;
return nullptr;
}
// Register in the SensorFactory
const bool WOLF_UNUSED registered_odom_3D_intr = IntrinsicsFactory::get().registerCreator("ODOM 3D", createIntrinsicsOdom3D);
} // namespace [unnamed]
} // namespace wolf
test/data/IMU/imu_static_biasNull.txt~ deleted 100644 → 0
+ 0
− 1003
View file @ 10c64adb
This diff is collapsed.
test/data/diff_drive/wheel_data.txt deleted 100644 → 0
+ 0
− 10782
View file @ 10c64adb
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment