Class robot_dart::Robot¶

ClassList > robot_dart > Robot

Inherits the following classes: std::enable_shared_from_this< Robot >

Inherited by the following classes: robot_dart::robots::A1, robot_dart::robots::Arm, robot_dart::robots::Franka, robot_dart::robots::Hexapod, robot_dart::robots::ICub, robot_dart::robots::Iiwa, robot_dart::robots::Pendulum, robot_dart::robots::Talos, robot_dart::robots::Tiago, robot_dart::robots::Ur3e, robot_dart::robots::Vx300

Public Functions¶

Type	Name
	Robot (const std::string & model_file, const std::vector< std::pair< std::string, std::string > > & packages, const std::string & robot_name="robot", bool is_urdf_string=false, bool cast_shadows=true)
	Robot (const std::string & model_file, const std::string & robot_name="robot", bool is_urdf_string=false, bool cast_shadows=true)
	Robot (dart::dynamics::SkeletonPtr skeleton, const std::string & robot_name="robot", bool cast_shadows=true)
Eigen::VectorXd	acceleration_lower_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	acceleration_upper_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	accelerations (const std::vector< std::string > & dof_names={}) const
std::vector< std::shared_ptr< control::RobotControl > >	active_controllers () const
std::string	actuator_type (const std::string & joint_name) const
std::vector< std::string >	actuator_types (const std::vector< std::string > & joint_names={}) const
void	add_body_mass (const std::string & body_name, double mass)
void	add_body_mass (size_t body_index, double mass)
void	add_controller (const std::shared_ptr< control::RobotControl > & controller, double weight=1.0)
void	add_external_force (const std::string & body_name, const Eigen::Vector3d & force, const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(), bool force_local=false, bool offset_local=true)
void	add_external_force (size_t body_index, const Eigen::Vector3d & force, const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(), bool force_local=false, bool offset_local=true)
void	add_external_torque (const std::string & body_name, const Eigen::Vector3d & torque, bool local=false)
void	add_external_torque (size_t body_index, const Eigen::Vector3d & torque, bool local=false)
bool	adjacent_colliding () const
Eigen::MatrixXd	aug_mass_matrix (const std::vector< std::string > & dof_names={}) const
Eigen::Isometry3d	base_pose () const
Eigen::Vector6d	base_pose_vec () const
Eigen::Vector6d	body_acceleration (const std::string & body_name) const
Eigen::Vector6d	body_acceleration (size_t body_index) const
size_t	body_index (const std::string & body_name) const
double	body_mass (const std::string & body_name) const
double	body_mass (size_t body_index) const
std::string	body_name (size_t body_index) const
std::vector< std::string >	body_names () const
dart::dynamics::BodyNode *	body_node (const std::string & body_name)
dart::dynamics::BodyNode *	body_node (size_t body_index)
Eigen::Isometry3d	body_pose (const std::string & body_name) const
Eigen::Isometry3d	body_pose (size_t body_index) const
Eigen::Vector6d	body_pose_vec (const std::string & body_name) const
Eigen::Vector6d	body_pose_vec (size_t body_index) const
Eigen::Vector6d	body_velocity (const std::string & body_name) const
Eigen::Vector6d	body_velocity (size_t body_index) const
bool	cast_shadows () const
void	clear_controllers ()
void	clear_external_forces ()
void	clear_internal_forces ()
std::shared_ptr< Robot >	clone () const
std::shared_ptr< Robot >	clone_ghost (const std::string & ghost_name="ghost", const Eigen::Vector4d & ghost_color={0.3, 0.3, 0.3, 0.7}) const
Eigen::Vector3d	com () const
Eigen::Vector6d	com_acceleration () const
Eigen::MatrixXd	com_jacobian (const std::vector< std::string > & dof_names={}) const
Eigen::MatrixXd	com_jacobian_deriv (const std::vector< std::string > & dof_names={}) const
Eigen::Vector6d	com_velocity () const
Eigen::VectorXd	commands (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	constraint_forces (const std::vector< std::string > & dof_names={}) const
std::shared_ptr< control::RobotControl >	controller (size_t index) const
std::vector< std::shared_ptr< control::RobotControl > >	controllers () const
Eigen::VectorXd	coriolis_forces (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	coriolis_gravity_forces (const std::vector< std::string > & dof_names={}) const
std::vector< double >	coulomb_coeffs (const std::vector< std::string > & dof_names={}) const
std::vector< double >	damping_coeffs (const std::vector< std::string > & dof_names={}) const
dart::dynamics::DegreeOfFreedom *	dof (const std::string & dof_name)
dart::dynamics::DegreeOfFreedom *	dof (size_t dof_index)
size_t	dof_index (const std::string & dof_name) const
const std::unordered_map< std::string, size_t > &	dof_map () const
std::string	dof_name (size_t dof_index) const
std::vector< std::string >	dof_names (bool filter_mimics=false, bool filter_locked=false, bool filter_passive=false) const
const std::vector< std::pair< dart::dynamics::BodyNode *, double > > &	drawing_axes () const
Eigen::Vector6d	external_forces (const std::string & body_name) const
Eigen::Vector6d	external_forces (size_t body_index) const
void	fix_to_world ()
bool	fixed () const
Eigen::VectorXd	force_lower_limits (const std::vector< std::string > & dof_names={}) const
void	force_position_bounds ()
std::pair< Eigen::Vector6d, Eigen::Vector6d >	force_torque (size_t joint_index) const
Eigen::VectorXd	force_upper_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	forces (const std::vector< std::string > & dof_names={}) const
bool	free () const
void	free_from_world (const Eigen::Vector6d & pose=Eigen::Vector6d::Zero())
double	friction_coeff (const std::string & body_name)
double	friction_coeff (size_t body_index)
Eigen::Vector3d	friction_dir (const std::string & body_name)
Eigen::Vector3d	friction_dir (size_t body_index)
bool	ghost () const
Eigen::VectorXd	gravity_forces (const std::vector< std::string > & dof_names={}) const
Eigen::MatrixXd	inv_aug_mass_matrix (const std::vector< std::string > & dof_names={}) const
Eigen::MatrixXd	inv_mass_matrix (const std::vector< std::string > & dof_names={}) const
Eigen::MatrixXd	jacobian (const std::string & body_name, const std::vector< std::string > & dof_names={}) const
Eigen::MatrixXd	jacobian_deriv (const std::string & body_name, const std::vector< std::string > & dof_names={}) const
dart::dynamics::Joint *	joint (const std::string & joint_name)
dart::dynamics::Joint *	joint (size_t joint_index)
size_t	joint_index (const std::string & joint_name) const
const std::unordered_map< std::string, size_t > &	joint_map () const
std::string	joint_name (size_t joint_index) const
std::vector< std::string >	joint_names () const
std::vector< std::string >	locked_dof_names () const
Eigen::MatrixXd	mass_matrix (const std::vector< std::string > & dof_names={}) const
std::vector< std::string >	mimic_dof_names () const
const std::string &	model_filename () const
const std::vector< std::pair< std::string, std::string > > &	model_packages () const
const std::string &	name () const
size_t	num_bodies () const
size_t	num_controllers () const
size_t	num_dofs () const
size_t	num_joints () const
std::vector< std::string >	passive_dof_names () const
std::vector< bool >	position_enforced (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	position_lower_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	position_upper_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	positions (const std::vector< std::string > & dof_names={}) const
void	reinit_controllers ()
void	remove_all_drawing_axis ()
void	remove_controller (const std::shared_ptr< control::RobotControl > & controller)
void	remove_controller (size_t index)
virtual void	reset ()
void	reset_commands ()
double	restitution_coeff (const std::string & body_name)
double	restitution_coeff (size_t body_index)
double	secondary_friction_coeff (const std::string & body_name)
double	secondary_friction_coeff (size_t body_index)
bool	self_colliding () const
void	set_acceleration_lower_limits (const Eigen::VectorXd & accelerations, const std::vector< std::string > & dof_names={})
void	set_acceleration_upper_limits (const Eigen::VectorXd & accelerations, const std::vector< std::string > & dof_names={})
void	set_accelerations (const Eigen::VectorXd & accelerations, const std::vector< std::string > & dof_names={})
void	set_actuator_type (const std::string & type, const std::string & joint_name, bool override_mimic=false, bool override_base=false)
void	set_actuator_types (const std::string & type, const std::vector< std::string > & joint_names={}, bool override_mimic=false, bool override_base=false)
void	set_base_pose (const Eigen::Isometry3d & tf)
void	set_base_pose (const Eigen::Vector6d & pose) set base pose: pose is a 6D vector (first 3D orientation in angle-axis and last 3D translation)
void	set_body_mass (const std::string & body_name, double mass)
void	set_body_mass (size_t body_index, double mass)
void	set_body_name (size_t body_index, const std::string & body_name)
void	set_cast_shadows (bool cast_shadows=true)
void	set_color_mode (const std::string & color_mode)
void	set_color_mode (const std::string & color_mode, const std::string & body_name)
void	set_commands (const Eigen::VectorXd & commands, const std::vector< std::string > & dof_names={})
void	set_coulomb_coeffs (const std::vector< double > & cfrictions, const std::vector< std::string > & dof_names={})
void	set_coulomb_coeffs (double cfriction, const std::vector< std::string > & dof_names={})
void	set_damping_coeffs (const std::vector< double > & damps, const std::vector< std::string > & dof_names={})
void	set_damping_coeffs (double damp, const std::vector< std::string > & dof_names={})
void	set_draw_axis (const std::string & body_name, double size=0.25)
void	set_external_force (const std::string & body_name, const Eigen::Vector3d & force, const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(), bool force_local=false, bool offset_local=true)
void	set_external_force (size_t body_index, const Eigen::Vector3d & force, const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(), bool force_local=false, bool offset_local=true)
void	set_external_torque (const std::string & body_name, const Eigen::Vector3d & torque, bool local=false)
void	set_external_torque (size_t body_index, const Eigen::Vector3d & torque, bool local=false)
void	set_force_lower_limits (const Eigen::VectorXd & forces, const std::vector< std::string > & dof_names={})
void	set_force_upper_limits (const Eigen::VectorXd & forces, const std::vector< std::string > & dof_names={})
void	set_forces (const Eigen::VectorXd & forces, const std::vector< std::string > & dof_names={})
void	set_friction_coeff (const std::string & body_name, double value)
void	set_friction_coeff (size_t body_index, double value)
void	set_friction_coeffs (double value)
void	set_friction_dir (const std::string & body_name, const Eigen::Vector3d & direction)
void	set_friction_dir (size_t body_index, const Eigen::Vector3d & direction)
void	set_ghost (bool ghost=true)
void	set_joint_name (size_t joint_index, const std::string & joint_name)
void	set_mimic (const std::string & joint_name, const std::string & mimic_joint_name, double multiplier=1., double offset=0.)
void	set_position_enforced (const std::vector< bool > & enforced, const std::vector< std::string > & dof_names={})
void	set_position_enforced (bool enforced, const std::vector< std::string > & dof_names={})
void	set_position_lower_limits (const Eigen::VectorXd & positions, const std::vector< std::string > & dof_names={})
void	set_position_upper_limits (const Eigen::VectorXd & positions, const std::vector< std::string > & dof_names={})
void	set_positions (const Eigen::VectorXd & positions, const std::vector< std::string > & dof_names={})
void	set_restitution_coeff (const std::string & body_name, double value)
void	set_restitution_coeff (size_t body_index, double value)
void	set_restitution_coeffs (double value)
void	set_secondary_friction_coeff (const std::string & body_name, double value)
void	set_secondary_friction_coeff (size_t body_index, double value)
void	set_secondary_friction_coeffs (double value)
void	set_self_collision (bool enable_self_collisions=true, bool enable_adjacent_collisions=false)
void	set_spring_stiffnesses (const std::vector< double > & stiffnesses, const std::vector< std::string > & dof_names={})
void	set_spring_stiffnesses (double stiffness, const std::vector< std::string > & dof_names={})
void	set_velocities (const Eigen::VectorXd & velocities, const std::vector< std::string > & dof_names={})
void	set_velocity_lower_limits (const Eigen::VectorXd & velocities, const std::vector< std::string > & dof_names={})
void	set_velocity_upper_limits (const Eigen::VectorXd & velocities, const std::vector< std::string > & dof_names={})
dart::dynamics::SkeletonPtr	skeleton ()
std::vector< double >	spring_stiffnesses (const std::vector< std::string > & dof_names={}) const
void	update (double t)
void	update_joint_dof_maps ()
Eigen::VectorXd	vec_dof (const Eigen::VectorXd & vec, const std::vector< std::string > & dof_names) const
Eigen::VectorXd	velocities (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	velocity_lower_limits (const std::vector< std::string > & dof_names={}) const
Eigen::VectorXd	velocity_upper_limits (const std::vector< std::string > & dof_names={}) const
virtual	~Robot ()

Public Static Functions¶

Type	Name
std::shared_ptr< Robot >	create_box (const Eigen::Vector3d & dims, const Eigen::Isometry3d & tf, const std::string & type="free", double mass=1.0, const Eigen::Vector4d & color=dart::Color::Red(1.0), const std::string & box_name="box")
std::shared_ptr< Robot >	create_box (const Eigen::Vector3d & dims, const Eigen::Vector6d & pose=Eigen::Vector6d::Zero(), const std::string & type="free", double mass=1.0, const Eigen::Vector4d & color=dart::Color::Red(1.0), const std::string & box_name="box")
std::shared_ptr< Robot >	create_ellipsoid (const Eigen::Vector3d & dims, const Eigen::Isometry3d & tf, const std::string & type="free", double mass=1.0, const Eigen::Vector4d & color=dart::Color::Red(1.0), const std::string & ellipsoid_name="ellipsoid")
std::shared_ptr< Robot >	create_ellipsoid (const Eigen::Vector3d & dims, const Eigen::Vector6d & pose=Eigen::Vector6d::Zero(), const std::string & type="free", double mass=1.0, const Eigen::Vector4d & color=dart::Color::Red(1.0), const std::string & ellipsoid_name="ellipsoid")

Protected Attributes¶

Type	Name
std::vector< std::pair< dart::dynamics::BodyNode *, double > >	_axis_shapes
bool	_cast_shadows
std::vector< std::shared_ptr< control::RobotControl > >	_controllers
std::unordered_map< std::string, size_t >	_dof_map
bool	_is_ghost
std::unordered_map< std::string, size_t >	_joint_map
std::string	_model_filename
std::vector< std::pair< std::string, std::string > >	_packages
std::string	_robot_name
dart::dynamics::SkeletonPtr	_skeleton

Protected Functions¶

Type	Name
dart::dynamics::Joint::ActuatorType	_actuator_type (size_t joint_index) const
std::vector< dart::dynamics::Joint::ActuatorType >	_actuator_types () const
std::string	_get_path (const std::string & filename) const
Eigen::MatrixXd	_jacobian (const Eigen::MatrixXd & full_jacobian, const std::vector< std::string > & dof_names) const
dart::dynamics::SkeletonPtr	_load_model (const std::string & filename, const std::vector< std::pair< std::string, std::string > > & packages=std::vector< std::pair< std::string, std::string > >(), bool is_urdf_string=false)
Eigen::MatrixXd	_mass_matrix (const Eigen::MatrixXd & full_mass_matrix, const std::vector< std::string > & dof_names) const
virtual void	_post_addition (RobotDARTSimu ) Function called by* RobotDARTSimu object when adding the robot to the world.
virtual void	_post_removal (RobotDARTSimu ) Function called by* RobotDARTSimu object when removing the robot to the world.
void	_set_actuator_type (size_t joint_index, dart::dynamics::Joint::ActuatorType type, bool override_mimic=false, bool override_base=false)
void	_set_actuator_types (const std::vector< dart::dynamics::Joint::ActuatorType > & types, bool override_mimic=false, bool override_base=false)
void	_set_actuator_types (dart::dynamics::Joint::ActuatorType type, bool override_mimic=false, bool override_base=false)
void	_set_color_mode (dart::dynamics::MeshShape::ColorMode color_mode, dart::dynamics::SkeletonPtr skel)
void	_set_color_mode (dart::dynamics::MeshShape::ColorMode color_mode, dart::dynamics::ShapeNode * sn)

Public Functions Documentation¶

function Robot [⅓]¶

robot_dart::Robot::Robot (
    const std::string & model_file,
    const std::vector< std::pair< std::string, std::string > > & packages,
    const std::string & robot_name="robot",
    bool is_urdf_string=false,
    bool cast_shadows=true
)

function Robot [⅔]¶

robot_dart::Robot::Robot (
    const std::string & model_file,
    const std::string & robot_name="robot",
    bool is_urdf_string=false,
    bool cast_shadows=true
)

function Robot [3/3]¶

robot_dart::Robot::Robot (
    dart::dynamics::SkeletonPtr skeleton,
    const std::string & robot_name="robot",
    bool cast_shadows=true
)

function acceleration_lower_limits¶

Eigen::VectorXd robot_dart::Robot::acceleration_lower_limits (
    const std::vector< std::string > & dof_names={}
) const

function acceleration_upper_limits¶

Eigen::VectorXd robot_dart::Robot::acceleration_upper_limits (
    const std::vector< std::string > & dof_names={}
) const

function accelerations¶

Eigen::VectorXd robot_dart::Robot::accelerations (
    const std::vector< std::string > & dof_names={}
) const

function active_controllers¶

std::vector< std::shared_ptr< control::RobotControl > > robot_dart::Robot::active_controllers () const

function actuator_type¶

std::string robot_dart::Robot::actuator_type (
    const std::string & joint_name
) const

function actuator_types¶

std::vector< std::string > robot_dart::Robot::actuator_types (
    const std::vector< std::string > & joint_names={}
) const

function add_body_mass [½]¶

void robot_dart::Robot::add_body_mass (
    const std::string & body_name,
    double mass
)

function add_body_mass [2/2]¶

void robot_dart::Robot::add_body_mass (
    size_t body_index,
    double mass
)

function add_controller¶

void robot_dart::Robot::add_controller (
    const std::shared_ptr< control::RobotControl > & controller,
    double weight=1.0
)

function add_external_force [½]¶

void robot_dart::Robot::add_external_force (
    const std::string & body_name,
    const Eigen::Vector3d & force,
    const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(),
    bool force_local=false,
    bool offset_local=true
)

function add_external_force [2/2]¶

void robot_dart::Robot::add_external_force (
    size_t body_index,
    const Eigen::Vector3d & force,
    const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(),
    bool force_local=false,
    bool offset_local=true
)

function add_external_torque [½]¶

void robot_dart::Robot::add_external_torque (
    const std::string & body_name,
    const Eigen::Vector3d & torque,
    bool local=false
)

function add_external_torque [2/2]¶

void robot_dart::Robot::add_external_torque (
    size_t body_index,
    const Eigen::Vector3d & torque,
    bool local=false
)

function adjacent_colliding¶

bool robot_dart::Robot::adjacent_colliding () const

function aug_mass_matrix¶

Eigen::MatrixXd robot_dart::Robot::aug_mass_matrix (
    const std::vector< std::string > & dof_names={}
) const

function base_pose¶

Eigen::Isometry3d robot_dart::Robot::base_pose () const

function base_pose_vec¶

Eigen::Vector6d robot_dart::Robot::base_pose_vec () const

function body_acceleration [½]¶

Eigen::Vector6d robot_dart::Robot::body_acceleration (
    const std::string & body_name
) const

function body_acceleration [2/2]¶

Eigen::Vector6d robot_dart::Robot::body_acceleration (
    size_t body_index
) const

function body_index¶

size_t robot_dart::Robot::body_index (
    const std::string & body_name
) const

function body_mass [½]¶

double robot_dart::Robot::body_mass (
    const std::string & body_name
) const

function body_mass [2/2]¶

double robot_dart::Robot::body_mass (
    size_t body_index
) const

function body_name¶

std::string robot_dart::Robot::body_name (
    size_t body_index
) const

function body_names¶

std::vector< std::string > robot_dart::Robot::body_names () const

function body_node [½]¶

dart::dynamics::BodyNode * robot_dart::Robot::body_node (
    const std::string & body_name
)

function body_node [2/2]¶

dart::dynamics::BodyNode * robot_dart::Robot::body_node (
    size_t body_index
)

function body_pose [½]¶

Eigen::Isometry3d robot_dart::Robot::body_pose (
    const std::string & body_name
) const

function body_pose [2/2]¶

Eigen::Isometry3d robot_dart::Robot::body_pose (
    size_t body_index
) const

function body_pose_vec [½]¶

Eigen::Vector6d robot_dart::Robot::body_pose_vec (
    const std::string & body_name
) const

function body_pose_vec [2/2]¶

Eigen::Vector6d robot_dart::Robot::body_pose_vec (
    size_t body_index
) const

function body_velocity [½]¶

Eigen::Vector6d robot_dart::Robot::body_velocity (
    const std::string & body_name
) const

function body_velocity [2/2]¶

Eigen::Vector6d robot_dart::Robot::body_velocity (
    size_t body_index
) const

function cast_shadows¶

bool robot_dart::Robot::cast_shadows () const

function clear_controllers¶

void robot_dart::Robot::clear_controllers ()

function clear_external_forces¶

void robot_dart::Robot::clear_external_forces ()

function clear_internal_forces¶

void robot_dart::Robot::clear_internal_forces ()

function clone¶

std::shared_ptr< Robot > robot_dart::Robot::clone () const

function clone_ghost¶

std::shared_ptr< Robot > robot_dart::Robot::clone_ghost (
    const std::string & ghost_name="ghost",
    const Eigen::Vector4d & ghost_color={0.3, 0.3, 0.3, 0.7}
) const

function com¶

Eigen::Vector3d robot_dart::Robot::com () const

function com_acceleration¶

Eigen::Vector6d robot_dart::Robot::com_acceleration () const

function com_jacobian¶

Eigen::MatrixXd robot_dart::Robot::com_jacobian (
    const std::vector< std::string > & dof_names={}
) const

function com_jacobian_deriv¶

Eigen::MatrixXd robot_dart::Robot::com_jacobian_deriv (
    const std::vector< std::string > & dof_names={}
) const

function com_velocity¶

Eigen::Vector6d robot_dart::Robot::com_velocity () const

function commands¶

Eigen::VectorXd robot_dart::Robot::commands (
    const std::vector< std::string > & dof_names={}
) const

function constraint_forces¶

Eigen::VectorXd robot_dart::Robot::constraint_forces (
    const std::vector< std::string > & dof_names={}
) const

function controller¶

std::shared_ptr< control::RobotControl > robot_dart::Robot::controller (
    size_t index
) const

function controllers¶

std::vector< std::shared_ptr< control::RobotControl > > robot_dart::Robot::controllers () const

function coriolis_forces¶

Eigen::VectorXd robot_dart::Robot::coriolis_forces (
    const std::vector< std::string > & dof_names={}
) const

function coriolis_gravity_forces¶

Eigen::VectorXd robot_dart::Robot::coriolis_gravity_forces (
    const std::vector< std::string > & dof_names={}
) const

function coulomb_coeffs¶

std::vector< double > robot_dart::Robot::coulomb_coeffs (
    const std::vector< std::string > & dof_names={}
) const

function damping_coeffs¶

std::vector< double > robot_dart::Robot::damping_coeffs (
    const std::vector< std::string > & dof_names={}
) const

function dof [½]¶

dart::dynamics::DegreeOfFreedom * robot_dart::Robot::dof (
    const std::string & dof_name
)

function dof [2/2]¶

dart::dynamics::DegreeOfFreedom * robot_dart::Robot::dof (
    size_t dof_index
)

function dof_index¶

size_t robot_dart::Robot::dof_index (
    const std::string & dof_name
) const

function dof_map¶

const std::unordered_map< std::string, size_t > & robot_dart::Robot::dof_map () const

function dof_name¶

std::string robot_dart::Robot::dof_name (
    size_t dof_index
) const

function dof_names¶

std::vector< std::string > robot_dart::Robot::dof_names (
    bool filter_mimics=false,
    bool filter_locked=false,
    bool filter_passive=false
) const

function drawing_axes¶

const std::vector< std::pair< dart::dynamics::BodyNode *, double > > & robot_dart::Robot::drawing_axes () const

function external_forces [½]¶

Eigen::Vector6d robot_dart::Robot::external_forces (
    const std::string & body_name
) const

function external_forces [2/2]¶

Eigen::Vector6d robot_dart::Robot::external_forces (
    size_t body_index
) const

function fix_to_world¶

void robot_dart::Robot::fix_to_world ()

function fixed¶

bool robot_dart::Robot::fixed () const

function force_lower_limits¶

Eigen::VectorXd robot_dart::Robot::force_lower_limits (
    const std::vector< std::string > & dof_names={}
) const

function force_position_bounds¶

void robot_dart::Robot::force_position_bounds ()

function force_torque¶

std::pair< Eigen::Vector6d, Eigen::Vector6d > robot_dart::Robot::force_torque (
    size_t joint_index
) const

function force_upper_limits¶

Eigen::VectorXd robot_dart::Robot::force_upper_limits (
    const std::vector< std::string > & dof_names={}
) const

function forces¶

Eigen::VectorXd robot_dart::Robot::forces (
    const std::vector< std::string > & dof_names={}
) const

function free¶

bool robot_dart::Robot::free () const

function free_from_world¶

void robot_dart::Robot::free_from_world (
    const Eigen::Vector6d & pose=Eigen::Vector6d::Zero()
)

function friction_coeff [½]¶

double robot_dart::Robot::friction_coeff (
    const std::string & body_name
)

function friction_coeff [2/2]¶

double robot_dart::Robot::friction_coeff (
    size_t body_index
)

function friction_dir [½]¶

Eigen::Vector3d robot_dart::Robot::friction_dir (
    const std::string & body_name
)

function friction_dir [2/2]¶

Eigen::Vector3d robot_dart::Robot::friction_dir (
    size_t body_index
)

function ghost¶

bool robot_dart::Robot::ghost () const

function gravity_forces¶

Eigen::VectorXd robot_dart::Robot::gravity_forces (
    const std::vector< std::string > & dof_names={}
) const

function inv_aug_mass_matrix¶

Eigen::MatrixXd robot_dart::Robot::inv_aug_mass_matrix (
    const std::vector< std::string > & dof_names={}
) const

function inv_mass_matrix¶

Eigen::MatrixXd robot_dart::Robot::inv_mass_matrix (
    const std::vector< std::string > & dof_names={}
) const

function jacobian¶

Eigen::MatrixXd robot_dart::Robot::jacobian (
    const std::string & body_name,
    const std::vector< std::string > & dof_names={}
) const

function jacobian_deriv¶

Eigen::MatrixXd robot_dart::Robot::jacobian_deriv (
    const std::string & body_name,
    const std::vector< std::string > & dof_names={}
) const

function joint [½]¶

dart::dynamics::Joint * robot_dart::Robot::joint (
    const std::string & joint_name
)

function joint [2/2]¶

dart::dynamics::Joint * robot_dart::Robot::joint (
    size_t joint_index
)

function joint_index¶

size_t robot_dart::Robot::joint_index (
    const std::string & joint_name
) const

function joint_map¶

const std::unordered_map< std::string, size_t > & robot_dart::Robot::joint_map () const

function joint_name¶

std::string robot_dart::Robot::joint_name (
    size_t joint_index
) const

function joint_names¶

std::vector< std::string > robot_dart::Robot::joint_names () const

function locked_dof_names¶

std::vector< std::string > robot_dart::Robot::locked_dof_names () const

function mass_matrix¶

Eigen::MatrixXd robot_dart::Robot::mass_matrix (
    const std::vector< std::string > & dof_names={}
) const

function mimic_dof_names¶

std::vector< std::string > robot_dart::Robot::mimic_dof_names () const

function model_filename¶

inline const std::string & robot_dart::Robot::model_filename () const

function model_packages¶

inline const std::vector< std::pair< std::string, std::string > > & robot_dart::Robot::model_packages () const

function name¶

const std::string & robot_dart::Robot::name () const

function num_bodies¶

size_t robot_dart::Robot::num_bodies () const

function num_controllers¶

size_t robot_dart::Robot::num_controllers () const

function num_dofs¶

size_t robot_dart::Robot::num_dofs () const

function num_joints¶

size_t robot_dart::Robot::num_joints () const

function passive_dof_names¶

std::vector< std::string > robot_dart::Robot::passive_dof_names () const

function position_enforced¶

std::vector< bool > robot_dart::Robot::position_enforced (
    const std::vector< std::string > & dof_names={}
) const

function position_lower_limits¶

Eigen::VectorXd robot_dart::Robot::position_lower_limits (
    const std::vector< std::string > & dof_names={}
) const

function position_upper_limits¶

Eigen::VectorXd robot_dart::Robot::position_upper_limits (
    const std::vector< std::string > & dof_names={}
) const

function positions¶

Eigen::VectorXd robot_dart::Robot::positions (
    const std::vector< std::string > & dof_names={}
) const

function reinit_controllers¶

void robot_dart::Robot::reinit_controllers ()

function remove_all_drawing_axis¶

void robot_dart::Robot::remove_all_drawing_axis ()

function remove_controller [½]¶

void robot_dart::Robot::remove_controller (
    const std::shared_ptr< control::RobotControl > & controller
)

function remove_controller [2/2]¶

void robot_dart::Robot::remove_controller (
    size_t index
)

function reset¶

virtual void robot_dart::Robot::reset ()

function reset_commands¶

void robot_dart::Robot::reset_commands ()

function restitution_coeff [½]¶

double robot_dart::Robot::restitution_coeff (
    const std::string & body_name
)

function restitution_coeff [2/2]¶

double robot_dart::Robot::restitution_coeff (
    size_t body_index
)

function secondary_friction_coeff [½]¶

double robot_dart::Robot::secondary_friction_coeff (
    const std::string & body_name
)

function secondary_friction_coeff [2/2]¶

double robot_dart::Robot::secondary_friction_coeff (
    size_t body_index
)

function self_colliding¶

bool robot_dart::Robot::self_colliding () const

function set_acceleration_lower_limits¶

void robot_dart::Robot::set_acceleration_lower_limits (
    const Eigen::VectorXd & accelerations,
    const std::vector< std::string > & dof_names={}
)

function set_acceleration_upper_limits¶

void robot_dart::Robot::set_acceleration_upper_limits (
    const Eigen::VectorXd & accelerations,
    const std::vector< std::string > & dof_names={}
)

function set_accelerations¶

void robot_dart::Robot::set_accelerations (
    const Eigen::VectorXd & accelerations,
    const std::vector< std::string > & dof_names={}
)

function set_actuator_type¶

void robot_dart::Robot::set_actuator_type (
    const std::string & type,
    const std::string & joint_name,
    bool override_mimic=false,
    bool override_base=false
)

function set_actuator_types¶

void robot_dart::Robot::set_actuator_types (
    const std::string & type,
    const std::vector< std::string > & joint_names={},
    bool override_mimic=false,
    bool override_base=false
)

function set_base_pose [½]¶

void robot_dart::Robot::set_base_pose (
    const Eigen::Isometry3d & tf
)

function set_base_pose [2/2]¶

void robot_dart::Robot::set_base_pose (
    const Eigen::Vector6d & pose
)

function set_body_mass [½]¶

void robot_dart::Robot::set_body_mass (
    const std::string & body_name,
    double mass
)

function set_body_mass [2/2]¶

void robot_dart::Robot::set_body_mass (
    size_t body_index,
    double mass
)

function set_body_name¶

void robot_dart::Robot::set_body_name (
    size_t body_index,
    const std::string & body_name
)

function set_cast_shadows¶

void robot_dart::Robot::set_cast_shadows (
    bool cast_shadows=true
)

function set_color_mode [½]¶

void robot_dart::Robot::set_color_mode (
    const std::string & color_mode
)

function set_color_mode [2/2]¶

void robot_dart::Robot::set_color_mode (
    const std::string & color_mode,
    const std::string & body_name
)

function set_commands¶

void robot_dart::Robot::set_commands (
    const Eigen::VectorXd & commands,
    const std::vector< std::string > & dof_names={}
)

function set_coulomb_coeffs [½]¶

void robot_dart::Robot::set_coulomb_coeffs (
    const std::vector< double > & cfrictions,
    const std::vector< std::string > & dof_names={}
)

function set_coulomb_coeffs [2/2]¶

void robot_dart::Robot::set_coulomb_coeffs (
    double cfriction,
    const std::vector< std::string > & dof_names={}
)

function set_damping_coeffs [½]¶

void robot_dart::Robot::set_damping_coeffs (
    const std::vector< double > & damps,
    const std::vector< std::string > & dof_names={}
)

function set_damping_coeffs [2/2]¶

void robot_dart::Robot::set_damping_coeffs (
    double damp,
    const std::vector< std::string > & dof_names={}
)

function set_draw_axis¶

void robot_dart::Robot::set_draw_axis (
    const std::string & body_name,
    double size=0.25
)

function set_external_force [½]¶

void robot_dart::Robot::set_external_force (
    const std::string & body_name,
    const Eigen::Vector3d & force,
    const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(),
    bool force_local=false,
    bool offset_local=true
)

function set_external_force [2/2]¶

void robot_dart::Robot::set_external_force (
    size_t body_index,
    const Eigen::Vector3d & force,
    const Eigen::Vector3d & offset=Eigen::Vector3d::Zero(),
    bool force_local=false,
    bool offset_local=true
)

function set_external_torque [½]¶

void robot_dart::Robot::set_external_torque (
    const std::string & body_name,
    const Eigen::Vector3d & torque,
    bool local=false
)

function set_external_torque [2/2]¶

void robot_dart::Robot::set_external_torque (
    size_t body_index,
    const Eigen::Vector3d & torque,
    bool local=false
)

function set_force_lower_limits¶

void robot_dart::Robot::set_force_lower_limits (
    const Eigen::VectorXd & forces,
    const std::vector< std::string > & dof_names={}
)

function set_force_upper_limits¶

void robot_dart::Robot::set_force_upper_limits (
    const Eigen::VectorXd & forces,
    const std::vector< std::string > & dof_names={}
)

function set_forces¶

void robot_dart::Robot::set_forces (
    const Eigen::VectorXd & forces,
    const std::vector< std::string > & dof_names={}
)

function set_friction_coeff [½]¶

void robot_dart::Robot::set_friction_coeff (
    const std::string & body_name,
    double value
)

function set_friction_coeff [2/2]¶

void robot_dart::Robot::set_friction_coeff (
    size_t body_index,
    double value
)

function set_friction_coeffs¶

void robot_dart::Robot::set_friction_coeffs (
    double value
)

function set_friction_dir [½]¶

void robot_dart::Robot::set_friction_dir (
    const std::string & body_name,
    const Eigen::Vector3d & direction
)

function set_friction_dir [2/2]¶

void robot_dart::Robot::set_friction_dir (
    size_t body_index,
    const Eigen::Vector3d & direction
)

function set_ghost¶

void robot_dart::Robot::set_ghost (
    bool ghost=true
)

function set_joint_name¶

void robot_dart::Robot::set_joint_name (
    size_t joint_index,
    const std::string & joint_name
)

function set_mimic¶

void robot_dart::Robot::set_mimic (
    const std::string & joint_name,
    const std::string & mimic_joint_name,
    double multiplier=1.,
    double offset=0.
)

function set_position_enforced [½]¶

void robot_dart::Robot::set_position_enforced (
    const std::vector< bool > & enforced,
    const std::vector< std::string > & dof_names={}
)

function set_position_enforced [2/2]¶

void robot_dart::Robot::set_position_enforced (
    bool enforced,
    const std::vector< std::string > & dof_names={}
)

function set_position_lower_limits¶

void robot_dart::Robot::set_position_lower_limits (
    const Eigen::VectorXd & positions,
    const std::vector< std::string > & dof_names={}
)

function set_position_upper_limits¶

void robot_dart::Robot::set_position_upper_limits (
    const Eigen::VectorXd & positions,
    const std::vector< std::string > & dof_names={}
)

function set_positions¶

void robot_dart::Robot::set_positions (
    const Eigen::VectorXd & positions,
    const std::vector< std::string > & dof_names={}
)

function set_restitution_coeff [½]¶

void robot_dart::Robot::set_restitution_coeff (
    const std::string & body_name,
    double value
)

function set_restitution_coeff [2/2]¶

void robot_dart::Robot::set_restitution_coeff (
    size_t body_index,
    double value
)

function set_restitution_coeffs¶

void robot_dart::Robot::set_restitution_coeffs (
    double value
)

function set_secondary_friction_coeff [½]¶

void robot_dart::Robot::set_secondary_friction_coeff (
    const std::string & body_name,
    double value
)

function set_secondary_friction_coeff [2/2]¶

void robot_dart::Robot::set_secondary_friction_coeff (
    size_t body_index,
    double value
)

function set_secondary_friction_coeffs¶

void robot_dart::Robot::set_secondary_friction_coeffs (
    double value
)

function set_self_collision¶

void robot_dart::Robot::set_self_collision (
    bool enable_self_collisions=true,
    bool enable_adjacent_collisions=false
)

function set_spring_stiffnesses [½]¶

void robot_dart::Robot::set_spring_stiffnesses (
    const std::vector< double > & stiffnesses,
    const std::vector< std::string > & dof_names={}
)

function set_spring_stiffnesses [2/2]¶

void robot_dart::Robot::set_spring_stiffnesses (
    double stiffness,
    const std::vector< std::string > & dof_names={}
)

function set_velocities¶

void robot_dart::Robot::set_velocities (
    const Eigen::VectorXd & velocities,
    const std::vector< std::string > & dof_names={}
)

function set_velocity_lower_limits¶

void robot_dart::Robot::set_velocity_lower_limits (
    const Eigen::VectorXd & velocities,
    const std::vector< std::string > & dof_names={}
)

function set_velocity_upper_limits¶

void robot_dart::Robot::set_velocity_upper_limits (
    const Eigen::VectorXd & velocities,
    const std::vector< std::string > & dof_names={}
)

function skeleton¶

dart::dynamics::SkeletonPtr robot_dart::Robot::skeleton ()

function spring_stiffnesses¶

std::vector< double > robot_dart::Robot::spring_stiffnesses (
    const std::vector< std::string > & dof_names={}
) const

function update¶

void robot_dart::Robot::update (
    double t
)

function update_joint_dof_maps¶

void robot_dart::Robot::update_joint_dof_maps ()

function vec_dof¶

Eigen::VectorXd robot_dart::Robot::vec_dof (
    const Eigen::VectorXd & vec,
    const std::vector< std::string > & dof_names
) const

function velocities¶

Eigen::VectorXd robot_dart::Robot::velocities (
    const std::vector< std::string > & dof_names={}
) const

function velocity_lower_limits¶

Eigen::VectorXd robot_dart::Robot::velocity_lower_limits (
    const std::vector< std::string > & dof_names={}
) const

function velocity_upper_limits¶

Eigen::VectorXd robot_dart::Robot::velocity_upper_limits (
    const std::vector< std::string > & dof_names={}
) const

function ~Robot¶

inline virtual robot_dart::Robot::~Robot ()

Public Static Functions Documentation¶

function create_box [½]¶

static std::shared_ptr< Robot > robot_dart::Robot::create_box (
    const Eigen::Vector3d & dims,
    const Eigen::Isometry3d & tf,
    const std::string & type="free",
    double mass=1.0,
    const Eigen::Vector4d & color=dart::Color::Red(1.0),
    const std::string & box_name="box"
)

function create_box [2/2]¶

static std::shared_ptr< Robot > robot_dart::Robot::create_box (
    const Eigen::Vector3d & dims,
    const Eigen::Vector6d & pose=Eigen::Vector6d::Zero(),
    const std::string & type="free",
    double mass=1.0,
    const Eigen::Vector4d & color=dart::Color::Red(1.0),
    const std::string & box_name="box"
)

function create_ellipsoid [½]¶

static std::shared_ptr< Robot > robot_dart::Robot::create_ellipsoid (
    const Eigen::Vector3d & dims,
    const Eigen::Isometry3d & tf,
    const std::string & type="free",
    double mass=1.0,
    const Eigen::Vector4d & color=dart::Color::Red(1.0),
    const std::string & ellipsoid_name="ellipsoid"
)

function create_ellipsoid [2/2]¶

static std::shared_ptr< Robot > robot_dart::Robot::create_ellipsoid (
    const Eigen::Vector3d & dims,
    const Eigen::Vector6d & pose=Eigen::Vector6d::Zero(),
    const std::string & type="free",
    double mass=1.0,
    const Eigen::Vector4d & color=dart::Color::Red(1.0),
    const std::string & ellipsoid_name="ellipsoid"
)

Protected Attributes Documentation¶

variable _axis_shapes¶

std::vector<std::pair<dart::dynamics::BodyNode*, double> > robot_dart::Robot::_axis_shapes;

variable _cast_shadows¶

bool robot_dart::Robot::_cast_shadows;

variable _controllers¶

std::vector<std::shared_ptr<control::RobotControl> > robot_dart::Robot::_controllers;

variable _dof_map¶

std::unordered_map<std::string, size_t> robot_dart::Robot::_dof_map;

variable _is_ghost¶

bool robot_dart::Robot::_is_ghost;

variable _joint_map¶

std::unordered_map<std::string, size_t> robot_dart::Robot::_joint_map;

variable _model_filename¶

std::string robot_dart::Robot::_model_filename;

variable _packages¶

std::vector<std::pair<std::string, std::string> > robot_dart::Robot::_packages;

variable _robot_name¶

std::string robot_dart::Robot::_robot_name;

variable _skeleton¶

dart::dynamics::SkeletonPtr robot_dart::Robot::_skeleton;

Protected Functions Documentation¶

function _actuator_type¶

dart::dynamics::Joint::ActuatorType robot_dart::Robot::_actuator_type (
    size_t joint_index
) const

function _actuator_types¶

std::vector< dart::dynamics::Joint::ActuatorType > robot_dart::Robot::_actuator_types () const

function _get_path¶

std::string robot_dart::Robot::_get_path (
    const std::string & filename
) const

function _jacobian¶

Eigen::MatrixXd robot_dart::Robot::_jacobian (
    const Eigen::MatrixXd & full_jacobian,
    const std::vector< std::string > & dof_names
) const

function _load_model¶

dart::dynamics::SkeletonPtr robot_dart::Robot::_load_model (
    const std::string & filename,
    const std::vector< std::pair< std::string, std::string > > & packages=std::vector< std::pair< std::string, std::string > >(),
    bool is_urdf_string=false
)

function _mass_matrix¶

Eigen::MatrixXd robot_dart::Robot::_mass_matrix (
    const Eigen::MatrixXd & full_mass_matrix,
    const std::vector< std::string > & dof_names
) const

function _post_addition¶

inline virtual void robot_dart::Robot::_post_addition (
    RobotDARTSimu *
)

function _post_removal¶

inline virtual void robot_dart::Robot::_post_removal (
    RobotDARTSimu *
)

function _set_actuator_type¶

void robot_dart::Robot::_set_actuator_type (
    size_t joint_index,
    dart::dynamics::Joint::ActuatorType type,
    bool override_mimic=false,
    bool override_base=false
)

function _set_actuator_types [½]¶

void robot_dart::Robot::_set_actuator_types (
    const std::vector< dart::dynamics::Joint::ActuatorType > & types,
    bool override_mimic=false,
    bool override_base=false
)

function _set_actuator_types [2/2]¶

void robot_dart::Robot::_set_actuator_types (
    dart::dynamics::Joint::ActuatorType type,
    bool override_mimic=false,
    bool override_base=false
)

function _set_color_mode [½]¶

void robot_dart::Robot::_set_color_mode (
    dart::dynamics::MeshShape::ColorMode color_mode,
    dart::dynamics::SkeletonPtr skel
)

function _set_color_mode [2/2]¶

void robot_dart::Robot::_set_color_mode (
    dart::dynamics::MeshShape::ColorMode color_mode,
    dart::dynamics::ShapeNode * sn
)

The documentation for this class was generated from the following file robot_dart/robot.hpp