moveit::core::RobotState Class Reference

Representation of a robot's state. This includes position, velocity, acceleration and effort. More...

#include <robot_state.h>

Public Member Functions
	RobotState (const RobotModelConstPtr &robot_model)
	A state can be constructed from a specified robot model. No values are initialized. Call setToDefaultValues() if a state needs to provide valid information.
	~RobotState ()
	RobotState (const RobotState &other)
	Copy constructor.
RobotState &	operator= (const RobotState &other)
	Copy operator.
const RobotModelConstPtr &	getRobotModel () const
	Get the robot model this state is constructed for.
std::size_t	getVariableCount () const
	Get the number of variables that make up this state.
const std::vector< std::string > &	getVariableNames () const
	Get the names of the variables that make up this state, in the order they are stored in memory.
const LinkModel *	getLinkModel (const std::string &link) const
	Get the model of a particular link.
const JointModel *	getJointModel (const std::string &joint) const
	Get the model of a particular joint.
const JointModelGroup *	getJointModelGroup (const std::string &group) const
	Get the model of a particular joint group.
void	computeAABB (std::vector< double > &aabb) const
	Compute an axis-aligned bounding box that contains the current state. The format for aabb is (minx, maxx, miny, maxy, minz, maxz)
void	computeAABB (std::vector< double > &aabb)
	Compute an axis-aligned bounding box that contains the current state. The format for aabb is (minx, maxx, miny, maxy, minz, maxz)
random_numbers::RandomNumberGenerator &	getRandomNumberGenerator ()
	Return the instance of a random number generator.
const Eigen::Isometry3d &	getFrameTransform (const std::string &frame_id, bool *frame_found=nullptr)
	Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.
const Eigen::Isometry3d &	getFrameTransform (const std::string &frame_id, bool *frame_found=nullptr) const
	Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.
const Eigen::Isometry3d &	getFrameInfo (const std::string &frame_id, const LinkModel *&robot_link, bool &frame_found) const
	Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.
bool	knowsFrameTransform (const std::string &frame_id) const
	Check if a transformation matrix from the model frame (root of model) to frame frame_id is known.
void	getRobotMarkers (visualization_msgs::msg::MarkerArray &arr, const std::vector< std::string > &link_names, const std_msgs::msg::ColorRGBA &color, const std::string &ns, const rclcpp::Duration &dur, bool include_attached=false) const
	Get a MarkerArray that fully describes the robot markers for a given robot.
void	getRobotMarkers (visualization_msgs::msg::MarkerArray &arr, const std::vector< std::string > &link_names, const std_msgs::msg::ColorRGBA &color, const std::string &ns, const rclcpp::Duration &dur, bool include_attached=false)
	Get a MarkerArray that fully describes the robot markers for a given robot. Update the state first.
void	getRobotMarkers (visualization_msgs::msg::MarkerArray &arr, const std::vector< std::string > &link_names, bool include_attached=false) const
	Get a MarkerArray that fully describes the robot markers for a given robot.
void	getRobotMarkers (visualization_msgs::msg::MarkerArray &arr, const std::vector< std::string > &link_names, bool include_attached=false)
	Get a MarkerArray that fully describes the robot markers for a given robot. Update the state first.
void	printStatePositions (std::ostream &out=std::cout) const
void	printStatePositionsWithJointLimits (const moveit::core::JointModelGroup *jmg, std::ostream &out=std::cout) const
	Output to console the current state of the robot's joint limits.
void	printStateInfo (std::ostream &out=std::cout) const
void	printTransforms (std::ostream &out=std::cout) const
void	printTransform (const Eigen::Isometry3d &transform, std::ostream &out=std::cout) const
void	printDirtyInfo (std::ostream &out=std::cout) const
std::string	getStateTreeString () const
bool	setToIKSolverFrame (Eigen::Isometry3d &pose, const kinematics::KinematicsBaseConstPtr &solver)
	Transform pose from the robot model's base frame to the reference frame of the IK solver.
bool	setToIKSolverFrame (Eigen::Isometry3d &pose, const std::string &ik_frame)
	Transform pose from the robot model's base frame to the reference frame of the IK solver.
Getting and setting variable position
double *	getVariablePositions ()
	Get a raw pointer to the positions of the variables stored in this state. Use carefully. If you change these values externally you need to make sure you trigger a forced update for the state by calling update(true).
const double *	getVariablePositions () const
	Get a raw pointer to the positions of the variables stored in this state.
void	setVariablePositions (const double *position)
	It is assumed positions is an array containing the new positions for all variables in this state. Those values are copied into the state.
void	setVariablePositions (const std::vector< double > &position)
	It is assumed positions is an array containing the new positions for all variables in this state. Those values are copied into the state.
void	setVariablePositions (const std::map< std::string, double > &variable_map)
	Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariablePositions (const std::map< std::string, double > &variable_map, std::vector< std::string > &missing_variables)
	Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.
void	setVariablePositions (const std::vector< std::string > &variable_names, const std::vector< double > &variable_position)
	Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.
void	setVariablePosition (const std::string &variable, double value)
	Set the position of a single variable. An exception is thrown if the variable name is not known.
void	setVariablePosition (int index, double value)
	Set the position of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)
double	getVariablePosition (const std::string &variable) const
	Get the position of a particular variable. An exception is thrown if the variable is not known.
double	getVariablePosition (int index) const
	Get the position of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed
Getting and setting variable velocity
bool	hasVelocities () const
	By default, if velocities are never set or initialized, the state remembers that there are no velocities set. This is useful to know when serializing or copying the state.
double *	getVariableVelocities ()
	Get raw access to the velocities of the variables that make up this state. The values are in the same order as reported by getVariableNames()
const double *	getVariableVelocities () const
	Get const access to the velocities of the variables that make up this state. The values are in the same order as reported by getVariableNames()
void	zeroVelocities ()
	Set all velocities to 0.0.
void	setVariableVelocities (const double *velocity)
	Given an array with velocity values for all variables, set those values as the velocities in this state.
void	setVariableVelocities (const std::vector< double > &velocity)
	Given an array with velocity values for all variables, set those values as the velocities in this state.
void	setVariableVelocities (const std::map< std::string, double > &variable_map)
	Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableVelocities (const std::map< std::string, double > &variable_map, std::vector< std::string > &missing_variables)
	Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.
void	setVariableVelocities (const std::vector< std::string > &variable_names, const std::vector< double > &variable_velocity)
	Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableVelocity (const std::string &variable, double value)
	Set the velocity of a variable. If an unknown variable name is specified, an exception is thrown.
void	setVariableVelocity (int index, double value)
	Set the velocity of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)
double	getVariableVelocity (const std::string &variable) const
	Get the velocity of a particular variable. An exception is thrown if the variable is not known.
double	getVariableVelocity (int index) const
	Get the velocity of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed
void	dropVelocities ()
	Remove velocities from this state (this differs from setting them to zero)
Getting and setting variable acceleration
bool	hasAccelerations () const
	By default, if accelerations are never set or initialized, the state remembers that there are no accelerations set. This is useful to know when serializing or copying the state. If hasAccelerations() reports true, hasEffort() will certainly report false.
double *	getVariableAccelerations ()
	Get raw access to the accelerations of the variables that make up this state. The values are in the same order as reported by getVariableNames(). The area of memory overlaps with effort (effort and acceleration should not be set at the same time)
const double *	getVariableAccelerations () const
	Get const raw access to the accelerations of the variables that make up this state. The values are in the same order as reported by getVariableNames()
void	zeroAccelerations ()
	Set all accelerations to 0.0.
void	setVariableAccelerations (const double *acceleration)
	Given an array with acceleration values for all variables, set those values as the accelerations in this state.
void	setVariableAccelerations (const std::vector< double > &acceleration)
	Given an array with acceleration values for all variables, set those values as the accelerations in this state.
void	setVariableAccelerations (const std::map< std::string, double > &variable_map)
	Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableAccelerations (const std::map< std::string, double > &variable_map, std::vector< std::string > &missing_variables)
	Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.
void	setVariableAccelerations (const std::vector< std::string > &variable_names, const std::vector< double > &variable_acceleration)
	Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableAcceleration (const std::string &variable, double value)
	Set the acceleration of a variable. If an unknown variable name is specified, an exception is thrown.
void	setVariableAcceleration (int index, double value)
	Set the acceleration of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)
double	getVariableAcceleration (const std::string &variable) const
	Get the acceleration of a particular variable. An exception is thrown if the variable is not known.
double	getVariableAcceleration (int index) const
	Get the acceleration of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed
void	dropAccelerations ()
	Remove accelerations from this state (this differs from setting them to zero)
Getting and setting variable effort
bool	hasEffort () const
	By default, if effort is never set or initialized, the state remembers that there is no effort set. This is useful to know when serializing or copying the state. If hasEffort() reports true, hasAccelerations() will certainly report false.
double *	getVariableEffort ()
	Get raw access to the effort of the variables that make up this state. The values are in the same order as reported by getVariableNames(). The area of memory overlaps with accelerations (effort and acceleration should not be set at the same time)
const double *	getVariableEffort () const
	Get const raw access to the effort of the variables that make up this state. The values are in the same order as reported by getVariableNames().
void	zeroEffort ()
	Set all effort values to 0.0.
void	setVariableEffort (const double *effort)
	Given an array with effort values for all variables, set those values as the effort in this state.
void	setVariableEffort (const std::vector< double > &effort)
	Given an array with effort values for all variables, set those values as the effort in this state.
void	setVariableEffort (const std::map< std::string, double > &variable_map)
	Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableEffort (const std::map< std::string, double > &variable_map, std::vector< std::string > &missing_variables)
	Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.
void	setVariableEffort (const std::vector< std::string > &variable_names, const std::vector< double > &variable_acceleration)
	Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown.
void	setVariableEffort (const std::string &variable, double value)
	Set the effort of a variable. If an unknown variable name is specified, an exception is thrown.
void	setVariableEffort (int index, double value)
	Set the effort of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)
double	getVariableEffort (const std::string &variable) const
	Get the effort of a particular variable. An exception is thrown if the variable is not known.
double	getVariableEffort (int index) const
	Get the effort of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed
void	dropEffort ()
	Remove effort values from this state (this differs from setting them to zero)
void	dropDynamics ()
	Reduce RobotState to kinematic information (remove velocity, acceleration and effort, if present)
void	invertVelocity ()
	Invert velocity if present.
Getting and setting joint positions, velocities, accelerations and effort for a single joint
The joint might be multi-DOF, i.e. require more than one variable to set. See setVariablePositions(), setVariableVelocities(), setVariableEffort() to handle multiple joints.
void	setJointPositions (const std::string &joint_name, const double *position)
void	setJointPositions (const std::string &joint_name, const std::vector< double > &position)
void	setJointPositions (const JointModel *joint, const std::vector< double > &position)
void	setJointPositions (const JointModel *joint, const double *position)
void	setJointPositions (const std::string &joint_name, const Eigen::Isometry3d &transform)
void	setJointPositions (const JointModel *joint, const Eigen::Isometry3d &transform)
void	setJointVelocities (const JointModel *joint, const double *velocity)
void	setJointEfforts (const JointModel *joint, const double *effort)
const double *	getJointPositions (const std::string &joint_name) const
const double *	getJointPositions (const JointModel *joint) const
const double *	getJointVelocities (const std::string &joint_name) const
const double *	getJointVelocities (const JointModel *joint) const
const double *	getJointAccelerations (const std::string &joint_name) const
const double *	getJointAccelerations (const JointModel *joint) const
const double *	getJointEffort (const std::string &joint_name) const
const double *	getJointEffort (const JointModel *joint) const
Getting and setting group positions
void	setJointGroupPositions (const std::string &joint_group_name, const double *gstate)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupPositions (const std::string &joint_group_name, const std::vector< double > &gstate)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupPositions (const JointModelGroup *group, const std::vector< double > &gstate)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupPositions (const JointModelGroup *group, const double *gstate)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupPositions (const std::string &joint_group_name, const Eigen::VectorXd &values)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupPositions (const JointModelGroup *group, const Eigen::VectorXd &values)
	Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupActivePositions (const JointModelGroup *group, const std::vector< double > &gstate)
	Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupActivePositions (const std::string &joint_group_name, const std::vector< double > &gstate)
	Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupActivePositions (const JointModelGroup *group, const Eigen::VectorXd &values)
	Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupActivePositions (const std::string &joint_group_name, const Eigen::VectorXd &values)
	Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.
