common.h

Go to the documentation of this file.

/*
 * Copyright 2012-2020 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <RBDyn/Joint.h>
#include <RBDyn/MultiBody.h>
#include <RBDyn/MultiBodyConfig.h>
#include <RBDyn/MultiBodyGraph.h>
#include <RBDyn/parsers/api.h>
 
#include <SpaceVecAlg/SpaceVecAlg>
 
#include <boost/variant.hpp>
 
#include <Eigen/Core>
#include <string>
 
namespace rbd
{
 
namespace parsers
{
 
enum class ParserInput
{
  File,
  Description
};
 
struct RBDYN_PARSERS_DLLAPI Limits
{
public:
  std::map<std::string, std::vector<double>> lower;
  std::map<std::string, std::vector<double>> upper;
  std::map<std::string, std::vector<double>> velocity;
  std::map<std::string, std::vector<double>> torque;
};
 
struct RBDYN_PARSERS_DLLAPI Geometry
{
public:
  struct Mesh
  {
    Mesh() : scaleV(Eigen::Vector3d::Ones()) {}
    std::string filename;
    Eigen::Vector3d scaleV;
  };
  struct Box
  {
    Box() : size(Eigen::Vector3d::Zero()) {}
    Eigen::Vector3d size;
  };
  struct Cylinder
  {
    Cylinder() : radius(0.), length(0.) {}
    double radius;
    double length;
  };
  struct Sphere
  {
    Sphere() : radius(0.) {}
    double radius;
  };
 
  struct Superellipsoid
  {
    Superellipsoid() : size(Eigen::Vector3d::Zero()), epsilon1(1), epsilon2(1) {}
    Eigen::Vector3d size;
    double epsilon1, epsilon2;
  };
 
  enum Type
  {
    BOX,
    CYLINDER,
    SPHERE,
    MESH,
    SUPERELLIPSOID,
    UNKNOWN
  };
  Type type;
  using Data = boost::variant<Box, Cylinder, Mesh, Sphere, Superellipsoid>;
  Data data;
 
  Geometry() : type(UNKNOWN) {}
};
 
struct RBDYN_PARSERS_DLLAPI Material
{
  struct Color
  {
    double r;
    double g;
    double b;
    double a;
  };
  struct Texture
  {
    std::string filename;
  };
 
  enum class Type
  {
    NONE,
    COLOR,
    TEXTURE
  };
  Type type;
  using Data = boost::variant<Color, Texture>;
  Data data;
 
  Material() : type(Type::NONE) {}
};
 
struct RBDYN_PARSERS_DLLAPI Visual
{
  std::string name;
  sva::PTransformd origin;
  Geometry geometry;
  Material material;
};
 
struct RBDYN_PARSERS_DLLAPI ParserParameters
{
  bool fixed_ = true;
 
  std::vector<std::string> filtered_links_ = {};
 
  bool remove_filtered_links_ = true;
 
  bool transform_inertia_ = true;
 
  std::string base_link_ = "";
 
  bool remove_virtual_links_ = false;
 
  std::string spherical_suffix_ = "_spherical";
 
  inline ParserParameters & fixed(bool fixed) noexcept
  {
    fixed_ = fixed;
    return *this;
  }
 
  inline ParserParameters & filtered_links(const std::vector<std::string> & links) noexcept
  {
    filtered_links_ = links;
    return *this;
  }
 
  inline ParserParameters & remove_filtered_links(bool value) noexcept
  {
    remove_filtered_links_ = value;
    return *this;
  }
 
  inline ParserParameters & transform_inertia(bool value) noexcept
  {
    transform_inertia_ = value;
    return *this;
  }
 
  inline ParserParameters & base_link(const std::string & link) noexcept
  {
    base_link_ = link;
    return *this;
  }
 
  inline ParserParameters & remove_virtual_links(bool value) noexcept
  {
    remove_virtual_links_ = value;
    return *this;
  }
 
  inline ParserParameters & spherical_suffix(const std::string & suffix) noexcept
  {
    spherical_suffix_ = suffix;
    return *this;
  }
};
 
struct RBDYN_PARSERS_DLLAPI ParserResult
{
  rbd::MultiBody mb;
  rbd::MultiBodyConfig mbc;
  rbd::MultiBodyGraph mbg;
  Limits limits;
  std::map<std::string, std::vector<Visual>> visual;
  std::map<std::string, std::vector<Visual>> collision;
  std::string name;
};
 
RBDYN_PARSERS_DLLAPI ParserResult from_file(const std::string & file_path,
                                            bool fixed = true,
                                            const std::vector<std::string> & filtered_links = {},
                                            bool transform_inertia = true,
                                            const std::string & base_link = "",
                                            bool with_virtual_links = true,
                                            const std::string spherical_suffix = "_spherical");
 
RBDYN_PARSERS_DLLAPI ParserResult from_file(const std::string & file_path, const ParserParameters & params);
 
RBDYN_PARSERS_DLLAPI std::string prefix_path(const std::string & path);
 
} // namespace parsers
 
} // namespace rbd