Trajectory Class Reference

The Trajectory class represents n-dimensional sampled trajectories. More...

#include <RobotAPI/libraries/core/Trajectory.h>

Inheritance diagram for Trajectory:

Classes
struct	TagOrdered
struct	TagTimestamp
struct	TrajData

Public Types
using	ordered_view
using	timestamp_view
typedef boost::multi_index::multi_index_container< TrajData, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< boost::multi_index::tag< TagTimestamp >, boost::multi_index::member< TrajData, double, &TrajData::timestamp > >, boost::multi_index::ordered_unique< boost::multi_index::tag< TagOrdered >, boost::multi_index::member< TrajData, double, &TrajData::timestamp > > > >	TrajDataContainer
using	TrajMap = std::map<double, std::vector<DoubleSeqPtr>>

Public Member Functions
void	addDerivationsToDimension (size_t dimension, const double t, const Ice::DoubleSeq &derivs)
size_t	addDimension (const Ice::DoubleSeq &values, const Ice::DoubleSeq &timestamps=Ice::DoubleSeq(), const std::string name="")
void	addPositionsToDimension (size_t dimension, const Ice::DoubleSeq &values, const Ice::DoubleSeq &timestamps)
ordered_view::const_iterator	begin () const
	Iterators that iterates in incremental order of the timestamps through the trajectory.
