hpp::manipulation::steeringMethod::EndEffectorTrajectory Class Reference

#include <hpp/manipulation/steering-method/end-effector-trajectory.hh>

Inheritance diagram for hpp::manipulation::steeringMethod::EndEffectorTrajectory:

Collaboration diagram for hpp::manipulation::steeringMethod::EndEffectorTrajectory:

Public Types
typedef core::interval_t	interval_t

Public Member Functions
void	trajectoryConstraint (const constraints::ImplicitPtr_t &ic)
	Set the constraint whose right hand side will vary.
const constraints::ImplicitPtr_t &	trajectoryConstraint ()
void	trajectory (const PathPtr_t &eeTraj, bool se3Output)
void	trajectory (const DifferentiableFunctionPtr_t &eeTraj, const interval_t &timeRange)
const DifferentiableFunctionPtr_t &	trajectory () const
const interval_t &	timeRange () const
core::SteeringMethodPtr_t	copy () const
PathPtr_t	projectedPath (vectorIn_t times, matrixIn_t configs) const
Public Member Functions inherited from hpp::core::SteeringMethod
PathPtr_t	operator() (ConfigurationIn_t q1, ConfigurationIn_t q2) const
PathPtr_t	steer (ConfigurationIn_t q1, ConfigurationIn_t q2) const
virtual	~SteeringMethod ()
ProblemConstPtr_t	problem () const
void	constraints (const ConstraintSetPtr_t &constraints)
const ConstraintSetPtr_t &	constraints () const
void	constraints (const ConstraintSetPtr_t &constraints)
const ConstraintSetPtr_t &	constraints () const

Static Public Member Functions
static EndEffectorTrajectoryPtr_t	create (const core::ProblemConstPtr_t &problem) HPP_MANIPULATION_DEPRECATED
static PathPtr_t	makePiecewiseLinearTrajectory (matrixIn_t points, vectorIn_t weights)

Protected Member Functions
	EndEffectorTrajectory (const core::ProblemConstPtr_t &problem)
	EndEffectorTrajectory (const EndEffectorTrajectory &other)
PathPtr_t	impl_compute (ConfigurationIn_t q1, ConfigurationIn_t q2) const
Protected Member Functions inherited from hpp::core::SteeringMethod
	SteeringMethod (const ProblemConstPtr_t &problem)
	SteeringMethod (const SteeringMethod &other)
void	init (SteeringMethodWkPtr_t weak)

Detailed Description

Build piecewise straight paths for a robot end-effector

To use this steering method, the user needs to provide

• a constraint with value in \(SE(3)\). An easy way to create such a constraint is to use method hpp::manipulation::Handle::createGrasp. The constraint is passed to the steering method using method trajectoryConstraint .
• the time-varying right hand side of this constraint along the path the user wants to create in the form of a hpp::core::Path instance with values in \(SE(3)\). For that, makePiecewiseLinearTrajectory method may be useful.

Warning

the constraint should also be inserted in the set of constraints of the steering method.

Once the steering method has been initialized, it can be called between two configurations q1 and q2. The interval of definition \([0,T]\) of the output path is the same as the one of the path provided as the right hand side of the constraint. Note that q1 and q2 should satisfy the constraint at times 0 and \(T\) respectively. The output path is a linear interpolation between q1 and q2 projected on the steering method constraints.

Deprecated

This class was used by the planner class with the same name that has been deprecated.

Member Typedef Documentation

interval_t

typedef core::interval_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::interval_t

Constructor & Destructor Documentation

EndEffectorTrajectory() [1/2]

hpp::manipulation::steeringMethod::EndEffectorTrajectory::EndEffectorTrajectory ( const core::ProblemConstPtr_t & problem )

inlineprotected

EndEffectorTrajectory() [2/2]

hpp::manipulation::steeringMethod::EndEffectorTrajectory::EndEffectorTrajectory ( const EndEffectorTrajectory & other )