void	copyJointGroupPositions (const std::string &joint_group_name, std::vector< double > &gstate) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupPositions (const std::string &joint_group_name, double *gstate) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupPositions (const JointModelGroup *group, std::vector< double > &gstate) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupPositions (const JointModelGroup *group, double *gstate) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupPositions (const std::string &joint_group_name, Eigen::VectorXd &values) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupPositions (const JointModelGroup *group, Eigen::VectorXd &values) const
	For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
Getting and setting group velocities
void	setJointGroupVelocities (const std::string &joint_group_name, const double *gstate)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupVelocities (const std::string &joint_group_name, const std::vector< double > &gstate)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupVelocities (const JointModelGroup *group, const std::vector< double > &gstate)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupVelocities (const JointModelGroup *group, const double *gstate)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupVelocities (const std::string &joint_group_name, const Eigen::VectorXd &values)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupVelocities (const JointModelGroup *group, const Eigen::VectorXd &values)
	Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	copyJointGroupVelocities (const std::string &joint_group_name, std::vector< double > &gstate) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupVelocities (const std::string &joint_group_name, double *gstate) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupVelocities (const JointModelGroup *group, std::vector< double > &gstate) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupVelocities (const JointModelGroup *group, double *gstate) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupVelocities (const std::string &joint_group_name, Eigen::VectorXd &values) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupVelocities (const JointModelGroup *group, Eigen::VectorXd &values) const
	For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
Getting and setting group accelerations
void	setJointGroupAccelerations (const std::string &joint_group_name, const double *gstate)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupAccelerations (const std::string &joint_group_name, const std::vector< double > &gstate)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupAccelerations (const JointModelGroup *group, const std::vector< double > &gstate)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupAccelerations (const JointModelGroup *group, const double *gstate)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupAccelerations (const std::string &joint_group_name, const Eigen::VectorXd &values)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	setJointGroupAccelerations (const JointModelGroup *group, const Eigen::VectorXd &values)
	Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.
void	copyJointGroupAccelerations (const std::string &joint_group_name, std::vector< double > &gstate) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupAccelerations (const std::string &joint_group_name, double *gstate) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupAccelerations (const JointModelGroup *group, std::vector< double > &gstate) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupAccelerations (const JointModelGroup *group, double *gstate) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupAccelerations (const std::string &joint_group_name, Eigen::VectorXd &values) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
void	copyJointGroupAccelerations (const JointModelGroup *group, Eigen::VectorXd &values) const
	For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.
Setting from Inverse Kinematics
bool	setFromIK (const JointModelGroup *group, const geometry_msgs::msg::Pose &pose, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const geometry_msgs::msg::Pose &pose, const std::string &tip, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const Eigen::Isometry3d &pose, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const Eigen::Isometry3d &pose, const std::string &tip, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const Eigen::Isometry3d &pose, const std::string &tip, const std::vector< double > &consistency_limits, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const EigenSTL::vector_Isometry3d &poses, const std::vector< std::string > &tips, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	Warning: This function inefficiently copies all transforms around. If the group consists of a set of sub-groups that are each a chain and a solver is available for each sub-group, then the joint values can be set by computing inverse kinematics. The poses are assumed to be in the reference frame of the kinematic model. The poses are assumed to be in the same order as the order of the sub-groups in this group. Returns true on success.
bool	setFromIK (const JointModelGroup *group, const EigenSTL::vector_Isometry3d &poses, const std::vector< std::string > &tips, const std::vector< std::vector< double > > &consistency_limits, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions(), const kinematics::KinematicsBase::IKCostFn &cost_function=kinematics::KinematicsBase::IKCostFn())
	Warning: This function inefficiently copies all transforms around. If the group consists of a set of sub-groups that are each a chain and a solver is available for each sub-group, then the joint values can be set by computing inverse kinematics. The poses are assumed to be in the reference frame of the kinematic model. The poses are assumed to be in the same order as the order of the sub-groups in this group. Returns true on success.
bool	setFromIKSubgroups (const JointModelGroup *group, const EigenSTL::vector_Isometry3d &poses, const std::vector< std::string > &tips, const std::vector< std::vector< double > > &consistency_limits, double timeout=0.0, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn(), const kinematics::KinematicsQueryOptions &options=kinematics::KinematicsQueryOptions())
	setFromIK for multiple poses and tips (end effectors) when no solver exists for the jmg that can solver for non-chain kinematics. In this case, we divide the group into subgroups and do IK solving individually
bool	setFromDiffIK (const JointModelGroup *group, const Eigen::VectorXd &twist, const std::string &tip, double dt, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn())
	Set the joint values from a Cartesian velocity applied during a time dt.
bool	setFromDiffIK (const JointModelGroup *group, const geometry_msgs::msg::Twist &twist, const std::string &tip, double dt, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn())
	Set the joint values from a Cartesian velocity applied during a time dt.
bool	getJacobian (const JointModelGroup *group, const LinkModel *link, const Eigen::Vector3d &reference_point_position, Eigen::MatrixXd &jacobian, bool use_quaternion_representation=false) const
	Compute the Jacobian with reference to a particular point on a given link, for a specified group.
bool	getJacobian (const JointModelGroup *group, const LinkModel *link, const Eigen::Vector3d &reference_point_position, Eigen::MatrixXd &jacobian, bool use_quaternion_representation=false)
	Compute the Jacobian with reference to a particular point on a given link, for a specified group.
Eigen::MatrixXd	getJacobian (const JointModelGroup *group, const Eigen::Vector3d &reference_point_position=Eigen::Vector3d(0.0, 0.0, 0.0)) const
	Compute the Jacobian with reference to the last link of a specified group, and origin at the group root link. If the group is not a chain, an exception is thrown.
Eigen::MatrixXd	getJacobian (const JointModelGroup *group, const Eigen::Vector3d &reference_point_position=Eigen::Vector3d(0.0, 0.0, 0.0))
	Compute the Jacobian with reference to the last link of a specified group, and origin at the group root link. If the group is not a chain, an exception is thrown.
void	computeVariableVelocity (const JointModelGroup *jmg, Eigen::VectorXd &qdot, const Eigen::VectorXd &twist, const LinkModel *tip) const
	Given a twist for a particular link (tip), compute the corresponding velocity for every variable and store it in qdot.
void	computeVariableVelocity (const JointModelGroup *jmg, Eigen::VectorXd &qdot, const Eigen::VectorXd &twist, const LinkModel *tip)
	Given a twist for a particular link (tip), compute the corresponding velocity for every variable and store it in qdot.
bool	integrateVariableVelocity (const JointModelGroup *jmg, const Eigen::VectorXd &qdot, double dt, const GroupStateValidityCallbackFn &constraint=GroupStateValidityCallbackFn())
	Given the velocities for the variables in this group (qdot) and an amount of time (dt), update the current state using the Euler forward method. If the constraint specified is satisfied, return true, otherwise return false.
Getting and setting whole states
void	setVariableValues (const sensor_msgs::msg::JointState &msg)
void	setToDefaultValues ()
	Set all joints to their default positions. The default position is 0, or if that is not within bounds then half way between min and max bound.
bool	setToDefaultValues (const JointModelGroup *group, const std::string &name)
	Set the joints in group to the position name defined in the SRDF.
bool	setToDefaultValues (const std::string &group_name, const std::string &state_name)
void	setToRandomPositions ()
	Set all joints to random values. Values will be within default bounds.
void	setToRandomPositions (const JointModelGroup *group)
	Set all joints in group to random values. Values will be within default bounds.
void	setToRandomPositions (const JointModelGroup *group, random_numbers::RandomNumberGenerator &rng)
	Set all joints in group to random values using a specified random number generator. Values will be within default bounds.
void	setToRandomPositionsNearBy (const JointModelGroup *group, const RobotState &seed, double distance)
	Set all joints in group to random values near the value in seed. distance is the maximum amount each joint value will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.
void	setToRandomPositionsNearBy (const JointModelGroup *group, const RobotState &seed, double distance, random_numbers::RandomNumberGenerator &rng)
	Set all joints in group to random values near the value in seed, using a specified random number generator. distance is the maximum amount each joint value will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.
void	setToRandomPositionsNearBy (const JointModelGroup *group, const RobotState &seed, const std::vector< double > &distances)
	Set all joints in group to random values near the value in seed. distances MUST have the same size as group.getActiveJointModels(). Each value in distances is the maximum amount the corresponding active joint in group will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.
void	setToRandomPositionsNearBy (const JointModelGroup *group, const RobotState &seed, const std::vector< double > &distances, random_numbers::RandomNumberGenerator &rng)
	Set all joints in group to random values near the value in seed, using a specified random number generator. distances MUST have the same size as group.getActiveJointModels(). Each value in distances is the maximum amount the corresponding active joint in group will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.
Updating and getting transforms
void	updateCollisionBodyTransforms ()
	Update the transforms for the collision bodies. This call is needed before calling collision checking. If updating link transforms or joint transforms is needed, the corresponding updates are also triggered.
void	updateLinkTransforms ()
	Update the reference frame transforms for links. This call is needed before using the transforms of links for coordinate transforms.
void	update (bool force=false)
	Update all transforms.
void	updateStateWithLinkAt (const std::string &link_name, const Eigen::Isometry3d &transform, bool backward=false)
	Update the state after setting a particular link to the input global transform pose.
void	updateStateWithLinkAt (const LinkModel *link, const Eigen::Isometry3d &transform, bool backward=false)
	Update the state after setting a particular link to the input global transform pose.
const moveit::core::LinkModel *	getRigidlyConnectedParentLinkModel (const std::string &frame) const
	Get the latest link upwards the kinematic tree which is only connected via fixed joints.
const Eigen::Isometry3d &	getGlobalLinkTransform (const std::string &link_name)
	Get the link transform w.r.t. the root link (model frame) of the RobotModel. This is typically the root link of the URDF unless a virtual joint is present. Checks the cache and if there are any dirty (non-updated) transforms, first updates them as needed. A related, more comprehensive function is |getFrameTransform|, which additionally to link frames also searches for attached object frames and their subframes.
const Eigen::Isometry3d &	getGlobalLinkTransform (const LinkModel *link)
const Eigen::Isometry3d &	getGlobalLinkTransform (const std::string &link_name) const
const Eigen::Isometry3d &	getGlobalLinkTransform (const LinkModel *link) const
const Eigen::Isometry3d &	getCollisionBodyTransform (const std::string &link_name, std::size_t index)
	Get the link transform w.r.t. the root link (model frame) of the RobotModel. This is typically the root link of the URDF unless a virtual joint is present. Checks the cache and if there are any dirty (non-updated) transforms, first updates them as needed.
const Eigen::Isometry3d &	getCollisionBodyTransform (const LinkModel *link, std::size_t index)
const Eigen::Isometry3d &	getCollisionBodyTransform (const std::string &link_name, std::size_t index) const
const Eigen::Isometry3d &	getCollisionBodyTransform (const LinkModel *link, std::size_t index) const
const Eigen::Isometry3d &	getJointTransform (const std::string &joint_name)
const Eigen::Isometry3d &	getJointTransform (const JointModel *joint)
const Eigen::Isometry3d &	getJointTransform (const std::string &joint_name) const
const Eigen::Isometry3d &	getJointTransform (const JointModel *joint) const
bool	dirtyJointTransform (const JointModel *joint) const
bool	dirtyLinkTransforms () const
bool	dirtyCollisionBodyTransforms () const
bool	dirty () const
	Returns true if anything in this state is dirty.
Computing distances
double	distance (const RobotState &other) const
	Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.
double	distance (const RobotState &other, const JointModelGroup *joint_group) const
	Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.
double	distance (const RobotState &other, const JointModel *joint) const
	Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.
void	interpolate (const RobotState &to, double t, RobotState &state) const
void	interpolate (const RobotState &to, double t, RobotState &state, const JointModelGroup *joint_group) const
void	interpolate (const RobotState &to, double t, RobotState &state, const JointModel *joint) const
void	enforceBounds ()
void	enforceBounds (const JointModelGroup *joint_group)
void	enforceBounds (const JointModel *joint)
void	enforcePositionBounds (const JointModel *joint)
void	harmonizePositions ()
	Call harmonizePosition() for all joints / all joints in group / given joint.
void	harmonizePositions (const JointModelGroup *joint_group)
void	harmonizePosition (const JointModel *joint)
void	enforceVelocityBounds (const JointModel *joint)
bool	satisfiesBounds (double margin=0.0) const
bool	satisfiesBounds (const JointModelGroup *joint_group, double margin=0.0) const
bool	satisfiesBounds (const JointModel *joint, double margin=0.0) const
bool	satisfiesPositionBounds (const JointModel *joint, double margin=0.0) const
bool	satisfiesVelocityBounds (const JointModel *joint, double margin=0.0) const
std::pair< double, const JointModel * >	getMinDistanceToPositionBounds () const
	Get the minimm distance from this state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.
std::pair< double, const JointModel * >	getMinDistanceToPositionBounds (const JointModelGroup *group) const
	Get the minimm distance from a group in this state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.
std::pair< double, const JointModel * >	getMinDistanceToPositionBounds (const std::vector< const JointModel * > &joints) const
	Get the minimm distance from a set of joints in the state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.
bool	isValidVelocityMove (const RobotState &other, const JointModelGroup *group, double dt) const
	Check that the time to move between two waypoints is sufficient given velocity limits and time step.
Managing attached bodies
void	attachBody (std::unique_ptr< AttachedBody > attached_body)
	Add an attached body to this state.
void	attachBody (const std::string &id, const Eigen::Isometry3d &pose, const std::vector< shapes::ShapeConstPtr > &shapes, const EigenSTL::vector_Isometry3d &shape_poses, const std::set< std::string > &touch_links, const std::string &link_name, const trajectory_msgs::msg::JointTrajectory &detach_posture=trajectory_msgs::msg::JointTrajectory(), const moveit::core::FixedTransformsMap &subframe_poses=moveit::core::FixedTransformsMap())
	Add an attached body to a link.
void	attachBody (const std::string &id, const Eigen::Isometry3d &pose, const std::vector< shapes::ShapeConstPtr > &shapes, const EigenSTL::vector_Isometry3d &shape_poses, const std::vector< std::string > &touch_links, const std::string &link_name, const trajectory_msgs::msg::JointTrajectory &detach_posture=trajectory_msgs::msg::JointTrajectory(), const moveit::core::FixedTransformsMap &subframe_poses=moveit::core::FixedTransformsMap())
	Add an attached body to a link.
void	getAttachedBodies (std::vector< const AttachedBody * > &attached_bodies) const
	Get all bodies attached to the model corresponding to this state.
void	getAttachedBodies (std::vector< const AttachedBody * > &attached_bodies, const JointModelGroup *group) const
	Get all bodies attached to a particular group the model corresponding to this state.
void	getAttachedBodies (std::vector< const AttachedBody * > &attached_bodies, const LinkModel *link_model) const
	Get all bodies attached to a particular link in the model corresponding to this state.
bool	clearAttachedBody (const std::string &id)
	Remove the attached body named id. Return false if the object was not found (and thus not removed). Return true on success.
void	clearAttachedBodies (const LinkModel *link)
	Clear the bodies attached to a specific link.
void	clearAttachedBodies (const JointModelGroup *group)
	Clear the bodies attached to a specific group.
void	clearAttachedBodies ()
	Clear all attached bodies. This calls delete on the AttachedBody instances, if needed.
const AttachedBody *	getAttachedBody (const std::string &name) const
	Get the attached body named name. Return nullptr if not found.
bool	hasAttachedBody (const std::string &id) const
	Check if an attached body named id exists in this state.
void	setAttachedBodyUpdateCallback (const AttachedBodyCallback &callback)

Detailed Description

Representation of a robot's state. This includes position, velocity, acceleration and effort.

At the lowest level, a state is a collection of variables. Each variable has a name and can have position, velocity, acceleration and effort associated to it. Effort and acceleration share the memory area for efficiency reasons (one should not set both acceleration and effort in the same state and expect things to work). Often variables correspond to joint names as well (joints with one degree of freedom have one variable), but joints with multiple degrees of freedom have more variables. Operations are allowed at variable level, joint level (see JointModel) and joint group level (see JointModelGroup).

For efficiency reasons a state computes forward kinematics in a lazy fashion. This can sometimes lead to problems if the update() function was not called on the state.

Definition at line 89 of file robot_state.h.

Constructor & Destructor Documentation

RobotState() [1/2]

moveit::core::RobotState::RobotState

(

const RobotModelConstPtr &

robot_model

)

A state can be constructed from a specified robot model. No values are initialized. Call setToDefaultValues() if a state needs to provide valid information.

Definition at line 66 of file robot_state.cpp.

~RobotState()

moveit::core::RobotState::~RobotState

(

)

Definition at line 90 of file robot_state.cpp.

Here is the call graph for this function:

RobotState() [2/2]

moveit::core::RobotState::RobotState

(

const RobotState &

other

)

Copy constructor.

Definition at line 84 of file robot_state.cpp.

Member Function Documentation

attachBody() [1/3]

void moveit::core::RobotState::attachBody	(	const std::string &	id,
		const Eigen::Isometry3d &	pose,
		const std::vector< shapes::ShapeConstPtr > &	shapes,
		const EigenSTL::vector_Isometry3d &	shape_poses,
		const std::set< std::string > &	touch_links,
		const std::string &	link_name,
		const trajectory_msgs::msg::JointTrajectory &	detach_posture = trajectory_msgs::msg::JointTrajectory(),
		const moveit::core::FixedTransformsMap &	subframe_poses = moveit::core::FixedTransformsMap()
	)

Add an attached body to a link.

Parameters

id	The string id associated with the attached body
pose	The pose associated with the attached body
shapes	The shapes that make up the attached body
shape_poses	The transforms between the object pose and the attached body's shapes
touch_links	The set of links that the attached body is allowed to touch
link_name	The link to attach to
detach_posture	The posture of the gripper when placing the object
subframe_poses	Transforms to points of interest on the object (can be used as end effector link)

This only adds the given body to this RobotState instance. It does not change anything about other representations of the object elsewhere in the system. So if the body represents an object in a collision_detection::World (like from a planning_scene::PlanningScene), you will likely need to remove the corresponding object from that world to avoid having collisions detected against it.

Definition at line 1178 of file robot_state.cpp.

Here is the call graph for this function:

attachBody() [2/3]

void moveit::core::RobotState::attachBody ( const std::string &  id, const Eigen::Isometry3d &  pose, const std::vector< shapes::ShapeConstPtr > &  shapes, const EigenSTL::vector_Isometry3d &  shape_poses, const std::vector< std::string > &  touch_links, const std::string &  link_name, const trajectory_msgs::msg::JointTrajectory &  detach_posture = trajectory_msgs::msg::JointTrajectory(), const moveit::core::FixedTransformsMap &  subframe_poses = moveit::core::FixedTransformsMap()  )

inline

Add an attached body to a link.

Parameters

id	The string id associated with the attached body
pose	The pose associated with the attached body
shapes	The shapes that make up the attached body
shape_poses	The transforms between the object pose and the attached body's shapes
touch_links	The set of links that the attached body is allowed to touch
link_name	The link to attach to
detach_posture	The posture of the gripper when placing the object
subframe_poses	Transforms to points of interest on the object (can be used as end effector link)

This only adds the given body to this RobotState instance. It does not change anything about other representations of the object elsewhere in the system. So if the body represents an object in a collision_detection::World (like from a planning_scene::PlanningScene), you will likely need to remove the corresponding object from that world to avoid having collisions detected against it.

Definition at line 1508 of file robot_state.h.

Here is the call graph for this function:

attachBody() [3/3]

void moveit::core::RobotState::attachBody

(

std::unique_ptr< AttachedBody >

attached_body

)

Add an attached body to this state.

This only adds the given body to this RobotState instance. It does not change anything about other representations of the object elsewhere in the system. So if the body represents an object in a collision_detection::World (like from a planning_scene::PlanningScene), you will likely need to remove the corresponding object from that world to avoid having collisions detected against it.

Definition at line 1167 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

clearAttachedBodies() [1/3]

void moveit::core::RobotState::clearAttachedBodies

(

)

Clear all attached bodies. This calls delete on the AttachedBody instances, if needed.

Definition at line 1216 of file robot_state.cpp.

Here is the caller graph for this function:

clearAttachedBodies() [2/3]

void moveit::core::RobotState::clearAttachedBodies

(

const JointModelGroup *

group

)

Clear the bodies attached to a specific group.

Definition at line 1241 of file robot_state.cpp.

Here is the call graph for this function:

clearAttachedBodies() [3/3]

void moveit::core::RobotState::clearAttachedBodies

(

const LinkModel *

link

)

Clear the bodies attached to a specific link.

Definition at line 1226 of file robot_state.cpp.

clearAttachedBody()

bool moveit::core::RobotState::clearAttachedBody

(

const std::string &

id

)

Remove the attached body named id. Return false if the object was not found (and thus not removed). Return true on success.

Definition at line 1256 of file robot_state.cpp.

Here is the caller graph for this function:

computeAABB() [1/2]

void moveit::core::RobotState::computeAABB ( std::vector< double > &  aabb )

inline

Compute an axis-aligned bounding box that contains the current state. The format for aabb is (minx, maxx, miny, maxy, minz, maxz)

Definition at line 1555 of file robot_state.h.

Here is the call graph for this function:

computeAABB() [2/2]

void moveit::core::RobotState::computeAABB

(

std::vector< double > &

aabb

)

const

Compute an axis-aligned bounding box that contains the current state. The format for aabb is (minx, maxx, miny, maxy, minz, maxz)

Definition at line 2213 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

computeVariableVelocity() [1/2]

void moveit::core::RobotState::computeVariableVelocity ( const JointModelGroup *  jmg, Eigen::VectorXd &  qdot, const Eigen::VectorXd &  twist, const LinkModel *  tip  )

inline

Given a twist for a particular link (tip), compute the corresponding velocity for every variable and store it in qdot.

Definition at line 1106 of file robot_state.h.

Here is the call graph for this function:

computeVariableVelocity() [2/2]

void moveit::core::RobotState::computeVariableVelocity	(	const JointModelGroup *	jmg,
		Eigen::VectorXd &	qdot,
		const Eigen::VectorXd &	twist,
		const LinkModel *	tip
	)		const

Given a twist for a particular link (tip), compute the corresponding velocity for every variable and store it in qdot.

Definition at line 1585 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

copyJointGroupAccelerations() [1/6]

void moveit::core::RobotState::copyJointGroupAccelerations	(	const JointModelGroup *	group,
		double *	gstate
	)		const

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 708 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupAccelerations() [2/6]

void moveit::core::RobotState::copyJointGroupAccelerations	(	const JointModelGroup *	group,
		Eigen::VectorXd &	values
	)		const

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 722 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupAccelerations() [3/6]

void moveit::core::RobotState::copyJointGroupAccelerations ( const JointModelGroup *  group, std::vector< double > &  gstate  ) const

inline

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 892 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupAccelerations() [4/6]

void moveit::core::RobotState::copyJointGroupAccelerations ( const std::string &  joint_group_name, double *  gstate  ) const

inline

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 882 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupAccelerations() [5/6]

void moveit::core::RobotState::copyJointGroupAccelerations ( const std::string &  joint_group_name, Eigen::VectorXd &  values  ) const

inline

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 906 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupAccelerations() [6/6]

void moveit::core::RobotState::copyJointGroupAccelerations ( const std::string &  joint_group_name, std::vector< double > &  gstate  ) const

inline

For a given group, copy the acceleration values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 869 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

copyJointGroupPositions() [1/6]

void moveit::core::RobotState::copyJointGroupPositions	(	const JointModelGroup *	group,
		double *	gstate
	)		const

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 618 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupPositions() [2/6]

void moveit::core::RobotState::copyJointGroupPositions	(	const JointModelGroup *	group,
		Eigen::VectorXd &	values
	)		const

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 632 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupPositions() [3/6]

void moveit::core::RobotState::copyJointGroupPositions ( const JointModelGroup *  group, std::vector< double > &  gstate  ) const

inline

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 692 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupPositions() [4/6]

void moveit::core::RobotState::copyJointGroupPositions ( const std::string &  joint_group_name, double *  gstate  ) const

inline

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 682 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupPositions() [5/6]

void moveit::core::RobotState::copyJointGroupPositions ( const std::string &  joint_group_name, Eigen::VectorXd &  values  ) const

inline

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 706 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupPositions() [6/6]

void moveit::core::RobotState::copyJointGroupPositions ( const std::string &  joint_group_name, std::vector< double > &  gstate  ) const

inline

For a given group, copy the position values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 669 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

copyJointGroupVelocities() [1/6]

void moveit::core::RobotState::copyJointGroupVelocities	(	const JointModelGroup *	group,
		double *	gstate
	)		const

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 663 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupVelocities() [2/6]

void moveit::core::RobotState::copyJointGroupVelocities	(	const JointModelGroup *	group,
		Eigen::VectorXd &	values
	)		const

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 677 of file robot_state.cpp.

Here is the call graph for this function:

copyJointGroupVelocities() [3/6]

void moveit::core::RobotState::copyJointGroupVelocities ( const JointModelGroup *  group, std::vector< double > &  gstate  ) const

inline

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 792 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupVelocities() [4/6]

void moveit::core::RobotState::copyJointGroupVelocities ( const std::string &  joint_group_name, double *  gstate  ) const

inline

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 782 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupVelocities() [5/6]

void moveit::core::RobotState::copyJointGroupVelocities ( const std::string &  joint_group_name, Eigen::VectorXd &  values  ) const

inline

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 806 of file robot_state.h.

Here is the call graph for this function:

copyJointGroupVelocities() [6/6]

void moveit::core::RobotState::copyJointGroupVelocities ( const std::string &  joint_group_name, std::vector< double > &  gstate  ) const

inline

For a given group, copy the velocity values of the variables that make up the group into another location, in the order that the variables are found in the group. This is not necessarily a contiguous block of memory in the RobotState itself, so we copy instead of returning a pointer.

Definition at line 769 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

dirty()

bool moveit::core::RobotState::dirty ( ) const

inline

Returns true if anything in this state is dirty.

Definition at line 1342 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

dirtyCollisionBodyTransforms()

bool moveit::core::RobotState::dirtyCollisionBodyTransforms ( ) const

inline

Definition at line 1336 of file robot_state.h.

Here is the caller graph for this function:

dirtyJointTransform()

bool moveit::core::RobotState::dirtyJointTransform ( const JointModel *  joint ) const

inline

Definition at line 1326 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

dirtyLinkTransforms()

bool moveit::core::RobotState::dirtyLinkTransforms ( ) const

inline

Definition at line 1331 of file robot_state.h.

Here is the caller graph for this function:

distance() [1/3]

double moveit::core::RobotState::distance ( const RobotState &  other ) const

inline

Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.

Definition at line 1354 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

distance() [2/3]

double moveit::core::RobotState::distance	(	const RobotState &	other,
		const JointModel *	joint
	)		const

Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.

Definition at line 1101 of file robot_state.cpp.

Here is the call graph for this function:

distance() [3/3]

double moveit::core::RobotState::distance	(	const RobotState &	other,
		const JointModelGroup *	joint_group
	)		const

Return the sum of joint distances to "other" state. An L1 norm. Only considers active joints.

Definition at line 1089 of file robot_state.cpp.

Here is the call graph for this function:

dropAccelerations()

void moveit::core::RobotState::dropAccelerations

(

)

Remove accelerations from this state (this differs from setting them to zero)

Definition at line 245 of file robot_state.cpp.

Here is the caller graph for this function:

dropDynamics()

void moveit::core::RobotState::dropDynamics

(

)

Reduce RobotState to kinematic information (remove velocity, acceleration and effort, if present)

Definition at line 255 of file robot_state.cpp.

Here is the call graph for this function:

dropEffort()

void moveit::core::RobotState::dropEffort

(

)

Remove effort values from this state (this differs from setting them to zero)

Definition at line 250 of file robot_state.cpp.

Here is the caller graph for this function:

dropVelocities()

void moveit::core::RobotState::dropVelocities

(

)

Remove velocities from this state (this differs from setting them to zero)

Definition at line 240 of file robot_state.cpp.

Here is the caller graph for this function:

enforceBounds() [1/3]

void moveit::core::RobotState::enforceBounds

(

)

Definition at line 959 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

enforceBounds() [2/3]

void moveit::core::RobotState::enforceBounds ( const JointModel *  joint )

inline

Definition at line 1399 of file robot_state.h.

Here is the call graph for this function:

enforceBounds() [3/3]

void moveit::core::RobotState::enforceBounds

(

const JointModelGroup *

joint_group

)

Definition at line 966 of file robot_state.cpp.

Here is the call graph for this function:

enforcePositionBounds()

void moveit::core::RobotState::enforcePositionBounds

(

const JointModel *

joint

)

Definition at line 973 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

enforceVelocityBounds()

void moveit::core::RobotState::enforceVelocityBounds

(

const JointModel *

joint

)

Definition at line 1011 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getAttachedBodies() [1/3]

void moveit::core::RobotState::getAttachedBodies

(

std::vector< const AttachedBody * > &

attached_bodies

)

const

Get all bodies attached to the model corresponding to this state.

Definition at line 1188 of file robot_state.cpp.

Here is the caller graph for this function:

getAttachedBodies() [2/3]

void moveit::core::RobotState::getAttachedBodies	(	std::vector< const AttachedBody * > &	attached_bodies,
		const JointModelGroup *	group
	)		const

Get all bodies attached to a particular group the model corresponding to this state.

Definition at line 1196 of file robot_state.cpp.

Here is the call graph for this function:

getAttachedBodies() [3/3]

void moveit::core::RobotState::getAttachedBodies	(	std::vector< const AttachedBody * > &	attached_bodies,
		const LinkModel *	link_model
	)		const

Get all bodies attached to a particular link in the model corresponding to this state.

Definition at line 1206 of file robot_state.cpp.

getAttachedBody()

const AttachedBody * moveit::core::RobotState::getAttachedBody

(

const std::string &

name

)

const

Get the attached body named name. Return nullptr if not found.

Definition at line 1155 of file robot_state.cpp.

Here is the caller graph for this function:

getCollisionBodyTransform() [1/4]

const Eigen::Isometry3d & moveit::core::RobotState::getCollisionBodyTransform ( const LinkModel *  link, std::size_t  index  )

inline

Definition at line 1291 of file robot_state.h.

Here is the call graph for this function:

getCollisionBodyTransform() [2/4]

const Eigen::Isometry3d & moveit::core::RobotState::getCollisionBodyTransform ( const LinkModel *  link, std::size_t  index  ) const

inline

Definition at line 1302 of file robot_state.h.

Here is the call graph for this function:

getCollisionBodyTransform() [3/4]

const Eigen::Isometry3d & moveit::core::RobotState::getCollisionBodyTransform ( const std::string &  link_name, std::size_t  index  )

inline

Get the link transform w.r.t. the root link (model frame) of the RobotModel. This is typically the root link of the URDF unless a virtual joint is present. Checks the cache and if there are any dirty (non-updated) transforms, first updates them as needed.

As opposed to the visual links in |getGlobalLinkTransform|, this function returns the collision link transform used for collision checking.

Parameters

link_name	name of link to lookup
index	specify which collision body to lookup, if more than one exists

Definition at line 1286 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getCollisionBodyTransform() [4/4]

const Eigen::Isometry3d & moveit::core::RobotState::getCollisionBodyTransform ( const std::string &  link_name, std::size_t  index  ) const

inline

Definition at line 1297 of file robot_state.h.

Here is the call graph for this function:

getFrameInfo()

const Eigen::Isometry3d & moveit::core::RobotState::getFrameInfo	(	const std::string &	frame_id,
		const LinkModel *&	robot_link,
		bool &	frame_found
	)		const

Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.

If this frame is attached to a robot link, the link pointer is returned in robot_link. If frame_id was not found, frame_found is set to false and an identity transform is returned.

The returned transformation is always a valid isometry.

Definition at line 1294 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getFrameTransform() [1/2]

const Eigen::Isometry3d & moveit::core::RobotState::getFrameTransform	(	const std::string &	frame_id,
		bool *	frame_found = nullptr
	)

Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.

If frame_id was not found, frame_found is set to false and an identity transform is returned.

The returned transformation is always a valid isometry.

Definition at line 1270 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getFrameTransform() [2/2]

const Eigen::Isometry3d & moveit::core::RobotState::getFrameTransform	(	const std::string &	frame_id,
		bool *	frame_found = nullptr
	)		const

Get the transformation matrix from the model frame (root of model) to the frame identified by frame_id.

If frame_id was not found, frame_found is set to false and an identity transform is returned.

The returned transformation is always a valid isometry.

Definition at line 1276 of file robot_state.cpp.

Here is the call graph for this function:

getGlobalLinkTransform() [1/4]

const Eigen::Isometry3d & moveit::core::RobotState::getGlobalLinkTransform ( const LinkModel *  link )

inline

Definition at line 1251 of file robot_state.h.

Here is the call graph for this function:

getGlobalLinkTransform() [2/4]

const Eigen::Isometry3d & moveit::core::RobotState::getGlobalLinkTransform ( const LinkModel *  link ) const

inline

Definition at line 1266 of file robot_state.h.

Here is the call graph for this function:

getGlobalLinkTransform() [3/4]

const Eigen::Isometry3d & moveit::core::RobotState::getGlobalLinkTransform ( const std::string &  link_name )

inline

Get the link transform w.r.t. the root link (model frame) of the RobotModel. This is typically the root link of the URDF unless a virtual joint is present. Checks the cache and if there are any dirty (non-updated) transforms, first updates them as needed. A related, more comprehensive function is |getFrameTransform|, which additionally to link frames also searches for attached object frames and their subframes.

This will throw an exception if the passed link is not found

The returned transformation is always a valid isometry.

Definition at line 1246 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getGlobalLinkTransform() [4/4]

const Eigen::Isometry3d & moveit::core::RobotState::getGlobalLinkTransform ( const std::string &  link_name ) const

inline

Definition at line 1261 of file robot_state.h.

Here is the call graph for this function:

getJacobian() [1/4]

Eigen::MatrixXd moveit::core::RobotState::getJacobian ( const JointModelGroup *  group, const Eigen::Vector3d &  reference_point_position = Eigen::Vector3d(0.0, 0.0, 0.0)  )

inline

Compute the Jacobian with reference to the last link of a specified group, and origin at the group root link. If the group is not a chain, an exception is thrown.

Parameters

group	The group to compute the Jacobian for
reference_point_position	The reference point position (with respect to the link specified in link_name)

Returns

The computed Jacobian.

Definition at line 1092 of file robot_state.h.

Here is the call graph for this function:

getJacobian() [2/4]

Eigen::MatrixXd moveit::core::RobotState::getJacobian	(	const JointModelGroup *	group,
		const Eigen::Vector3d &	reference_point_position = Eigen::Vector3d(0.0, 0.0, 0.0)
	)		const

Compute the Jacobian with reference to the last link of a specified group, and origin at the group root link. If the group is not a chain, an exception is thrown.

Parameters

group	The group to compute the Jacobian for
reference_point_position	The reference point position (with respect to the link specified in link_name)

Returns

The computed Jacobian.

Definition at line 1452 of file robot_state.cpp.

Here is the call graph for this function:

getJacobian() [3/4]

bool moveit::core::RobotState::getJacobian ( const JointModelGroup *  group, const LinkModel *  link, const Eigen::Vector3d &  reference_point_position, Eigen::MatrixXd &  jacobian, bool  use_quaternion_representation = false  )

inline

Compute the Jacobian with reference to a particular point on a given link, for a specified group.

Parameters

group	The group to compute the Jacobian for
link	The link model to compute the Jacobian for
reference_point_position	The reference point position (with respect to the link specified in link)
jacobian	The resultant jacobian, with the origin at the group root link.
use_quaternion_representation	Flag indicating if the Jacobian should use a quaternion representation (default is false)

Returns

True if jacobian was successfully computed, false otherwise

Definition at line 1069 of file robot_state.h.

Here is the call graph for this function:

getJacobian() [4/4]

bool moveit::core::RobotState::getJacobian	(	const JointModelGroup *	group,
		const LinkModel *	link,
		const Eigen::Vector3d &	reference_point_position,
		Eigen::MatrixXd &	jacobian,
		bool	use_quaternion_representation = false
	)		const

Compute the Jacobian with reference to a particular point on a given link, for a specified group.

Parameters

group	The group to compute the Jacobian for
link	The link model to compute the Jacobian for
reference_point_position	The reference point position (with respect to the link specified in link)
jacobian	The resultant jacobian, with the origin at the group root link.
use_quaternion_representation	Flag indicating if the Jacobian should use a quaternion representation (default is false)

Returns

True if jacobian was successfully computed, false otherwise

Definition at line 1461 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getJointAccelerations() [1/2]

const double * moveit::core::RobotState::getJointAccelerations

(

const JointModel *

joint

)

const

Definition at line 536 of file robot_state.cpp.

Here is the call graph for this function:

getJointAccelerations() [2/2]

const double * moveit::core::RobotState::getJointAccelerations ( const std::string &  joint_name ) const

inline

Definition at line 559 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getJointEffort() [1/2]

const double * moveit::core::RobotState::getJointEffort

(

const JointModel *

joint

)

const

Definition at line 545 of file robot_state.cpp.

Here is the call graph for this function:

getJointEffort() [2/2]

const double * moveit::core::RobotState::getJointEffort ( const std::string &  joint_name ) const

inline

Definition at line 567 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getJointModel()

const JointModel * moveit::core::RobotState::getJointModel ( const std::string &  joint ) const

inline

Get the model of a particular joint.

Definition at line 128 of file robot_state.h.

getJointModelGroup()

const JointModelGroup * moveit::core::RobotState::getJointModelGroup ( const std::string &  group ) const

inline

Get the model of a particular joint group.

Definition at line 134 of file robot_state.h.

Here is the caller graph for this function:

getJointPositions() [1/2]

const double * moveit::core::RobotState::getJointPositions

(

const JointModel *

joint

)

const

Definition at line 518 of file robot_state.cpp.

Here is the call graph for this function:

getJointPositions() [2/2]

const double * moveit::core::RobotState::getJointPositions ( const std::string &  joint_name ) const

inline

Definition at line 543 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getJointTransform() [1/4]

const Eigen::Isometry3d & moveit::core::RobotState::getJointTransform

(

const JointModel *

joint

)

Definition at line 920 of file robot_state.cpp.

Here is the call graph for this function:

getJointTransform() [2/4]

const Eigen::Isometry3d & moveit::core::RobotState::getJointTransform ( const JointModel *  joint ) const

inline

Definition at line 1320 of file robot_state.h.

Here is the call graph for this function:

getJointTransform() [3/4]

const Eigen::Isometry3d & moveit::core::RobotState::getJointTransform ( const std::string &  joint_name )

inline

Definition at line 1308 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getJointTransform() [4/4]

const Eigen::Isometry3d & moveit::core::RobotState::getJointTransform ( const std::string &  joint_name ) const

inline

Definition at line 1315 of file robot_state.h.

Here is the call graph for this function:

getJointVelocities() [1/2]

const double * moveit::core::RobotState::getJointVelocities

(

const JointModel *

joint

)

const

Definition at line 527 of file robot_state.cpp.

Here is the call graph for this function:

getJointVelocities() [2/2]

const double * moveit::core::RobotState::getJointVelocities ( const std::string &  joint_name ) const

inline

Definition at line 551 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

getLinkModel()

const LinkModel * moveit::core::RobotState::getLinkModel ( const std::string &  link ) const

inline

Get the model of a particular link.

Definition at line 122 of file robot_state.h.

Here is the caller graph for this function:

getMinDistanceToPositionBounds() [1/3]

std::pair< double, const JointModel * > moveit::core::RobotState::getMinDistanceToPositionBounds

(

)

const

Get the minimm distance from this state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.

Definition at line 1020 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getMinDistanceToPositionBounds() [2/3]

std::pair< double, const JointModel * > moveit::core::RobotState::getMinDistanceToPositionBounds

(

const JointModelGroup *

group

)

const

Get the minimm distance from a group in this state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.

Definition at line 1025 of file robot_state.cpp.

Here is the call graph for this function:

getMinDistanceToPositionBounds() [3/3]

std::pair< double, const JointModel * > moveit::core::RobotState::getMinDistanceToPositionBounds

(

const std::vector< const JointModel * > &

joints

)

const

Get the minimm distance from a set of joints in the state to the bounds. The minimum distance and the joint for which this minimum is achieved are returned.

Definition at line 1031 of file robot_state.cpp.

Here is the call graph for this function:

getRandomNumberGenerator()

random_numbers::RandomNumberGenerator & moveit::core::RobotState::getRandomNumberGenerator ( )

inline

Return the instance of a random number generator.

Definition at line 1562 of file robot_state.h.

Here is the caller graph for this function:

getRigidlyConnectedParentLinkModel()

const LinkModel * moveit::core::RobotState::getRigidlyConnectedParentLinkModel

(

const std::string &

frame

)

const

Get the latest link upwards the kinematic tree which is only connected via fixed joints.

This behaves the same as RobotModel::getRigidlyConnectedParentLinkModel, but can additionally resolve parents for attached objects / subframes.

Definition at line 910 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getRobotMarkers() [1/4]

void moveit::core::RobotState::getRobotMarkers ( visualization_msgs::msg::MarkerArray &  arr, const std::vector< std::string > &  link_names, bool  include_attached = false  )

inline

Get a MarkerArray that fully describes the robot markers for a given robot. Update the state first.

Parameters

arr	The returned marker array
link_names	The list of link names for which the markers should be created.

Definition at line 1632 of file robot_state.h.

Here is the call graph for this function:

getRobotMarkers() [2/4]

void moveit::core::RobotState::getRobotMarkers	(	visualization_msgs::msg::MarkerArray &	arr,
		const std::vector< std::string > &	link_names,
		bool	include_attached = false
	)		const

Get a MarkerArray that fully describes the robot markers for a given robot.

Parameters

arr	The returned marker array
link_names	The list of link names for which the markers should be created.

Definition at line 1379 of file robot_state.cpp.

Here is the call graph for this function:

getRobotMarkers() [3/4]

void moveit::core::RobotState::getRobotMarkers ( visualization_msgs::msg::MarkerArray &  arr, const std::vector< std::string > &  link_names, const std_msgs::msg::ColorRGBA &  color, const std::string &  ns, const rclcpp::Duration &  dur, bool  include_attached = false  )

inline

Get a MarkerArray that fully describes the robot markers for a given robot. Update the state first.

Parameters

arr	The returned marker array
link_names	The list of link names for which the markers should be created.
color	The color for the marker
ns	The namespace for the markers
dur	The rclcpp::Duration for which the markers should stay visible

Definition at line 1613 of file robot_state.h.

Here is the call graph for this function:

getRobotMarkers() [4/4]

void moveit::core::RobotState::getRobotMarkers	(	visualization_msgs::msg::MarkerArray &	arr,
		const std::vector< std::string > &	link_names,
		const std_msgs::msg::ColorRGBA &	color,
		const std::string &	ns,
		const rclcpp::Duration &	dur,
		bool	include_attached = false
	)		const

Get a MarkerArray that fully describes the robot markers for a given robot.

Parameters

arr	The returned marker array
link_names	The list of link names for which the markers should be created.
color	The color for the marker
ns	The namespace for the markers
dur	The rclcpp::Duration for which the markers should stay visible

Definition at line 1363 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

getRobotModel()

const RobotModelConstPtr & moveit::core::RobotState::getRobotModel ( ) const

inline

Get the robot model this state is constructed for.

Definition at line 104 of file robot_state.h.

Here is the caller graph for this function:

getStateTreeString()

std::string moveit::core::RobotState::getStateTreeString

(

)

const

Definition at line 2410 of file robot_state.cpp.

Here is the caller graph for this function:

getVariableAcceleration() [1/2]

double moveit::core::RobotState::getVariableAcceleration ( const std::string &  variable ) const

inline

Get the acceleration of a particular variable. An exception is thrown if the variable is not known.

Definition at line 395 of file robot_state.h.

Here is the caller graph for this function:

getVariableAcceleration() [2/2]

double moveit::core::RobotState::getVariableAcceleration ( int  index ) const

inline

Get the acceleration of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed

Definition at line 403 of file robot_state.h.

getVariableAccelerations() [1/2]

double * moveit::core::RobotState::getVariableAccelerations ( )

inline

Get raw access to the accelerations of the variables that make up this state. The values are in the same order as reported by getVariableNames(). The area of memory overlaps with effort (effort and acceleration should not be set at the same time)

Definition at line 330 of file robot_state.h.

Here is the caller graph for this function:

getVariableAccelerations() [2/2]

const double * moveit::core::RobotState::getVariableAccelerations ( ) const

inline

Get const raw access to the accelerations of the variables that make up this state. The values are in the same order as reported by getVariableNames()

Definition at line 338 of file robot_state.h.

getVariableCount()

std::size_t moveit::core::RobotState::getVariableCount ( ) const

inline

Get the number of variables that make up this state.

Definition at line 110 of file robot_state.h.

Here is the caller graph for this function:

getVariableEffort() [1/4]

double * moveit::core::RobotState::getVariableEffort ( )

inline

Get raw access to the effort of the variables that make up this state. The values are in the same order as reported by getVariableNames(). The area of memory overlaps with accelerations (effort and acceleration should not be set at the same time)

Definition at line 428 of file robot_state.h.

Here is the caller graph for this function:

getVariableEffort() [2/4]

const double * moveit::core::RobotState::getVariableEffort ( ) const

inline

Get const raw access to the effort of the variables that make up this state. The values are in the same order as reported by getVariableNames().

Definition at line 436 of file robot_state.h.

getVariableEffort() [3/4]

double moveit::core::RobotState::getVariableEffort ( const std::string &  variable ) const

inline

Get the effort of a particular variable. An exception is thrown if the variable is not known.

Definition at line 486 of file robot_state.h.

getVariableEffort() [4/4]

double moveit::core::RobotState::getVariableEffort ( int  index ) const

inline

Get the effort of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed

Definition at line 494 of file robot_state.h.

getVariableNames()

const std::vector< std::string > & moveit::core::RobotState::getVariableNames ( ) const

inline

Get the names of the variables that make up this state, in the order they are stored in memory.

Definition at line 116 of file robot_state.h.

Here is the caller graph for this function:

getVariablePosition() [1/2]

double moveit::core::RobotState::getVariablePosition ( const std::string &  variable ) const

inline

Get the position of a particular variable. An exception is thrown if the variable is not known.

Definition at line 207 of file robot_state.h.

Here is the caller graph for this function:

getVariablePosition() [2/2]

double moveit::core::RobotState::getVariablePosition ( int  index ) const

inline

Get the position of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed

Definition at line 215 of file robot_state.h.

getVariablePositions() [1/2]

double * moveit::core::RobotState::getVariablePositions ( )

inline

Get a raw pointer to the positions of the variables stored in this state. Use carefully. If you change these values externally you need to make sure you trigger a forced update for the state by calling update(true).

Definition at line 147 of file robot_state.h.

Here is the caller graph for this function:

getVariablePositions() [2/2]

const double * moveit::core::RobotState::getVariablePositions ( ) const

inline

Get a raw pointer to the positions of the variables stored in this state.

Definition at line 154 of file robot_state.h.

getVariableVelocities() [1/2]

double * moveit::core::RobotState::getVariableVelocities ( )

inline

Get raw access to the velocities of the variables that make up this state. The values are in the same order as reported by getVariableNames()

Definition at line 236 of file robot_state.h.

Here is the caller graph for this function:

getVariableVelocities() [2/2]

const double * moveit::core::RobotState::getVariableVelocities ( ) const

inline

Get const access to the velocities of the variables that make up this state. The values are in the same order as reported by getVariableNames()

Definition at line 244 of file robot_state.h.

getVariableVelocity() [1/2]

double moveit::core::RobotState::getVariableVelocity ( const std::string &  variable ) const

inline

Get the velocity of a particular variable. An exception is thrown if the variable is not known.

Definition at line 296 of file robot_state.h.

Here is the caller graph for this function:

getVariableVelocity() [2/2]

double moveit::core::RobotState::getVariableVelocity ( int  index ) const

inline

Get the velocity of a particular variable. The variable is specified by its index. No checks are performed for the validity of the index passed

Definition at line 304 of file robot_state.h.

harmonizePosition()

void moveit::core::RobotState::harmonizePosition

(

const JointModel *

joint

)

Definition at line 998 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

harmonizePositions() [1/2]

void moveit::core::RobotState::harmonizePositions

(

)

Call harmonizePosition() for all joints / all joints in group / given joint.

Definition at line 986 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

harmonizePositions() [2/2]

void moveit::core::RobotState::harmonizePositions

(

const JointModelGroup *

joint_group

)

Definition at line 992 of file robot_state.cpp.

Here is the call graph for this function:

hasAccelerations()

bool moveit::core::RobotState::hasAccelerations ( ) const

inline

By default, if accelerations are never set or initialized, the state remembers that there are no accelerations set. This is useful to know when serializing or copying the state. If hasAccelerations() reports true, hasEffort() will certainly report false.

Definition at line 322 of file robot_state.h.

Here is the caller graph for this function:

hasAttachedBody()

bool moveit::core::RobotState::hasAttachedBody

(

const std::string &

id

)

const

Check if an attached body named id exists in this state.

Definition at line 1150 of file robot_state.cpp.

Here is the caller graph for this function:

hasEffort()

bool moveit::core::RobotState::hasEffort ( ) const

inline

By default, if effort is never set or initialized, the state remembers that there is no effort set. This is useful to know when serializing or copying the state. If hasEffort() reports true, hasAccelerations() will certainly report false.

Definition at line 420 of file robot_state.h.

Here is the caller graph for this function:

hasVelocities()

bool moveit::core::RobotState::hasVelocities ( ) const

inline

By default, if velocities are never set or initialized, the state remembers that there are no velocities set. This is useful to know when serializing or copying the state.

Definition at line 229 of file robot_state.h.

Here is the caller graph for this function:

integrateVariableVelocity()

bool moveit::core::RobotState::integrateVariableVelocity	(	const JointModelGroup *	jmg,
		const Eigen::VectorXd &	qdot,
		double	dt,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn()
	)

Given the velocities for the variables in this group (qdot) and an amount of time (dt), update the current state using the Euler forward method. If the constraint specified is satisfied, return true, otherwise return false.

Definition at line 1632 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate() [1/3]

void moveit::core::RobotState::interpolate	(	const RobotState &	to,
		double	t,
		RobotState &	state
	)		const

Interpolate towards "to" state. Mimic joints are correctly updated and flags are set so that FK is recomputed when needed.

Parameters

to	interpolate to this state
t	a fraction in the range [0 1]. If 1, the result matches "to" state exactly.
state	holds the result

Definition at line 1111 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

interpolate() [2/3]

void moveit::core::RobotState::interpolate	(	const RobotState &	to,
		double	t,
		RobotState &	state,
		const JointModel *	joint
	)		const

Interpolate towards "to" state, but only for a single joint. Mimic joints are correctly updated and flags are set so that FK is recomputed when needed.

Parameters

to	interpolate to this state
t	a fraction in the range [0 1]. If 1, the result matches "to" state exactly.
state	holds the result
joint	interpolate only for this joint

Definition at line 1132 of file robot_state.cpp.

Here is the call graph for this function:

interpolate() [3/3]

void moveit::core::RobotState::interpolate	(	const RobotState &	to,
		double	t,
		RobotState &	state,
		const JointModelGroup *	joint_group
	)		const

Interpolate towards "to" state, but only for the joints in the specified group. Mimic joints are correctly updated and flags are set so that FK is recomputed when needed.

Parameters

to	interpolate to this state
t	a fraction in the range [0 1]. If 1, the result matches "to" state exactly.
state	holds the result
joint_group	interpolate only for the joints in this group

Definition at line 1120 of file robot_state.cpp.

Here is the call graph for this function:

invertVelocity()

void moveit::core::RobotState::invertVelocity

(

)

Invert velocity if present.

Definition at line 477 of file robot_state.cpp.

isValidVelocityMove()

bool moveit::core::RobotState::isValidVelocityMove	(	const RobotState &	other,
		const JointModelGroup *	group,
		double	dt
	)		const

Check that the time to move between two waypoints is sufficient given velocity limits and time step.

Parameters

other	- robot state to compare joint positions against
group	- planning group to compare joint positions against
dt	- time step between the two points

Definition at line 1069 of file robot_state.cpp.

Here is the call graph for this function:

knowsFrameTransform()

bool moveit::core::RobotState::knowsFrameTransform

(

const std::string &

frame_id

)

const

Check if a transformation matrix from the model frame (root of model) to frame frame_id is known.

Definition at line 1342 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

RobotState & moveit::core::RobotState::operator=

(

const RobotState &

other

)

Copy operator.

Definition at line 106 of file robot_state.cpp.

printDirtyInfo()

void moveit::core::RobotState::printDirtyInfo

(

std::ostream &

out = std::cout

)

const

Definition at line 2307 of file robot_state.cpp.

Here is the call graph for this function:

printStateInfo()

void moveit::core::RobotState::printStateInfo

(

std::ostream &

out = std::cout

)

const

Definition at line 2321 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

printStatePositions()

void moveit::core::RobotState::printStatePositions

(

std::ostream &

out = std::cout

)

const

Definition at line 2248 of file robot_state.cpp.

printStatePositionsWithJointLimits()

void moveit::core::RobotState::printStatePositionsWithJointLimits	(	const moveit::core::JointModelGroup *	jmg,
		std::ostream &	out = std::cout
	)		const

Output to console the current state of the robot's joint limits.

Definition at line 2255 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

printTransform()

void moveit::core::RobotState::printTransform	(	const Eigen::Isometry3d &	transform,
		std::ostream &	out = std::cout
	)		const

Definition at line 2363 of file robot_state.cpp.

Here is the caller graph for this function:

printTransforms()

void moveit::core::RobotState::printTransforms

(

std::ostream &

out = std::cout

)

const

Definition at line 2381 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

satisfiesBounds() [1/3]

bool moveit::core::RobotState::satisfiesBounds ( const JointModel *  joint, double  margin = 0.0  ) const

inline

Definition at line 1416 of file robot_state.h.

Here is the call graph for this function:

satisfiesBounds() [2/3]

bool moveit::core::RobotState::satisfiesBounds	(	const JointModelGroup *	joint_group,
		double	margin = 0.0
	)		const

Definition at line 948 of file robot_state.cpp.

Here is the call graph for this function:

satisfiesBounds() [3/3]

bool moveit::core::RobotState::satisfiesBounds

(

double

margin = 0.0

)

const

Definition at line 937 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

satisfiesPositionBounds()

bool moveit::core::RobotState::satisfiesPositionBounds ( const JointModel *  joint, double  margin = 0.0  ) const

inline

Definition at line 1420 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

satisfiesVelocityBounds()

bool moveit::core::RobotState::satisfiesVelocityBounds ( const JointModel *  joint, double  margin = 0.0  ) const

inline

Definition at line 1424 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setAttachedBodyUpdateCallback()

void moveit::core::RobotState::setAttachedBodyUpdateCallback

(

const AttachedBodyCallback &

callback

)

Definition at line 1145 of file robot_state.cpp.

setFromDiffIK() [1/2]

bool moveit::core::RobotState::setFromDiffIK	(	const JointModelGroup *	group,
		const Eigen::VectorXd &	twist,
		const std::string &	tip,
		double	dt,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn()
	)

Set the joint values from a Cartesian velocity applied during a time dt.

Parameters

group	the group of joints this function operates on
twist	a Cartesian velocity on the 'tip' frame
tip	the frame for which the twist is given
dt	a time interval (seconds)
st	a secondary task computation function

Definition at line 1569 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setFromDiffIK() [2/2]

bool moveit::core::RobotState::setFromDiffIK	(	const JointModelGroup *	group,
		const geometry_msgs::msg::Twist &	twist,
		const std::string &	tip,
		double	dt,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn()
	)

Set the joint values from a Cartesian velocity applied during a time dt.

Parameters

group	the group of joints this function operates on
twist	a Cartesian velocity on the 'tip' frame
tip	the frame for which the twist is given
dt	a time interval (seconds)
st	a secondary task computation function

Definition at line 1577 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [1/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const Eigen::Isometry3d &	pose,
		const std::string &	tip,
		const std::vector< double > &	consistency_limits,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.

Parameters

pose	The pose the last link in the chain needs to achieve
tip	The name of the frame for which IK is attempted.
consistency_limits	This specifies the desired distance between the solution and the seed state
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1744 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [2/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const Eigen::Isometry3d &	pose,
		const std::string &	tip,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.

Parameters

pose	The pose the last link in the chain needs to achieve
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1691 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [3/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const Eigen::Isometry3d &	pose,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.

Parameters

pose	The pose the last link in the chain needs to achieve
tip	The name of the link the pose is specified for
timeout	The timeout passed to the kinematics solver on each attempt

Definition at line 1676 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [4/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const EigenSTL::vector_Isometry3d &	poses,
		const std::vector< std::string > &	tips,
		const std::vector< std::vector< double > > &	consistency_limits,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

Warning: This function inefficiently copies all transforms around. If the group consists of a set of sub-groups that are each a chain and a solver is available for each sub-group, then the joint values can be set by computing inverse kinematics. The poses are assumed to be in the reference frame of the kinematic model. The poses are assumed to be in the same order as the order of the sub-groups in this group. Returns true on success.

Parameters

poses	The poses the last link in each chain needs to achieve
tips	The names of the frames for which IK is attempted.
consistency_limits	This specifies the desired distance between the solution and the seed state
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1773 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [5/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const EigenSTL::vector_Isometry3d &	poses,
		const std::vector< std::string > &	tips,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

Warning: This function inefficiently copies all transforms around. If the group consists of a set of sub-groups that are each a chain and a solver is available for each sub-group, then the joint values can be set by computing inverse kinematics. The poses are assumed to be in the reference frame of the kinematic model. The poses are assumed to be in the same order as the order of the sub-groups in this group. Returns true on success.

Parameters

poses	The poses the last link in each chain needs to achieve
tips	The names of the frames for which IK is attempted.
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1763 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [6/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const geometry_msgs::msg::Pose &	pose,
		const std::string &	tip,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.

Parameters

pose	The pose the tip link in the chain needs to achieve
tip	The name of the link the pose is specified for
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1665 of file robot_state.cpp.

Here is the call graph for this function:

setFromIK() [7/7]

bool moveit::core::RobotState::setFromIK	(	const JointModelGroup *	group,
		const geometry_msgs::msg::Pose &	pose,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions(),
		const kinematics::KinematicsBase::IKCostFn &	cost_function = kinematics::KinematicsBase::IKCostFn()
	)

If the group this state corresponds to is a chain and a solver is available, then the joint values can be set by computing inverse kinematics. The pose is assumed to be in the reference frame of the kinematic model. Returns true on success.

Parameters

pose	The pose the last link in the chain needs to achieve
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 1651 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setFromIKSubgroups()

bool moveit::core::RobotState::setFromIKSubgroups	(	const JointModelGroup *	group,
		const EigenSTL::vector_Isometry3d &	poses,
		const std::vector< std::string > &	tips,
		const std::vector< std::vector< double > > &	consistency_limits,
		double	timeout = 0.0,
		const GroupStateValidityCallbackFn &	constraint = GroupStateValidityCallbackFn(),
		const kinematics::KinematicsQueryOptions &	options = kinematics::KinematicsQueryOptions()
	)

setFromIK for multiple poses and tips (end effectors) when no solver exists for the jmg that can solver for non-chain kinematics. In this case, we divide the group into subgroups and do IK solving individually

Parameters

poses	The poses the last link in each chain needs to achieve
tips	The names of the frames for which IK is attempted.
consistency_limits	This specifies the desired distance between the solution and the seed state
timeout	The timeout passed to the kinematics solver on each attempt
constraint	A state validity constraint to be required for IK solutions

Definition at line 2005 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointEfforts()

void moveit::core::RobotState::setJointEfforts	(	const JointModel *	joint,
		const double *	effort
	)

Definition at line 554 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupAccelerations() [1/6]

void moveit::core::RobotState::setJointGroupAccelerations	(	const JointModelGroup *	group,
		const double *	gstate
	)

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 685 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupAccelerations() [2/6]

void moveit::core::RobotState::setJointGroupAccelerations	(	const JointModelGroup *	group,
		const Eigen::VectorXd &	values
	)

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 700 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupAccelerations() [3/6]

void moveit::core::RobotState::setJointGroupAccelerations ( const JointModelGroup *  group, const std::vector< double > &  gstate  )

inline

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 844 of file robot_state.h.

Here is the call graph for this function:

setJointGroupAccelerations() [4/6]

void moveit::core::RobotState::setJointGroupAccelerations ( const std::string &  joint_group_name, const double *  gstate  )

inline

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 826 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointGroupAccelerations() [5/6]

void moveit::core::RobotState::setJointGroupAccelerations ( const std::string &  joint_group_name, const Eigen::VectorXd &  values  )

inline

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 855 of file robot_state.h.

Here is the call graph for this function:

setJointGroupAccelerations() [6/6]

void moveit::core::RobotState::setJointGroupAccelerations ( const std::string &  joint_group_name, const std::vector< double > &  gstate  )

inline

Given accelerations for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 835 of file robot_state.h.

Here is the call graph for this function:

setJointGroupActivePositions() [1/4]

void moveit::core::RobotState::setJointGroupActivePositions	(	const JointModelGroup *	group,
		const Eigen::VectorXd &	values
	)

Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.

Definition at line 606 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupActivePositions() [2/4]

void moveit::core::RobotState::setJointGroupActivePositions	(	const JointModelGroup *	group,
		const std::vector< double > &	gstate
	)

Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.

Definition at line 594 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointGroupActivePositions() [3/4]

void moveit::core::RobotState::setJointGroupActivePositions ( const std::string &  joint_group_name, const Eigen::VectorXd &  values  )

inline

Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.

Definition at line 656 of file robot_state.h.

Here is the call graph for this function:

setJointGroupActivePositions() [4/4]

void moveit::core::RobotState::setJointGroupActivePositions ( const std::string &  joint_group_name, const std::vector< double > &  gstate  )

inline

Given positions for the variables of active joints that make up a group, in the order found in the group (excluding values of mimic joints), set those as the new values that correspond to the group.

Definition at line 638 of file robot_state.h.

Here is the call graph for this function:

setJointGroupPositions() [1/6]

void moveit::core::RobotState::setJointGroupPositions	(	const JointModelGroup *	group,
		const double *	gstate
	)

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 571 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupPositions() [2/6]

void moveit::core::RobotState::setJointGroupPositions	(	const JointModelGroup *	group,
		const Eigen::VectorXd &	values
	)

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 586 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupPositions() [3/6]

void moveit::core::RobotState::setJointGroupPositions ( const JointModelGroup *  group, const std::vector< double > &  gstate  )

inline

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 604 of file robot_state.h.

Here is the call graph for this function:

setJointGroupPositions() [4/6]

void moveit::core::RobotState::setJointGroupPositions ( const std::string &  joint_group_name, const double *  gstate  )

inline

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 583 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointGroupPositions() [5/6]

void moveit::core::RobotState::setJointGroupPositions ( const std::string &  joint_group_name, const Eigen::VectorXd &  values  )

inline

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 616 of file robot_state.h.

Here is the call graph for this function:

setJointGroupPositions() [6/6]

void moveit::core::RobotState::setJointGroupPositions ( const std::string &  joint_group_name, const std::vector< double > &  gstate  )

inline

Given positions for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 592 of file robot_state.h.

Here is the call graph for this function:

setJointGroupVelocities() [1/6]

void moveit::core::RobotState::setJointGroupVelocities	(	const JointModelGroup *	group,
		const double *	gstate
	)

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 640 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupVelocities() [2/6]

void moveit::core::RobotState::setJointGroupVelocities	(	const JointModelGroup *	group,
		const Eigen::VectorXd &	values
	)

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 655 of file robot_state.cpp.

Here is the call graph for this function:

setJointGroupVelocities() [3/6]

void moveit::core::RobotState::setJointGroupVelocities ( const JointModelGroup *  group, const std::vector< double > &  gstate  )

inline

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 744 of file robot_state.h.

Here is the call graph for this function:

setJointGroupVelocities() [4/6]

void moveit::core::RobotState::setJointGroupVelocities ( const std::string &  joint_group_name, const double *  gstate  )

inline

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 726 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointGroupVelocities() [5/6]

void moveit::core::RobotState::setJointGroupVelocities ( const std::string &  joint_group_name, const Eigen::VectorXd &  values  )

inline

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 755 of file robot_state.h.

Here is the call graph for this function:

setJointGroupVelocities() [6/6]

void moveit::core::RobotState::setJointGroupVelocities ( const std::string &  joint_group_name, const std::vector< double > &  gstate  )

inline

Given velocities for the variables that make up a group, in the order found in the group (including values of mimic joints), set those as the new values that correspond to the group.

Definition at line 735 of file robot_state.h.

Here is the call graph for this function:

setJointPositions() [1/6]

void moveit::core::RobotState::setJointPositions	(	const JointModel *	joint,
		const double *	position
	)

Definition at line 486 of file robot_state.cpp.

Here is the call graph for this function:

setJointPositions() [2/6]

void moveit::core::RobotState::setJointPositions	(	const JointModel *	joint,
		const Eigen::Isometry3d &	transform
	)

Definition at line 497 of file robot_state.cpp.

Here is the call graph for this function:

setJointPositions() [3/6]

void moveit::core::RobotState::setJointPositions ( const JointModel *  joint, const std::vector< double > &  position  )

inline

Definition at line 525 of file robot_state.h.

Here is the call graph for this function:

setJointPositions() [4/6]

void moveit::core::RobotState::setJointPositions ( const std::string &  joint_name, const double *  position  )

inline

Definition at line 515 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setJointPositions() [5/6]

void moveit::core::RobotState::setJointPositions ( const std::string &  joint_name, const Eigen::Isometry3d &  transform  )

inline

Definition at line 532 of file robot_state.h.

Here is the call graph for this function:

setJointPositions() [6/6]

void moveit::core::RobotState::setJointPositions ( const std::string &  joint_name, const std::vector< double > &  position  )

inline

Definition at line 520 of file robot_state.h.

Here is the call graph for this function:

setJointVelocities()

void moveit::core::RobotState::setJointVelocities	(	const JointModel *	joint,
		const double *	velocity
	)

Definition at line 508 of file robot_state.cpp.

Here is the call graph for this function:

setToDefaultValues() [1/3]

void moveit::core::RobotState::setToDefaultValues

(

)

Set all joints to their default positions. The default position is 0, or if that is not within bounds then half way between min and max bound.

Definition at line 339 of file robot_state.cpp.

setToDefaultValues() [2/3]

bool moveit::core::RobotState::setToDefaultValues	(	const JointModelGroup *	group,
		const std::string &	name
	)

Set the joints in group to the position name defined in the SRDF.

Definition at line 331 of file robot_state.cpp.

Here is the call graph for this function:

setToDefaultValues() [3/3]

bool moveit::core::RobotState::setToDefaultValues ( const std::string &  group_name, const std::string &  state_name  )

inline

Definition at line 1141 of file robot_state.h.

Here is the call graph for this function:

setToIKSolverFrame() [1/2]

bool moveit::core::RobotState::setToIKSolverFrame	(	Eigen::Isometry3d &	pose,
		const kinematics::KinematicsBaseConstPtr &	solver
	)

Transform pose from the robot model's base frame to the reference frame of the IK solver.

Parameters

pose	- the input to change
solver	- a kin solver whose base frame is important to us

Returns

true if no error

Definition at line 1722 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setToIKSolverFrame() [2/2]

bool moveit::core::RobotState::setToIKSolverFrame	(	Eigen::Isometry3d &	pose,
		const std::string &	ik_frame
	)

Transform pose from the robot model's base frame to the reference frame of the IK solver.

Parameters

pose	- the input to change
ik_frame	- the name of frame of reference of base of ik solver

Returns

true if no error

Definition at line 1727 of file robot_state.cpp.

Here is the call graph for this function:

setToRandomPositions() [1/3]

void moveit::core::RobotState::setToRandomPositions

(

)

Set all joints to random values. Values will be within default bounds.

Definition at line 262 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setToRandomPositions() [2/3]

void moveit::core::RobotState::setToRandomPositions

(

const JointModelGroup *

group

)

Set all joints in group to random values. Values will be within default bounds.

Definition at line 271 of file robot_state.cpp.

Here is the call graph for this function:

setToRandomPositions() [3/3]

void moveit::core::RobotState::setToRandomPositions	(	const JointModelGroup *	group,
		random_numbers::RandomNumberGenerator &	rng
	)

Set all joints in group to random values using a specified random number generator. Values will be within default bounds.

Definition at line 278 of file robot_state.cpp.

Here is the call graph for this function:

setToRandomPositionsNearBy() [1/4]

void moveit::core::RobotState::setToRandomPositionsNearBy	(	const JointModelGroup *	group,
		const RobotState &	seed,
		const std::vector< double > &	distances
	)

Set all joints in group to random values near the value in seed. distances MUST have the same size as group.getActiveJointModels(). Each value in distances is the maximum amount the corresponding active joint in group will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.

Definition at line 286 of file robot_state.cpp.

Here is the call graph for this function:

setToRandomPositionsNearBy() [2/4]

void moveit::core::RobotState::setToRandomPositionsNearBy	(	const JointModelGroup *	group,
		const RobotState &	seed,
		const std::vector< double > &	distances,
		random_numbers::RandomNumberGenerator &	rng
	)

Set all joints in group to random values near the value in seed, using a specified random number generator. distances MUST have the same size as group.getActiveJointModels(). Each value in distances is the maximum amount the corresponding active joint in group will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.

Definition at line 295 of file robot_state.cpp.

Here is the call graph for this function:

setToRandomPositionsNearBy() [3/4]

void moveit::core::RobotState::setToRandomPositionsNearBy	(	const JointModelGroup *	group,
		const RobotState &	seed,
		double	distance
	)

Set all joints in group to random values near the value in seed. distance is the maximum amount each joint value will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.

Definition at line 310 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

setToRandomPositionsNearBy() [4/4]

void moveit::core::RobotState::setToRandomPositionsNearBy	(	const JointModelGroup *	group,
		const RobotState &	seed,
		double	distance,
		random_numbers::RandomNumberGenerator &	rng
	)

Set all joints in group to random values near the value in seed, using a specified random number generator. distance is the maximum amount each joint value will vary from the corresponding value in seed. \distance represents meters for prismatic/positional joints and radians for revolute/orientation joints. Resulting values are clamped within default bounds.

Definition at line 318 of file robot_state.cpp.

Here is the call graph for this function:

setVariableAcceleration() [1/2]

void moveit::core::RobotState::setVariableAcceleration ( const std::string &  variable, double  value  )

inline

Set the acceleration of a variable. If an unknown variable name is specified, an exception is thrown.

Definition at line 381 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setVariableAcceleration() [2/2]

void moveit::core::RobotState::setVariableAcceleration ( int  index, double  value  )

inline

Set the acceleration of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)

Definition at line 388 of file robot_state.h.

setVariableAccelerations() [1/5]

void moveit::core::RobotState::setVariableAccelerations ( const double *  acceleration )

inline

Given an array with acceleration values for all variables, set those values as the accelerations in this state.

Definition at line 348 of file robot_state.h.

Here is the caller graph for this function:

setVariableAccelerations() [2/5]

void moveit::core::RobotState::setVariableAccelerations

(

const std::map< std::string, double > &

variable_map

)

Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 431 of file robot_state.cpp.

setVariableAccelerations() [3/5]

void moveit::core::RobotState::setVariableAccelerations	(	const std::map< std::string, double > &	variable_map,
		std::vector< std::string > &	missing_variables
	)

Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.

Definition at line 438 of file robot_state.cpp.

Here is the call graph for this function:

setVariableAccelerations() [4/5]

void moveit::core::RobotState::setVariableAccelerations ( const std::vector< double > &  acceleration )

inline

Given an array with acceleration values for all variables, set those values as the accelerations in this state.

Definition at line 359 of file robot_state.h.

Here is the call graph for this function:

setVariableAccelerations() [5/5]

void moveit::core::RobotState::setVariableAccelerations	(	const std::vector< std::string > &	variable_names,
		const std::vector< double > &	variable_acceleration
	)

Set the accelerations of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 445 of file robot_state.cpp.

setVariableEffort() [1/7]

void moveit::core::RobotState::setVariableEffort ( const double *  effort )

inline

Given an array with effort values for all variables, set those values as the effort in this state.

Definition at line 445 of file robot_state.h.

Here is the caller graph for this function:

setVariableEffort() [2/7]

void moveit::core::RobotState::setVariableEffort

(

const std::map< std::string, double > &

variable_map

)

Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 454 of file robot_state.cpp.

setVariableEffort() [3/7]

void moveit::core::RobotState::setVariableEffort	(	const std::map< std::string, double > &	variable_map,
		std::vector< std::string > &	missing_variables
	)

Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.

Definition at line 461 of file robot_state.cpp.

Here is the call graph for this function:

setVariableEffort() [4/7]

void moveit::core::RobotState::setVariableEffort ( const std::string &  variable, double  value  )

inline

Set the effort of a variable. If an unknown variable name is specified, an exception is thrown.

Definition at line 472 of file robot_state.h.

Here is the call graph for this function:

setVariableEffort() [5/7]

void moveit::core::RobotState::setVariableEffort ( const std::vector< double > &  effort )

inline

Given an array with effort values for all variables, set those values as the effort in this state.

Definition at line 454 of file robot_state.h.

Here is the call graph for this function:

setVariableEffort() [6/7]

void moveit::core::RobotState::setVariableEffort	(	const std::vector< std::string > &	variable_names,
		const std::vector< double > &	variable_acceleration
	)

Set the effort of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 468 of file robot_state.cpp.

setVariableEffort() [7/7]

void moveit::core::RobotState::setVariableEffort ( int  index, double  value  )

inline

Set the effort of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)

Definition at line 479 of file robot_state.h.

setVariablePosition() [1/2]

void moveit::core::RobotState::setVariablePosition ( const std::string &  variable, double  value  )

inline

Set the position of a single variable. An exception is thrown if the variable name is not known.

Definition at line 188 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setVariablePosition() [2/2]

void moveit::core::RobotState::setVariablePosition ( int  index, double  value  )

inline

Set the position of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)

Definition at line 195 of file robot_state.h.

setVariablePositions() [1/5]

void moveit::core::RobotState::setVariablePositions

(

const double *

position

)

It is assumed positions is an array containing the new positions for all variables in this state. Those values are copied into the state.

Definition at line 349 of file robot_state.cpp.

Here is the caller graph for this function:

setVariablePositions() [2/5]

void moveit::core::RobotState::setVariablePositions

(

const std::map< std::string, double > &

variable_map

)

Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 361 of file robot_state.cpp.

setVariablePositions() [3/5]

void moveit::core::RobotState::setVariablePositions	(	const std::map< std::string, double > &	variable_map,
		std::vector< std::string > &	missing_variables
	)

Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.

Definition at line 388 of file robot_state.cpp.

Here is the call graph for this function:

setVariablePositions() [4/5]

void moveit::core::RobotState::setVariablePositions ( const std::vector< double > &  position )

inline

It is assumed positions is an array containing the new positions for all variables in this state. Those values are copied into the state.

Definition at line 167 of file robot_state.h.

Here is the call graph for this function:

setVariablePositions() [5/5]

void moveit::core::RobotState::setVariablePositions	(	const std::vector< std::string > &	variable_names,
		const std::vector< double > &	variable_position
	)

Set the positions of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.

Definition at line 395 of file robot_state.cpp.

setVariableValues()

void moveit::core::RobotState::setVariableValues ( const sensor_msgs::msg::JointState &  msg )

inline

Definition at line 1125 of file robot_state.h.

Here is the call graph for this function:

setVariableVelocities() [1/5]

void moveit::core::RobotState::setVariableVelocities ( const double *  velocity )

inline

Given an array with velocity values for all variables, set those values as the velocities in this state.

Definition at line 253 of file robot_state.h.

Here is the caller graph for this function:

setVariableVelocities() [2/5]

void moveit::core::RobotState::setVariableVelocities

(

const std::map< std::string, double > &

variable_map

)

Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 408 of file robot_state.cpp.

setVariableVelocities() [3/5]

void moveit::core::RobotState::setVariableVelocities	(	const std::map< std::string, double > &	variable_map,
		std::vector< std::string > &	missing_variables
	)

Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown. Additionally, missing_variables is filled with the names of the variables that are not set.

Definition at line 415 of file robot_state.cpp.

Here is the call graph for this function:

setVariableVelocities() [4/5]

void moveit::core::RobotState::setVariableVelocities ( const std::vector< double > &  velocity )

inline

Given an array with velocity values for all variables, set those values as the velocities in this state.

Definition at line 261 of file robot_state.h.

Here is the call graph for this function:

setVariableVelocities() [5/5]

void moveit::core::RobotState::setVariableVelocities	(	const std::vector< std::string > &	variable_names,
		const std::vector< double > &	variable_velocity
	)

Set the velocities of a set of variables. If unknown variable names are specified, an exception is thrown.

Definition at line 422 of file robot_state.cpp.

setVariableVelocity() [1/2]

void moveit::core::RobotState::setVariableVelocity ( const std::string &  variable, double  value  )

inline

Set the velocity of a variable. If an unknown variable name is specified, an exception is thrown.

Definition at line 282 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

setVariableVelocity() [2/2]

void moveit::core::RobotState::setVariableVelocity ( int  index, double  value  )

inline

Set the velocity of a single variable. The variable is specified by its index (a value associated by the RobotModel to each variable)

Definition at line 289 of file robot_state.h.

update()

void moveit::core::RobotState::update

(

bool

force = false

)

Update all transforms.

Definition at line 730 of file robot_state.cpp.

Here is the call graph for this function:

updateCollisionBodyTransforms()

void moveit::core::RobotState::updateCollisionBodyTransforms

(

)

Update the transforms for the collision bodies. This call is needed before calling collision checking. If updating link transforms or joint transforms is needed, the corresponding updates are also triggered.

Definition at line 743 of file robot_state.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

updateLinkTransforms()

void moveit::core::RobotState::updateLinkTransforms

(

)

Update the reference frame transforms for links. This call is needed before using the transforms of links for coordinate transforms.

Definition at line 775 of file robot_state.cpp.

Here is the caller graph for this function:

updateStateWithLinkAt() [1/2]

void moveit::core::RobotState::updateStateWithLinkAt	(	const LinkModel *	link,
		const Eigen::Isometry3d &	transform,
		bool	backward = false
	)

Update the state after setting a particular link to the input global transform pose.

Definition at line 850 of file robot_state.cpp.

Here is the call graph for this function:

updateStateWithLinkAt() [2/2]

void moveit::core::RobotState::updateStateWithLinkAt ( const std::string &  link_name, const Eigen::Isometry3d &  transform, bool  backward = false  )

inline

Update the state after setting a particular link to the input global transform pose.

This "warps" the given link to the given pose, neglecting the joint values of its parent joint. The link transforms of link and all its descendants are updated, but not marked as dirty, although they do not match the joint values anymore! Collision body transforms are not yet updated, but marked dirty only. Use update(false) or updateCollisionBodyTransforms() to update them as well.

Definition at line 1221 of file robot_state.h.

Here is the call graph for this function:

Here is the caller graph for this function:

zeroAccelerations()

void moveit::core::RobotState::zeroAccelerations

(

)

Set all accelerations to 0.0.

Definition at line 228 of file robot_state.cpp.

Here is the caller graph for this function:

zeroEffort()

void moveit::core::RobotState::zeroEffort

(

)

Set all effort values to 0.0.

Definition at line 234 of file robot_state.cpp.

zeroVelocities()

void moveit::core::RobotState::zeroVelocities

(

)

Set all velocities to 0.0.

Definition at line 222 of file robot_state.cpp.

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• moveit_core/robot_state/include/moveit/robot_state/robot_state.h
• moveit_core/robot_state/src/robot_state.cpp