TrajectoryPtr	calculateTimeOptimalTrajectory (const Eigen::VectorXd &maxVelocities, const Eigen::VectorXd &maxAccelerations, double maxDeviation, IceUtil::Time const &timestep)
TrajectoryPtr	calculateTimeOptimalTrajectory (double maxVelocity, double maxAcceleration, double maxDeviation, IceUtil::Time const &timestep)
void	clear (bool keepMetaData=false)
VariantDataClassPtr	clone (const Ice::Current &c=Ice::emptyCurrent) const override
TrajectoryPtr	cloneMetaData () const
TrajDataContainer &	data ()
bool	dataExists (double t, size_t dimension=0, size_t derivation=0) const
void	deserialize (const ObjectSerializerBasePtr &, const Ice::Current &=Ice::emptyCurrent) override
void	differentiateDiscretly (size_t derivation)
void	differentiateDiscretlyForDim (size_t trajDimension, size_t derivation)
size_t	dim () const
	dim returns the trajectory dimension count for this trajectory (e.g.
ordered_view::const_iterator	end () const
void	gaussianFilter (double filterRadius)
	gaussianFilter smoothes the trajectory
std::vector< Ice::DoubleSeq >	getAllStates (double t, int maxDeriv=1)
double	getAmplitude (size_t dimension, size_t derivation, double startTime, double endTime) const
Ice::DoubleSeq	getDerivations (double t, size_t dimension, size_t derivations) const
Ice::DoubleSeq	getDimensionData (size_t dimension, size_t derivation=0) const
	getDimensionData gets all entries for one dimensions with order of increasing timestamps
Eigen::VectorXd	getDimensionDataAsEigen (size_t dimension, size_t derivation) const
Eigen::VectorXd	getDimensionDataAsEigen (size_t dimension, size_t derivation, double startTime, double endTime) const
std::string	getDimensionName (size_t dim) const
const Ice::StringSeq &	getDimensionNames () const
double	getDiscretDifferentiationForDimAtT (double t, size_t trajDimension, size_t derivation) const
Ice::DoubleSeq	getDiscreteDifferentiationForDim (size_t trajDimension, size_t derivation) const
double	getLength (size_t derivation, double startTime, double endTime) const
double	getLength (size_t derivation=0) const
	Returns the sum of a all subsequent distances of the entries in the trajectories over all dimensions.
double	getLength (size_t dimension, size_t derivation) const
double	getLength (size_t dimension, size_t derivation, double startTime, double endTime) const
LimitlessStateSeq	getLimitless () const
double	getMax (size_t dimension, size_t derivation, double startTime, double endTime) const
Ice::DoubleSeq	getMaxima (size_t dimension, size_t derivation, double startTime, double endTime) const
Ice::DoubleSeq	getMaximaTimestamps (size_t dimension, size_t derivation, double startTime, double endTime) const
double	getMin (size_t dimension, size_t derivation, double startTime, double endTime) const
Ice::DoubleSeq	getMinima (size_t dimension, size_t derivation, double startTime, double endTime) const
	Calculate all minima.
Ice::DoubleSeq	getMinimaTimestamps (size_t dimension, size_t derivation, double startTime, double endTime) const
TrajectoryPtr	getPart (double startTime, double endTime, size_t numberOfDerivations=0) const
double	getSquaredLength (size_t dimension, size_t derivation) const
double	getSquaredLength (size_t dimension, size_t derivation, double startTime, double endTime) const
double	getState (double t, size_t dim=0, size_t derivation=0)
double	getState (double t, size_t dim=0, size_t derivation=0) const
std::vector< DoubleSeqPtr > &	getStates (double t)
std::vector< DoubleSeqPtr >	getStates (double t) const
Ice::DoubleSeq	getStates (double t, size_t derivation) const
std::map< double, Ice::DoubleSeq >	getStatesAround (double t, size_t derivation, size_t extend) const
template<typename T>
std::map< std::string, T >	getStatesMap (double t, size_t derivation=0) const
double	getTimeLength () const
	Difference between biggest and smallest timestamp.
Ice::DoubleSeq	getTimestamps () const
Ice::FloatSeq	getTimestampsFloat () const
Ice::Int	getType (const Ice::Current &c=Ice::emptyCurrent) const override
double	getWithFunc (const double &(*foo)(const double &, const double &), double initValue, size_t dimension, size_t derivation, double startTime, double endTime) const
Ice::ObjectPtr	ice_clone () const override
void	ice_postUnmarshal () override
void	ice_preMarshal () override
void	negateDim (size_t trajDimension)
	negateDim changes the sign of all values of the given dimension.
TrajectoryPtr	normalize (const double startTime=0.0, const double endTime=1.0)
Trajectory &	operator+= (const Trajectory traj)
Trajectory &	operator= (const Trajectory &source)
std::vector< DoubleSeqPtr > &	operator[] (double timestamp)
std::string	output (const Ice::Current &c=Ice::emptyCurrent) const override
ordered_view::const_reverse_iterator	rbegin () const
void	reconstructFromDerivativeForDim (double valueAtFirstTimestamp, size_t trajDimension, size_t sourceDimOfSystemState, size_t targetDimOfSystemState)
void	removeDerivation (size_t derivation)
void	removeDerivation (size_t dimension, size_t derivation)
void	removeDimension (size_t dimension)
ordered_view::const_reverse_iterator	rend () const
void	scaleValue (const Ice::DoubleSeq &factor)
void	serialize (const ObjectSerializerBasePtr &obj, const Ice::Current &=Ice::emptyCurrent) const override
void	setDimensionNames (const Ice::StringSeq dimNames)
void	setEntries (const double t, const size_t dimIndex, const Ice::DoubleSeq &y)
void	setLimitless (const LimitlessStateSeq &limitlessStates)
void	setPositionEntry (const double t, const size_t dimIndex, const double &y)
void	shiftTime (double shift)
void	shiftValue (const Ice::DoubleSeq &shift)
size_t	size () const
	Returns number of data entries (i.e.
Eigen::MatrixXd	toEigen (size_t derivation, double startTime, double endTime) const
Eigen::MatrixXd	toEigen (size_t derivation=0) const
	Trajectory ()
	Trajectory (const std::map< double, Ice::DoubleSeq > &data)
template<typename T>
	Trajectory (const std::vector< std::vector< std::vector< T > > > &data, const Ice::DoubleSeq timestamps=Ice::DoubleSeq(), const Ice::StringSeq &dimensionNames={})
template<typename T>
	Trajectory (const std::vector< std::vector< T > > &data, const Ice::DoubleSeq timestamps=Ice::DoubleSeq(), const Ice::StringSeq &dimensionNames={})
	Constructor to add n-dimensions with m-values.
template<typename T>
	Trajectory (const std::vector< T > &data, const Ice::DoubleSeq timestamps=Ice::DoubleSeq(), const std::string &dimensionName="", typename std::enable_if_t< std::is_arithmetic_v< T > > *t=0)
	Trajectory (const Trajectory &source)
bool	validate (const Ice::Current &c=Ice::emptyCurrent) override

Static Public Member Functions
static void	CopyData (const Trajectory &source, Trajectory &destination)
static void	CopyMetaData (const Trajectory &source, Trajectory &destination)
static Ice::DoubleSeq	DifferentiateDiscretly (const Ice::DoubleSeq &timestamps, const Ice::DoubleSeq &values, int derivationCount=1)
template<typename T>
static Ice::DoubleSeq	GenerateTimestamps (const std::vector< T > &values)
static Ice::DoubleSeq	GenerateTimestamps (double startTime=0.0, double endTime=1.0, double stepSize=0.001)
static Ice::DoubleSeq	NormalizeTimestamps (const Ice::DoubleSeq &timestamps, const double startTime=0.0, const double endTime=1.0)
static Trajectory	NormalizeTimestamps (const Trajectory &traj, const double startTime=0.0, const double endTime=1.0)

Protected Member Functions
void	__addDimension ()
std::vector< DoubleSeqPtr >	__calcBaseDataAtTimestamp (const double &t) const
void	__fillAllEmptyFields ()
timestamp_view::iterator	__fillBaseDataAtTimestamp (const double &t)
double	__gaussianFilter (double filterRadius, typename ordered_view::iterator centerIt, size_t trajNum, size_t dim)
virtual double	__interpolate (double t, ordered_view::const_iterator itPrev, ordered_view::const_iterator itNext, size_t dimension, size_t derivation) const
double	__interpolate (double t, size_t dimension, size_t derivation) const
double	__interpolate (typename ordered_view::const_iterator itMap, size_t dimension, size_t derivation) const
	~Trajectory () override

Protected Attributes
TrajDataContainer	dataMap

Detailed Description

The Trajectory class represents n-dimensional sampled trajectories.

The class interpolates all missing values with linear interpolation and calculates derivations. This means trajectories with different timestamps can easily be used. Velocities or accelerations can easily be queried with the derivation parameters of many functions. Access complexity for a query with a timestamp is like from an unordered_map.

Internal structure of the Trajectory class

Basic usage:

    Ice::DoubleSeq joint1Values{0, 5, 1}; // fill with your values;
    Ice::DoubleSeq joint2Values{1, 3, 1}; // fill with your values;
    Ice::DoubleSeq joint3Values{0, 2, 5}; // fill with your values;
    Ice::DoubleSeq timestamps = Trajectory::GenerateTimestamps(
        0, 1, 1.0 / (joint1Values.size() - 1)); // if you dont have timestamps
    TrajectoryPtr trajectory(new Trajectory(
        DoubleSeqSeq{joint1Values, joint2Values}, timestamps, {"Shoulder 0 R", "Shoulder 1 R"}));
    trajectory->addDimension(joint3Values, timestamps, "Shoulder 2 R");
 
    double timestamp = 0.1;
    double dimension = 0;
    double derivation = 0;
    double j1posAtT = trajectory->getState(timestamp, dimension, derivation);
    // or
    Ice::DoubleSeq j1positions = trajectory->getDimensionData(dimension, derivation);

The trajectory offers normal iterator capabilities:

    Trajectory::ordered_view::iterator it; // or just auto it;
    it = trajectory->begin();
    for (; it != trajectory->end(); it++)
    {
        const Trajectory::TrajData& data = *it;
        ARMARX_INFO_S << "Position at " << data.getTimestamp() << " :" << data.getPosition(0);
    }
 
    // or with c++11 for loop:
    for (const Trajectory::TrajData& element : *trajectory)
    {
        ARMARX_INFO_S << "Position at " << element.getTimestamp() << " :" << element.getPosition(0);
    }

Note

Only const iterators are currently available.

With the iterators it can be used like a std container:

    FloatSeqSeq positions{{0, 0, 1}, {0, 1, 1}};
    TrajectoryPtr traj = new Trajectory(positions, {}, {"joint1", "joint2"});
    std::vector<Trajectory::TrajData> selection(traj->size());
    // select all elements with velocity > 0
    auto it = std::copy_if(traj->begin(),
                           traj->end(),
                           selection.begin(),
                           [](const Trajectory::TrajData& elem)
                           { return fabs(elem.getDeriv(0, 1)) > 0; });
    selection.resize(std::distance(selection.begin(), it));

Member Typedef Documentation

ordered_view

using ordered_view

Initial value:

 
            typename boost::multi_index::index<TrajDataContainer, TagOrdered>::type

timestamp_view

using timestamp_view

Initial value:

 
            typename boost::multi_index::index<TrajDataContainer, TagTimestamp>::type

TrajDataContainer

typedef boost::multi_index::multi_index_container< TrajData, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< boost::multi_index::tag<TagTimestamp>, boost::multi_index::member<TrajData, double, &TrajData::timestamp> >, boost::multi_index::ordered_unique< boost::multi_index::tag<TagOrdered>, boost::multi_index::member< TrajData, double, &TrajData::timestamp> > > > TrajDataContainer

TrajMap

using TrajMap = std::map<double, std::vector<DoubleSeqPtr>>

Constructor & Destructor Documentation

~Trajectory()

~Trajectory ( )

overrideprotecteddefault

Trajectory() [1/6]

Trajectory ( )

inline

Trajectory() [2/6]

Trajectory

(

const Trajectory &

source

)

Trajectory() [3/6]

template<typename T>

Trajectory ( const std::vector< T > & data, const Ice::DoubleSeq timestamps = Ice::DoubleSeq(), const std::string & dimensionName = "", typename std::enable_if_t< std::is_arithmetic_v< T > > * t = 0 )

inline

Trajectory() [4/6]

template<typename T>

Trajectory ( const std::vector< std::vector< T > > & data, const Ice::DoubleSeq timestamps = Ice::DoubleSeq(), const Ice::StringSeq & dimensionNames = {} )

inline

Constructor to add n-dimensions with m-values.

Parameters

data	data vector (size n) with positions (size m). Dimension 1 is the joint dimension and Dimension 2 is the position of that joint.
timestamps	timestamps of the trajectory. If not empty, need to be of same size as the inner values of data. If empty, timestamps from 0..1 are generated with a stepsize aligned with the size of the inner vector of data.

Trajectory() [5/6]

template<typename T>

Trajectory ( const std::vector< std::vector< std::vector< T > > > & data, const Ice::DoubleSeq timestamps = Ice::DoubleSeq(), const Ice::StringSeq & dimensionNames = {} )

inline

Trajectory() [6/6]

Trajectory

(

const std::map< double, Ice::DoubleSeq > &

data

)

Member Function Documentation

__addDimension()

void __addDimension ( )

protected

__calcBaseDataAtTimestamp()

std::vector< DoubleSeqPtr > __calcBaseDataAtTimestamp ( const double & t ) const

protected

__fillAllEmptyFields()

void __fillAllEmptyFields ( )

protected

__fillBaseDataAtTimestamp()

Trajectory::timestamp_view::iterator __fillBaseDataAtTimestamp ( const double & t )

protected

__gaussianFilter()

double __gaussianFilter ( double filterRadius, typename ordered_view::iterator centerIt, size_t trajNum, size_t dim )

protected

__interpolate() [1/3]

double __interpolate ( double t, ordered_view::const_iterator itPrev, ordered_view::const_iterator itNext, size_t dimension, size_t derivation ) const

protectedvirtual

__interpolate() [2/3]

double __interpolate ( double t, size_t dimension, size_t derivation ) const

protected

__interpolate() [3/3]

double __interpolate ( typename ordered_view::const_iterator itMap, size_t dimension, size_t derivation ) const

protected

addDerivationsToDimension()

void addDerivationsToDimension	(	size_t	dimension,
		const double	t,
		const Ice::DoubleSeq &	derivs )

addDimension()

size_t addDimension	(	const Ice::DoubleSeq &	values,
		const Ice::DoubleSeq &	timestamps = Ice::DoubleSeq(),
		const std::string	name = "" )

addPositionsToDimension()

void addPositionsToDimension	(	size_t	dimension,
		const Ice::DoubleSeq &	values,
		const Ice::DoubleSeq &	timestamps )

begin()

Trajectory::ordered_view::const_iterator begin

(

)

const

Iterators that iterates in incremental order of the timestamps through the trajectory.

Note

Only const versions are available currently.

See also

end(), rbegin(), rend()

calculateTimeOptimalTrajectory() [1/2]

TrajectoryPtr calculateTimeOptimalTrajectory	(	const Eigen::VectorXd &	maxVelocities,
		const Eigen::VectorXd &	maxAccelerations,
		double	maxDeviation,
		IceUtil::Time const &	timestep )

calculateTimeOptimalTrajectory() [2/2]

TrajectoryPtr calculateTimeOptimalTrajectory	(	double	maxVelocity,
		double	maxAcceleration,
		double	maxDeviation,
		IceUtil::Time const &	timestep )

clear()

void clear

(

bool

keepMetaData = false

)

clone()

VariantDataClassPtr clone ( const Ice::Current & c = Ice::emptyCurrent ) const

override

cloneMetaData()

TrajectoryPtr cloneMetaData

(

)

const

CopyData()

void CopyData ( const Trajectory & source, Trajectory & destination )

static

CopyMetaData()

void CopyMetaData ( const Trajectory & source, Trajectory & destination )

static

data()

Trajectory::TrajDataContainer & data

(

)

dataExists()

bool dataExists	(	double	t,
		size_t	dimension = 0,
		size_t	derivation = 0 ) const

deserialize()

void deserialize ( const ObjectSerializerBasePtr & serializer, const Ice::Current & = Ice::emptyCurrent )

override

DifferentiateDiscretly()

Ice::DoubleSeq DifferentiateDiscretly ( const Ice::DoubleSeq & timestamps, const Ice::DoubleSeq & values, int derivationCount = 1 )

static

differentiateDiscretly()

void differentiateDiscretly

(

size_t

derivation

)

differentiateDiscretlyForDim()

void differentiateDiscretlyForDim	(	size_t	trajDimension,
		size_t	derivation )

dim()

size_t dim

(

)

const

dim returns the trajectory dimension count for this trajectory (e.g.

taskspace w/o orientation would be 3)

Returns

end()

Trajectory::ordered_view::const_iterator end

(

)

const

gaussianFilter()

void gaussianFilter

(

double

filterRadius

)

gaussianFilter smoothes the trajectory

Parameters

filterRadius,in

easy words: time range to left and right from center that influences the resulting center value

GenerateTimestamps() [1/2]

template<typename T>

static Ice::DoubleSeq GenerateTimestamps ( const std::vector< T > & values )

inlinestatic

GenerateTimestamps() [2/2]

Ice::DoubleSeq GenerateTimestamps ( double startTime = 0.0, double endTime = 1.0, double stepSize = 0.001 )

static

getAllStates()

std::vector< Ice::DoubleSeq > getAllStates	(	double	t,
		int	maxDeriv = 1 )

getAmplitude()

double getAmplitude	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getDerivations()

Ice::DoubleSeq getDerivations	(	double	t,
		size_t	dimension,
		size_t	derivations ) const

getDimensionData()

Ice::DoubleSeq getDimensionData	(	size_t	dimension,
		size_t	derivation = 0 ) const

getDimensionData gets all entries for one dimensions with order of increasing timestamps

Parameters

dimension
derivation

Returns

getDimensionDataAsEigen() [1/2]

Eigen::VectorXd getDimensionDataAsEigen	(	size_t	dimension,
		size_t	derivation ) const

getDimensionDataAsEigen() [2/2]

Eigen::VectorXd getDimensionDataAsEigen	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getDimensionName()

std::string getDimensionName

(

size_t

dim

)

const

getDimensionNames()

const Ice::StringSeq & getDimensionNames

(

)

const

getDiscretDifferentiationForDimAtT()

double getDiscretDifferentiationForDimAtT	(	double	t,
		size_t	trajDimension,
		size_t	derivation ) const

getDiscreteDifferentiationForDim()

Ice::DoubleSeq getDiscreteDifferentiationForDim	(	size_t	trajDimension,
		size_t	derivation ) const

getLength() [1/4]

double getLength	(	size_t	derivation,
		double	startTime,
		double	endTime ) const

getLength() [2/4]

double getLength

(

size_t

derivation = 0

)

const

Returns the sum of a all subsequent distances of the entries in the trajectories over all dimensions.

Parameters

derivation

Derivation for which the length is calculated

getLength() [3/4]

double getLength	(	size_t	dimension,
		size_t	derivation ) const

getLength() [4/4]

double getLength	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getLimitless()

LimitlessStateSeq getLimitless

(

)

const

getMax()

double getMax	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getMaxima()

Ice::DoubleSeq getMaxima	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getMaximaTimestamps()

Ice::DoubleSeq getMaximaTimestamps	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getMin()

double getMin	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getMinima()

Ice::DoubleSeq getMinima	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

Calculate all minima.

Parameters

dimension
derivation
startTime
endTime

Returns

getMinimaTimestamps()

Ice::DoubleSeq getMinimaTimestamps	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getPart()

TrajectoryPtr getPart	(	double	startTime,
		double	endTime,
		size_t	numberOfDerivations = 0 ) const

getSquaredLength() [1/2]

double getSquaredLength	(	size_t	dimension,
		size_t	derivation ) const

getSquaredLength() [2/2]

double getSquaredLength	(	size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

getState() [1/2]

double getState	(	double	t,
		size_t	dim = 0,
		size_t	derivation = 0 )

getState() [2/2]

double getState	(	double	t,
		size_t	dim = 0,
		size_t	derivation = 0 ) const

getStates() [1/3]

std::vector< DoubleSeqPtr > & getStates

(

double

t

)

getStates() [2/3]

std::vector< DoubleSeqPtr > getStates

(

double

t

)

const

getStates() [3/3]

Ice::DoubleSeq getStates	(	double	t,
		size_t	derivation ) const

getStatesAround()

std::map< double, Ice::DoubleSeq > getStatesAround	(	double	t,
		size_t	derivation,
		size_t	extend ) const

getStatesMap()

template<typename T>

std::map< std::string, T > getStatesMap ( double t, size_t derivation = 0 ) const

inline

getTimeLength()

double getTimeLength

(

)

const

Difference between biggest and smallest timestamp.

If size() <=1 -> return 0.

getTimestamps()

Ice::DoubleSeq getTimestamps

(

)

const

getTimestampsFloat()

Ice::FloatSeq getTimestampsFloat

(

)

const

getType()

Ice::Int getType ( const Ice::Current & c = Ice::emptyCurrent ) const

override

getWithFunc()

double getWithFunc	(	const double &(*	foo )(const double &, const double &),
		double	initValue,
		size_t	dimension,
		size_t	derivation,
		double	startTime,
		double	endTime ) const

ice_clone()

Ice::ObjectPtr ice_clone ( ) const

override

ice_postUnmarshal()

void ice_postUnmarshal ( )

override

ice_preMarshal()

void ice_preMarshal ( )

override

negateDim()

void negateDim

(

size_t

trajDimension

)

negateDim changes the sign of all values of the given dimension.

normalize()

TrajectoryPtr normalize	(	const double	startTime = 0.0,
		const double	endTime = 1.0 )

NormalizeTimestamps() [1/2]

Ice::DoubleSeq NormalizeTimestamps ( const Ice::DoubleSeq & timestamps, const double startTime = 0.0, const double endTime = 1.0 )

static

NormalizeTimestamps() [2/2]

Trajectory NormalizeTimestamps ( const Trajectory & traj, const double startTime = 0.0, const double endTime = 1.0 )

static

operator+=()

Trajectory & operator+=

(

const Trajectory

traj

)

operator=()

Trajectory & operator=

(

const Trajectory &

source

)

operator[]()

std::vector< DoubleSeqPtr > & operator[]

(

double

timestamp

)

output()

std::string output ( const Ice::Current & c = Ice::emptyCurrent ) const

override

rbegin()

Trajectory::ordered_view::const_reverse_iterator rbegin

(

)

const

reconstructFromDerivativeForDim()

void reconstructFromDerivativeForDim	(	double	valueAtFirstTimestamp,
		size_t	trajDimension,
		size_t	sourceDimOfSystemState,
		size_t	targetDimOfSystemState )

removeDerivation() [1/2]

void removeDerivation

(

size_t

derivation

)

removeDerivation() [2/2]

void removeDerivation	(	size_t	dimension,
		size_t	derivation )

removeDimension()

void removeDimension

(

size_t

dimension

)

rend()

Trajectory::ordered_view::const_reverse_iterator rend

(

)

const

scaleValue()

void scaleValue

(

const Ice::DoubleSeq &

factor

)

serialize()

void serialize ( const ObjectSerializerBasePtr & obj, const Ice::Current & = Ice::emptyCurrent ) const

override

setDimensionNames()

void setDimensionNames ( const Ice::StringSeq dimNames )

inline

setEntries()

void setEntries	(	const double	t,
		const size_t	dimIndex,
		const Ice::DoubleSeq &	y )

setLimitless()

void setLimitless

(

const LimitlessStateSeq &

limitlessStates

)

setPositionEntry()

void setPositionEntry	(	const double	t,
		const size_t	dimIndex,
		const double &	y )

shiftTime()

void shiftTime

(

double

shift

)

shiftValue()

void shiftValue

(

const Ice::DoubleSeq &

shift

)

size()

size_t size

(

)

const

Returns number of data entries (i.e.

positions) in the trajectory.

toEigen() [1/2]

Eigen::MatrixXd toEigen	(	size_t	derivation,
		double	startTime,
		double	endTime ) const

toEigen() [2/2]

Eigen::MatrixXd toEigen

(

size_t

derivation = 0

)

const

validate()

bool validate ( const Ice::Current & c = Ice::emptyCurrent )

override

Member Data Documentation

dataMap

TrajDataContainer dataMap

protected

---

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

• RobotAPI/libraries/core/Trajectory.h
• RobotAPI/libraries/core/Trajectory.cpp