inlineprotected

Member Function Documentation

copy()

core::SteeringMethodPtr_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::copy ( ) const

inlinevirtual

Implements hpp::core::SteeringMethod.

create()

static EndEffectorTrajectoryPtr_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::create ( const core::ProblemConstPtr_t & problem )

inlinestatic

impl_compute()

PathPtr_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::impl_compute ( ConfigurationIn_t q1, ConfigurationIn_t q2 ) const

protectedvirtual

Implements hpp::core::SteeringMethod.

makePiecewiseLinearTrajectory()

static PathPtr_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::makePiecewiseLinearTrajectory ( matrixIn_t points, vectorIn_t weights )

static

Build a trajectory in SE(3).

Parameters

points	a Nx7 matrix whose rows corresponds to poses.
weights	a 6D vector, weights to be applied when computing the distance between two SE3 points.

The trajectory \(T\) is defined as follows. Let \(N\) be the number of lines of matrix points, \(p_i\) be the i-th line of points and let \(W\) be the diagonal matrix with the coefficients of weights:

\[ W = \left(\begin{array}{cccccc} w_1 & 0 & 0 & 0 & 0 & 0\\ 0 & w_2 & 0 & 0 & 0 & 0\\ 0 & 0 & w_3 & 0 & 0 & 0\\ 0 & 0 & 0 & w_4 & 0 & 0\\ 0 & 0 & 0 & 0 & w_5 & 0\\ 0 & 0 & 0 & 0 & 0 & w_6\\ \end{array}\right) \]

\begin{eqnarray*} f(t) = \mathbf{p}_i \oplus \frac{t-t_i}{t_{i+1}-t_i} (\mathbf{p}_{i+1}-\mathbf{p}_i) && \mbox{ for } t \in [t_i,t_{i+1}] \end{eqnarray*}

where \(t_0 = 0\) and

\begin{eqnarray*} t_{i+1}-t_i = \|W(\mathbf{p}_{i+1}-\mathbf{p}_i)\| && \mbox{for } i \mbox{ such that } 1 \leq i \leq N-1 \end{eqnarray*}

projectedPath()

PathPtr_t hpp::manipulation::steeringMethod::EndEffectorTrajectory::projectedPath	(	vectorIn_t	times,
		matrixIn_t	configs ) const

Computes an core::InterpolatedPath from the provided interpolation points.

Parameters

times	the time of each configuration
configs	each column correspond to a configuration

timeRange()

const interval_t & hpp::manipulation::steeringMethod::EndEffectorTrajectory::timeRange ( ) const

inline

trajectory() [1/3]

const DifferentiableFunctionPtr_t & hpp::manipulation::steeringMethod::EndEffectorTrajectory::trajectory ( ) const

inline

trajectory() [2/3]

void hpp::manipulation::steeringMethod::EndEffectorTrajectory::trajectory	(	const DifferentiableFunctionPtr_t &	eeTraj,
		const interval_t &	timeRange )

Set the right hand side of the function from another function.

Parameters

eeTraj	a function whose input space is of dimension 1.
timeRange	the input range of eeTraj.

trajectory() [3/3]

void hpp::manipulation::steeringMethod::EndEffectorTrajectory::trajectory	(	const PathPtr_t &	eeTraj,
		bool	se3Output )

Set the right hand side of the function from a path

Parameters

se3Output

set to True if the output of path must be understood as SE3.

trajectoryConstraint() [1/2]

const constraints::ImplicitPtr_t & hpp::manipulation::steeringMethod::EndEffectorTrajectory::trajectoryConstraint ( )

inline

trajectoryConstraint() [2/2]

void hpp::manipulation::steeringMethod::EndEffectorTrajectory::trajectoryConstraint

(

const constraints::ImplicitPtr_t &

ic

)

Set the constraint whose right hand side will vary.

---

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

• include/hpp/manipulation/steering-method/end-effector-trajectory.hh