Class for the output parameters of the On-Line Trajectory Generation algorithm. More...

#include <RMLOutputParameters.h>

Inheritance diagram for RMLOutputParameters:

Public Types
enum	ReturnValue { RETURN_SUCCESS = 0, RETURN_ERROR = -1 }
	Return values for the methods of the class RMLOutputParameters. More...
Public Member Functions
	~RMLOutputParameters (void)
	Destructor of class RMLOutputParameters.
RMLOutputParameters &	operator= (const RMLOutputParameters &OP)
	Copy operator.
void	GetNewPositionVector (RMLDoubleVector *OutputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the new position vector $\vec{P}_{i+1}$ to the `RMLDoubleVector` object referred to by `OutputVector`.
void	GetNewPositionVector (double *OutputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the new position vector $\vec{P}_{i+1}$ to the memory pointed to by `OutputVector`.
void	GetNewPositionVectorElement (double *OutputValue, const unsigned int &Index) const
	Copies one element of the new selection vector $\vec{P}_{i+1}$ to the memory pointed to by `OutputValue`.
double	GetNewPositionVectorElement (const unsigned int &Index) const
	Returns one single element of the new selection vector $\vec{P}_{i+1}$ .
void	GetNewVelocityVector (RMLDoubleVector *OutputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the new velocity vector $\vec{V}_{i+1}$ to the `RMLDoubleVector` object referred to by `OutputVector`.
void	GetNewVelocityVector (double *OutputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the new velocity vector $\vec{V}_{i+1}$ to the memory pointed to by `OutputVector`.
void	GetNewVelocityVectorElement (double *OutputValue, const unsigned int &Index) const
	Copies one element of the new selection vector $\vec{V}_{i+1}$ to the memory pointed to by `OutputValue`.
double	GetNewVelocityVectorElement (const unsigned int &Index) const
	Returns one single element of the new selection vector $\vec{V}_{i+1}$ .
void	GetNewAccelerationVector (RMLDoubleVector *OutputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the new acceleration vector $\vec{A}_{i+1}$ to the `RMLDoubleVector` object referred to by `OutputVector`.
void	GetNewAccelerationVector (double *OutputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the new acceleration vector $\vec{A}_{i+1}$ to the memory pointed to by `OutputVector`.
void	GetNewAccelerationVectorElement (double *OutputValue, const unsigned int &Index) const
	Copies one element of the new selection vector $\vec{A}_{i+1}$ to the memory pointed to by `OutputValue`.
double	GetNewAccelerationVectorElement (const unsigned int &Index) const
	Returns one single element of the new selection vector $\vec{A}_{i+1}$ .
void	GetPositionalExtrema (RMLDoubleVector MinimumPositionVector, RMLDoubleVector MaximumPositionVector) const
	Copies two `RMLDoubleVector` objects that contain the minimum and maximum positions, which are reached until the target state of motion is reached.
void	GetPositionalExtrema (double MinimumPositionVector, double MaximumPositionVector, const unsigned int &SizeInBytes) const
	Copies two `RMLDoubleVector` objects that contain the minimum and maximum positions, which are reached until the target state of motion is reached.
void	GetTimesAtMinPosition (RMLDoubleVector *ExtremaTimes) const
	Copies the contents of a `RMLDoubleVector` object that contains the times (in seconds) at which the minimum positions are reached to the `RMLDoubleVector` object referred to by `ExtremaTimes`.
void	GetTimesAtMaxPosition (RMLDoubleVector *ExtremaTimes) const
	Copies the contents of a `RMLDoubleVector` object that contains the times (in seconds) at which the maximum positions are reached to the `RMLDoubleVector` object referred to by `ExtremaTimes`.
void	GetTimesAtMinPosition (double *ExtremaTimes, const unsigned int &SizeInBytes) const
	Copies the array of `double` values that contain the time values (in seconds) at which the minimum positions are reached to the array of `double` values referred to by `ExtremaTimes`.
void	GetTimesAtMaxPosition (double *ExtremaTimes, const unsigned int &SizeInBytes) const
	Copies the array of `double` values that contain the time values (in seconds) at which the maximum positions are reached to the array of `double` values referred to by `ExtremaTimes`.
int	GetMotionStateAtMinPosForOneDOF (const unsigned int &DOF, RMLDoubleVector PositionVector, RMLDoubleVector VelocityVector, RMLDoubleVector *AccelerationVector) const
	Copies the motion state, at which the position of the degree of freedom with the index `DOF` has reached its minimum, to the three referred `RMLDoubleVector` objects.
int	GetMotionStateAtMinPosForOneDOF (const unsigned int &DOF, double PositionVector, double VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const
	Copies the motion state, at which the position of the degree of freedom with the index `DOF` has reached its minimum, to the three referred arrays of `double` values.
int	GetMotionStateAtMaxPosForOneDOF (const unsigned int &DOF, RMLDoubleVector PositionVector, RMLDoubleVector VelocityVector, RMLDoubleVector *AccelerationVector) const
	Copies the motion state, at which the position of the degree of freedom with the index `DOF` has reached its maximum, to the three referred `RMLDoubleVector` objects.
int	GetMotionStateAtMaxPosForOneDOF (const unsigned int &DOF, double PositionVector, double VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const
	Copies the motion state, at which the position of the degree of freedom with the index `DOF` has reached its maximum, to the three referred arrays of `double` values.
unsigned int	GetNumberOfDOFs (void) const
	Returns the number of degrees of freedom.
bool	WasACompleteComputationPerformedDuringTheLastCycle (void) const
	Indicates, whether a new computation was performed in the last cycle.
bool	IsTrajectoryPhaseSynchronized (void) const
	Indicates whether the currently calculated trajectory is phase- synchronized or only time-synchronized.
double	GetSynchronizationTime (void) const
	Returns the synchronization time.
unsigned int	GetDOFWithTheGreatestExecutionTime (void) const
	Returns the index of the degree of freedom with the greatest trajectory execution time.
void	GetExecutionTimes (RMLDoubleVector *OutputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the `RMLDoubleVector` object referred to by `OutputVector`.
void	GetExecutionTimes (double *OutputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the memory pointed to by `OutputVector`.
void	GetExecutionTimesElement (double *OutputValue, const unsigned int &Index) const
	Copies one element of the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the memory pointed to by `OutputValue`.
double	GetExecutionTimesElement (const unsigned int &Index) const
	Returns one single element of the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached.
double	GetGreatestExecutionTime (void) const
	Returns the time value in seconds which is required by the degree with the greatest execution to reach its desired target velocity.
Public Attributes
bool	ANewCalculationWasPerformed
	Indicates, whether a new computation was performed in the last cycle.
bool	TrajectoryIsPhaseSynchronized
	Boolean flag that indicates whether the current trajectory is phase-synchronized.
unsigned int	NumberOfDOFs
	The number of degrees of freedom .
unsigned int	DOFWithTheGreatestExecutionTime
	Index of the degree of freedom that requires the greatest execution time to reach its desired target velocity value.
double	SynchronizationTime
	The synchronization time $t_{i}^{\,sync}$ in seconds.
RMLDoubleVector *	NewPositionVector
	A pointer to the new position vector $\vec{P}_{i+1}$ .
RMLDoubleVector *	NewVelocityVector
	A pointer to the new velocity vector $\vec{V}_{i+1}$ .
RMLDoubleVector *	NewAccelerationVector
	A pointer to the new acceleration vector $\vec{A}_{i+1}$ .
RMLDoubleVector *	MinExtremaTimesVector
	A pointer to an `RMLDoubleVector` object that contains the times at which each degree of freedom reaches its minimum position during the execution of the calculated trajectory.
RMLDoubleVector *	MaxExtremaTimesVector
	A pointer to an `RMLDoubleVector` object that contains the times at which each degree of freedom reaches its maximum position during the execution of the calculated trajectory.
RMLDoubleVector *	MinPosExtremaPositionVectorOnly
	A pointer to an `RMLDoubleVector` object that contains the maximum positions for all degrees of freedom that occur during the execution of the calculated trajectory.
RMLDoubleVector *	MaxPosExtremaPositionVectorOnly
	A pointer to an `RMLDoubleVector` object that contains the maximum positions for all degrees of freedom that occur during the execution of the calculated trajectory.
RMLDoubleVector *	ExecutionTimes
	A pointer to an `RMLDoubleVector` object that contains the execution times of all selected degrees of freedom in the case non-synchronized trajectories.
RMLDoubleVector **	MinPosExtremaPositionVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its minimum position.
RMLDoubleVector **	MinPosExtremaVelocityVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the velocity vector, that will be achieved when the respective degree of freedom reaches its minimum position.
RMLDoubleVector **	MinPosExtremaAccelerationVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its minimum position.
RMLDoubleVector **	MaxPosExtremaPositionVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its maximum position.
RMLDoubleVector **	MaxPosExtremaVelocityVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the velocity vector, that will be achieved when the respective degree of freedom reaches its maximum position.
RMLDoubleVector **	MaxPosExtremaAccelerationVectorArray
	A pointer to an array of pointers to `RMLDoubleVector` objects. The number of array elements equals the number of degrees of freedom, and each of these `RMLDOubleVector` objects consists of the same number of entries, such that it is a square matrix. A single vector contains the acceleration vector, that will be achieved when the respective degree of freedom reaches its maximum position.
Protected Member Functions
	RMLOutputParameters (const unsigned int DegreesOfFreedom)
	Constructor of class RMLOutputParameters.
	RMLOutputParameters (const RMLOutputParameters &OP)
	Copy constructor of class RMLPositionOutputParameters.
void	Echo (FILE *FileHandler=stdout) const
	Prints the new state of motion of the output parameters to *FileHandler.

Detailed Description

Class for the output parameters of the On-Line Trajectory Generation algorithm.

The class RMLOutputParameters constitutes the basis class for the actual interface classes RMLPositionOutputParameters and RMLVelocityOutputParameters, which are both derived from this one.

See also:: ReflexxesAPI; RMLPositionOutputParameters; RMLVelocityOutputParameters; RMLInputParameters; Description of Output Values

Member Enumeration Documentation

enum RMLOutputParameters::ReturnValue

Return values for the methods of the class RMLOutputParameters.

Enumerator:

RETURN_SUCCESS
RETURN_ERROR

Constructor & Destructor Documentation

RMLOutputParameters::RMLOutputParameters ( const unsigned int DegreesOfFreedom ) [inline, protected]

Constructor of class RMLOutputParameters.

Warning:: The constructor is not real-time capable as heap memory has to be allocated.

Parameters:

DegreesOfFreedom Specifies the number of degrees of freedom

Note:

This is only the base class for the classes

such that the constructor is declared protected.

RMLOutputParameters::RMLOutputParameters ( const RMLOutputParameters & OP ) [inline, protected]

Copy constructor of class RMLPositionOutputParameters.

Warning:: The constructor is not real-time capable as heap memory has to be allocated.

Parameters:

OP	Object to be copied

Note:

This is only the base class for the classes

such that the constructor is declared protected.

RMLOutputParameters::~RMLOutputParameters ( void ) [inline]

Destructor of class RMLOutputParameters.

Member Function Documentation

void RMLOutputParameters::Echo ( FILE * FileHandler = stdout ) const [inline, protected]

Prints the new state of motion of the output parameters to *FileHandler.

Parameters:

FileHandler File handler for the output

Warning:: The usage of this method is not real-time capable.

Reimplemented in RMLVelocityOutputParameters, and RMLPositionOutputParameters.

unsigned int RMLOutputParameters::GetDOFWithTheGreatestExecutionTime ( void ) const [inline]

Returns the index of the degree of freedom with the greatest trajectory execution time.

See also:: RMLOutputParameters::GetGreatestExecutionTime()

void RMLOutputParameters::GetExecutionTimes ( RMLDoubleVector * OutputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the RMLDoubleVector object referred to by OutputVector.

Parameters:

OutputVector A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetExecutionTimes(double *OutputVector, const unsigned int &SizeInBytes) const; GetExecutionTimesElement(double *OutputValue, const unsigned int &Index) const; RMLOutputParameters::ExecutionTimes

void RMLOutputParameters::GetExecutionTimes	(	double *	OutputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the memory pointed to by OutputVector.

Parameters:

OutputVector	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `OutputVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetExecutionTimes(RMLDoubleVector *OutputVector) const; GetExecutionTimesElement(double *OutputValue, const unsigned int &Index) const; RMLOutputParameters::ExecutionTimes

void RMLOutputParameters::GetExecutionTimesElement	(	double *	OutputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached, to the memory pointed to by OutputValue.

Parameters:

OutputValue	A pointer to one `double` value, to which the desired vector element will be copied
Index	Specifies the desired element of the vector. The element numbering starts with 0 (zero). If this value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by `OutputValue`.

See also:: GetExecutionTimes(RMLDoubleVector *OutputVector) const; GetExecutionTimesElement(double *OutputValue, const unsigned int &Index) const; GetExecutionTimesElement(const unsigned int &Index) const; RMLOutputParameters::ExecutionTimes

double RMLOutputParameters::GetExecutionTimesElement ( const unsigned int & Index ) const [inline]

Returns one single element of the execution times for each degree of freedom, at which the desired target velocity $\ _{k}V_{i}^{\,trgt}$ is reached.

Parameters:

Index Specifies the desired element of the vector. The index of the first vector element is 0 (zero). If the value of Index value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by OutputValue.

See also:: GetExecutionTimesElement(double *OutputValue, const unsigned int &Index) const; RMLOutputParameters::ExecutionTimes

double RMLOutputParameters::GetGreatestExecutionTime ( void ) const [inline]

Returns the time value in seconds which is required by the degree with the greatest execution to reach its desired target velocity.

See also:: GetGreatestExecutionTime (void) const

int RMLOutputParameters::GetMotionStateAtMaxPosForOneDOF	(	const unsigned int &	DOF,
		RMLDoubleVector *	PositionVector,
		RMLDoubleVector *	VelocityVector,
		RMLDoubleVector *	AccelerationVector
	)		const `[inline]`

Copies the motion state, at which the position of the degree of freedom with the index DOF has reached its maximum, to the three referred RMLDoubleVector objects.

Parameters:

DOF	The index of the degree of freedom, whose maximum position is regarded. The motion state of the time instant, at which the maximum position value of this degree of freedom is reached, will be copied to `PositionVector`, `VelocityVector`, and `AccelerationVector`.
PositionVector	A pointer to an `RMLDoubleVector` object, to which the position vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.
VelocityVector	A pointer to an `RMLDoubleVector` object, to which the velocity vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.
AccelerationVector	A pointer to an `RMLDoubleVector` object, to which the acceleration vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.

Returns:

RMLOutputParameters::RETURN_ERROR, if the value of DOF is greater than or equal to the number of degrees of freedom
RMLOutputParameters::RETURN_SUCCESS, else

See also:: GetMotionStateAtMinPosForOneDOF(const unsigned int &DOF, RMLDoubleVector *PositionVector, RMLDoubleVector *VelocityVector, RMLDoubleVector *AccelerationVector) const; GetMotionStateAtMaxPosForOneDOF(const unsigned int &DOF, double *PositionVector, double *VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const; GetTimesAtMaxPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; RMLDoubleVector

int RMLOutputParameters::GetMotionStateAtMaxPosForOneDOF	(	const unsigned int &	DOF,
		double *	PositionVector,
		double *	VelocityVector,
		double *	AccelerationVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the motion state, at which the position of the degree of freedom with the index DOF has reached its maximum, to the three referred arrays of double values.

Parameters:

DOF	The index of the degree of freedom, whose maximum position is regarded. The motion state of the time instant, at which the maximum position value of this degree of freedom is reached, will be copied to `PositionVector`, `VelocityVector`, and `AccelerationVector`.
PositionVector	A pointer to an array of `double` values, to which the position vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.
VelocityVector	A pointer to an array of `double` values, to which the velocity vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.
AccelerationVector	A pointer to an array of `double` values, to which the acceleration vector at the instant, at which the maximum position for the degree of freedom `DOF` is reached, will be copied.
SizeInBytes	The size of available memory at the each of the locations pointed to by `PositionVector`, `VelocityVector`, and `AccelerationVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

Returns:

RMLOutputParameters::RETURN_ERROR, if the value of DOF is greater than or equal to the number of degrees of freedom
RMLOutputParameters::RETURN_SUCCESS, else

See also:: GetMotionStateAtMaxPosForOneDOF(const unsigned int &DOF, RMLDoubleVector *PositionVector, RMLDoubleVector *VelocityVector, RMLDoubleVector *AccelerationVector) const; GetMotionStateAtMinPosForOneDOF(const unsigned int &DOF, double *PositionVector, double *VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const; GetTimesAtMaxPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; RMLDoubleVector

int RMLOutputParameters::GetMotionStateAtMinPosForOneDOF	(	const unsigned int &	DOF,
		RMLDoubleVector *	PositionVector,
		RMLDoubleVector *	VelocityVector,
		RMLDoubleVector *	AccelerationVector
	)		const `[inline]`

Copies the motion state, at which the position of the degree of freedom with the index DOF has reached its minimum, to the three referred RMLDoubleVector objects.

Parameters:

DOF	The index of the degree of freedom, whose minimum position is regarded. The motion state of the time instant, at which the minimum position value of this degree of freedom is reached, will be copied to `PositionVector`, `VelocityVector`, and `AccelerationVector`.
PositionVector	A pointer to an `RMLDoubleVector` object, to which the position vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.
VelocityVector	A pointer to an `RMLDoubleVector` object, to which the velocity vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.
AccelerationVector	A pointer to an `RMLDoubleVector` object, to which the acceleration vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.

Returns:

RMLOutputParameters::RETURN_ERROR, if the value of DOF is greater than or equal to the number of degrees of freedom
RMLOutputParameters::RETURN_SUCCESS, else

See also:: GetMotionStateAtMaxPosForOneDOF(const unsigned int &DOF, RMLDoubleVector *PositionVector, RMLDoubleVector *VelocityVector, RMLDoubleVector *AccelerationVector) const; GetMotionStateAtMinPosForOneDOF(const unsigned int &DOF, double *PositionVector, double *VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const; GetTimesAtMinPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; RMLDoubleVector

int RMLOutputParameters::GetMotionStateAtMinPosForOneDOF	(	const unsigned int &	DOF,
		double *	PositionVector,
		double *	VelocityVector,
		double *	AccelerationVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the motion state, at which the position of the degree of freedom with the index DOF has reached its minimum, to the three referred arrays of double values.

Parameters:

DOF	The index of the degree of freedom, whose minimum position is regarded. The motion state of the time instant, at which the minimum position value of this degree of freedom is reached, will be copied to `PositionVector`, `VelocityVector`, and `AccelerationVector`.
PositionVector	A pointer to an array of `double` values, to which the position vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.
VelocityVector	A pointer to an array of `double` values, to which the velocity vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.
AccelerationVector	A pointer to an array of `double` values, to which the acceleration vector at the instant, at which the minimum position for the degree of freedom `DOF` is reached, will be copied.
SizeInBytes	The size of available memory at the each of the locations pointed to by `PositionVector`, `VelocityVector`, and `AccelerationVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

Returns:

RMLOutputParameters::RETURN_ERROR, if the value of DOF is greater than or equal to the number of degrees of freedom
RMLOutputParameters::RETURN_SUCCESS, else

See also:: GetMotionStateAtMinPosForOneDOF(const unsigned int &DOF, RMLDoubleVector *PositionVector, RMLDoubleVector *VelocityVector, RMLDoubleVector *AccelerationVector) const; GetMotionStateAtMaxPosForOneDOF(const unsigned int &DOF, double *PositionVector, double *VelocityVector, double *AccelerationVector, const unsigned int &SizeInBytes) const; GetTimesAtMinPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; RMLDoubleVector

void RMLOutputParameters::GetNewAccelerationVector ( RMLDoubleVector * OutputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the new acceleration vector $\vec{A}_{i+1}$ to the RMLDoubleVector object referred to by OutputVector.

Parameters:

OutputVector A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetNewAccelerationVector(double *OutputVector, const unsigned int &SizeInBytes) const; GetNewAccelerationVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewAccelerationVector	(	double *	OutputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the new acceleration vector $\vec{A}_{i+1}$ to the memory pointed to by OutputVector.

Parameters:

OutputVector	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `OutputVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetNewAccelerationVector(RMLDoubleVector *OutputVector) const; GetNewAccelerationVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewAccelerationVectorElement	(	double *	OutputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the new selection vector $\vec{A}_{i+1}$ to the memory pointed to by OutputValue.

Parameters:

OutputValue	A pointer to one `double` value, to which the desired vector element will be copied
Index	Specifies the desired element of the vector. The element numbering starts with 0 (zero). If this value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by `OutputValue`.

See also:: GetNewAccelerationVector(RMLDoubleVector *OutputVector) const; GetNewAccelerationVectorElement(double *OutputValue, const unsigned int &Index) const; GetNewAccelerationVectorElement(const unsigned int &Index) const

double RMLOutputParameters::GetNewAccelerationVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the new selection vector $\vec{A}_{i+1}$ .

Parameters:

Index Specifies the desired element of the vector. The index of the first vector element is 0 (zero). If the value of Index value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by OutputValue.

See also:: GetNewAccelerationVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewPositionVector ( RMLDoubleVector * OutputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the new position vector $\vec{P}_{i+1}$ to the RMLDoubleVector object referred to by OutputVector.

Parameters:

OutputVector A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetNewPositionVector(double *OutputVector, const unsigned int &SizeInBytes) const; GetNewPositionVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewPositionVector	(	double *	OutputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the new position vector $\vec{P}_{i+1}$ to the memory pointed to by OutputVector.

Parameters:

OutputVector	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `OutputVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetNewPositionVector(RMLDoubleVector *OutputVector) const; GetNewPositionVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewPositionVectorElement	(	double *	OutputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the new selection vector $\vec{P}_{i+1}$ to the memory pointed to by OutputValue.

Parameters:

OutputValue	A pointer to one `double` value, to which the desired vector element will be copied
Index	Specifies the desired element of the vector. The element numbering starts with 0 (zero). If this value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by `OutputValue`.

See also:: GetNewPositionVector(RMLDoubleVector *OutputVector) const; GetNewPositionVectorElement(double *OutputValue, const unsigned int &Index) const; GetNewPositionVectorElement(const unsigned int &Index) const

double RMLOutputParameters::GetNewPositionVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the new selection vector $\vec{P}_{i+1}$ .

Parameters:

Index Specifies the desired element of the vector. The index of the first vector element is 0 (zero). If the value of Index value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by OutputValue.

See also:: GetNewPositionVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewVelocityVector ( RMLDoubleVector * OutputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the new velocity vector $\vec{V}_{i+1}$ to the RMLDoubleVector object referred to by OutputVector.

Parameters:

OutputVector A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetNewVelocityVector(double *OutputVector, const unsigned int &SizeInBytes) const; GetNewVelocityVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewVelocityVector	(	double *	OutputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the new velocity vector $\vec{V}_{i+1}$ to the memory pointed to by OutputVector.

Parameters:

OutputVector	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `OutputVector`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetNewVelocityVector(RMLDoubleVector *OutputVector) const; GetNewVelocityVectorElement(double *OutputValue, const unsigned int &Index) const

void RMLOutputParameters::GetNewVelocityVectorElement	(	double *	OutputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the new selection vector $\vec{V}_{i+1}$ to the memory pointed to by OutputValue.

Parameters:

OutputValue	A pointer to one `double` value, to which the desired vector element will be copied
Index	Specifies the desired element of the vector. The element numbering starts with 0 (zero). If this value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by `OutputValue`.

See also:: GetNewVelocityVector(RMLDoubleVector *OutputVector) const; GetNewVelocityVectorElement(double *OutputValue, const unsigned int &Index) const; GetNewVelocityVectorElement(const unsigned int &Index) const

double RMLOutputParameters::GetNewVelocityVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the new selection vector $\vec{V}_{i+1}$ .

Parameters:

Index Specifies the desired element of the vector. The index of the first vector element is 0 (zero). If the value of Index value is greater the number of vector elements, a value of 0.0 will be written to the memory pointed to by OutputValue.

See also:: GetNewVelocityVectorElement(double *OutputValue, const unsigned int &Index) const

unsigned int RMLOutputParameters::GetNumberOfDOFs ( void ) const [inline]

Returns the number of degrees of freedom.

Returns:: The number of degrees of freedom.

void RMLOutputParameters::GetPositionalExtrema	(	RMLDoubleVector *	MinimumPositionVector,
		RMLDoubleVector *	MaximumPositionVector
	)		const `[inline]`

Copies two RMLDoubleVector objects that contain the minimum and maximum positions, which are reached until the target state of motion is reached.

Parameters:

MinimumPositionVector	A pointer to an `RMLDoubleVector` object, to which the vector of minimum positions will be copied to.
MaximumPositionVector	A pointer to an `RMLDoubleVector` object, to which the vector of maximum positions will be copied to.

See also:: GetPositionalExtrema(double *MinimumPositionVector, double *MaximumPositionVector, const unsigned int &SizeInBytes) const; RMLVector; RMLDoubleVector

void RMLOutputParameters::GetPositionalExtrema	(	double *	MinimumPositionVector,
		double *	MaximumPositionVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies two RMLDoubleVector objects that contain the minimum and maximum positions, which are reached until the target state of motion is reached.

Parameters:

MinimumPositionVector	A pointer to a `double` array, to which the elements of the vector of minimum positions will be copied to.
MaximumPositionVector	A pointer to a `double` array, to which the elements of the vector of maximum positions will be copied to.
SizeInBytes	The size of available memory at the location pointed to by `MinimumPositionVector` or MaximumPositionVector, respectively. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const

double RMLOutputParameters::GetSynchronizationTime ( void ) const [inline]

Returns the synchronization time.

The position-based On-Line Trajectory Generation algorithm transfers all selected degrees of freedom into their desired target state of motion, such that all of them reach the target state of motion $_{k}\vec{M}_{i}^{\,trgt}$ at the very same time instant, that is, at the minimum possible synchronization time $t_{i}^{,sync}$ . If this value is used as an output value of the velocity-based On-Line Trajectory Generation algorithm, this time determines when all selected degree of freedom will reach the desired target velocity.

Returns:: The value of the synchronization time in seconds

See also:: RMLOutputParameters::SynchronizationTime

void RMLOutputParameters::GetTimesAtMaxPosition ( RMLDoubleVector * ExtremaTimes ) const [inline]

Copies the contents of a RMLDoubleVector object that contains the times (in seconds) at which the maximum positions are reached to the RMLDoubleVector object referred to by ExtremaTimes.

Parameters:

ExtremaTimes A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetTimesAtMinPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; GetPositionalExtrema(double *MinimumPositionVector, double *MaximumPositionVector, const unsigned int &SizeInBytes) const; RMLDoubleVector

void RMLOutputParameters::GetTimesAtMaxPosition	(	double *	ExtremaTimes,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values that contain the time values (in seconds) at which the maximum positions are reached to the array of double values referred to by ExtremaTimes.

Parameters:

ExtremaTimes	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `ExtremaTimes`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetTimesAtMaxPosition(RMLDoubleVector *ExtremaTimes) const; GetTimesAtMinPosition(double*ExtremaTimes, const unsigned int &SizeInBytes) const

void RMLOutputParameters::GetTimesAtMinPosition ( RMLDoubleVector * ExtremaTimes ) const [inline]

Copies the contents of a RMLDoubleVector object that contains the times (in seconds) at which the minimum positions are reached to the RMLDoubleVector object referred to by ExtremaTimes.

Parameters:

ExtremaTimes A pointer to an RMLDoubleVector object, to which the data will be copied

See also:: GetTimesAtMaxPosition(RMLDoubleVector *ExtremaTimes) const; GetPositionalExtrema(RMLDoubleVector *MinimumPositionVector, RMLDoubleVector *MaximumPositionVector) const; GetPositionalExtrema(double *MinimumPositionVector, double *MaximumPositionVector, const unsigned int &SizeInBytes) const; RMLDoubleVector

void RMLOutputParameters::GetTimesAtMinPosition	(	double *	ExtremaTimes,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values that contain the time values (in seconds) at which the minimum positions are reached to the array of double values referred to by ExtremaTimes.

Parameters:

ExtremaTimes	A pointer to an array of `double` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `ExtremaTimes`. To assure safety and to prevent from prohibited writing into protected memory areas, the user has to specify the amount of available memory in bytes. For a correct operation, the value of `SizeInBytes` has to equal the number of vector elements multiplied by the size of a `double` value.

See also:: GetTimesAtMinPosition(RMLDoubleVector *ExtremaTimes) const; GetTimesAtMaxPosition(double*ExtremaTimes, const unsigned int &SizeInBytes) const

bool RMLOutputParameters::IsTrajectoryPhaseSynchronized ( void ) const [inline]

Indicates whether the currently calculated trajectory is phase- synchronized or only time-synchronized.

Returns:: The method returns true if the trajectory is phase-synchronized and false if it is time-synchronized.

RMLOutputParameters & RMLOutputParameters::operator= ( const RMLOutputParameters & OP ) [inline]

Copy operator.

Parameters:

OP	RMLOutputParameters object to be copied

bool RMLOutputParameters::WasACompleteComputationPerformedDuringTheLastCycle ( void ) const [inline]

Indicates, whether a new computation was performed in the last cycle.

If the computation of completely new trajectory parameters was performed, this flag will be set to true. If the input values remained constant and the output parameters of the last computation cycle were directly fed back to the input parameters, such that the previously computed trajectory did not change, the flag will be set to false.

This attribute can be accessed directly or by using one of the following methods:

WasACompleteComputationPerformedDuringTheLastCycle(void) const

Returns:

true if a new computation was performed
false if the previously calculated trajectory parameters did not change and were used.

Member Data Documentation

bool RMLOutputParameters::ANewCalculationWasPerformed

Indicates, whether a new computation was performed in the last cycle.

If the computation of completely new trajectory parameters was performed, this flag will be set to true. If the input values remained constant and the output parameters of the last computation cycle were directly fed back to the input parameters, such that the previously computed trajectory did not change, the flag will be set to false.

This attribute can be accessed directly or by using one of the following methods:

WasACompleteComputationPerformedDuringTheLastCycle(void) const

unsigned int RMLOutputParameters::DOFWithTheGreatestExecutionTime

Index of the degree of freedom that requires the greatest execution time to reach its desired target velocity value.

In case of non-synchronized trajectories, this integer value specifies the index of the degree-of-freedom with the greatest execution time.
In case of time-synchronized trajectories, this integer value specifies the degree of freedom that determined the synchronization time.
In case of time-synchronized trajectories, this integer value contains the lowest index index number of all selected degrees of freedom.
If more that one degree of freedom feature the (same) execution time, the lowest index will be used.

This attribute can be accessed directly or by using one of the following methods:

GetDOFWithTheGreatestExecutionTime(void) const

RMLDoubleVector * RMLOutputParameters::ExecutionTimes

A pointer to an RMLDoubleVector object that contains the execution times of all selected degrees of freedom in the case non-synchronized trajectories.

In case of non-synchronized trajectories, this vector contains the execution times of all selected degrees of freedom.
In the case of time- and phase-synchronized trajectories, this vector contains the synchronization time for all selected degree of freedom.
The values non-selected degrees of freedom is zero.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MaxExtremaTimesVector

A pointer to an RMLDoubleVector object that contains the times at which each degree of freedom reaches its maximum position during the execution of the calculated trajectory.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MaxPosExtremaAccelerationVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the acceleration vector, that will be achieved when the respective degree of freedom reaches its maximum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MaxPosExtremaPositionVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its maximum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MaxPosExtremaPositionVectorOnly

A pointer to an RMLDoubleVector object that contains the maximum positions for all degrees of freedom that occur during the execution of the calculated trajectory.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MaxPosExtremaVelocityVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the velocity vector, that will be achieved when the respective degree of freedom reaches its maximum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MinExtremaTimesVector

A pointer to an RMLDoubleVector object that contains the times at which each degree of freedom reaches its minimum position during the execution of the calculated trajectory.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector ** RMLOutputParameters::MinPosExtremaAccelerationVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its minimum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MinPosExtremaPositionVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the position vector, that will be achieved when the respective degree of freedom reaches its minimum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MinPosExtremaPositionVectorOnly

A pointer to an RMLDoubleVector object that contains the maximum positions for all degrees of freedom that occur during the execution of the calculated trajectory.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::MinPosExtremaVelocityVectorArray

A pointer to an array of pointers to RMLDoubleVector objects. The number of array elements equals the number of degrees of freedom, and each of these RMLDOubleVector objects consists of the same number of entries, such that it is a square matrix. A single vector contains the velocity vector, that will be achieved when the respective degree of freedom reaches its minimum position.

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::NewAccelerationVector

A pointer to the new acceleration vector $\vec{A}_{i+1}$ .

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::NewPositionVector

A pointer to the new position vector $\vec{P}_{i+1}$ .

This attribute can be accessed directly or by using one of the following methods:

RMLDoubleVector * RMLOutputParameters::NewVelocityVector

A pointer to the new velocity vector $\vec{V}_{i+1}$ .

This attribute can be accessed directly or by using one of the following methods:

unsigned int RMLOutputParameters::NumberOfDOFs

The number of degrees of freedom $ K $ .

This attribute can be accessed directly or by using one of the following methods:

double RMLOutputParameters::SynchronizationTime

The synchronization time $t_{i}^{\,sync}$ in seconds.

If the trajectory is time- or phase-synchronized, this attribute will contain the synchronization time. Otherwise, it is set to zero.

This attribute can be accessed directly or by using one of the following methods:

GetSynchronizationTime(void) const

bool RMLOutputParameters::TrajectoryIsPhaseSynchronized

Boolean flag that indicates whether the current trajectory is phase-synchronized.

This attribute can be accessed directly or by using one of the following methods:

IsTrajectoryPhaseSynchronized(void) const

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

include/RMLOutputParameters.h

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation