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

#include <RMLInputParameters.h>

Inheritance diagram for RMLInputParameters:

Public Member Functions
	RMLInputParameters (const RMLInputParameters &IP)
	Copy constructor of class RMLInputParameters.
	~RMLInputParameters (void)
	Destructor of class RMLInputParameters.
RMLInputParameters &	operator= (const RMLInputParameters &IP)
	Copy operator.
void	SetSelectionVector (const RMLBoolVector &InputVector)
	Sets the current selection vector $\vec{S}_{i}$ by using the an RMLBoolVector object.
void	SetSelectionVector (const bool *InputVector)
	Sets the current selection vector $\vec{S}_{i}$ by using a native C++ `bool` array.
void	SetSelectionVectorElement (const bool &InputValue, const unsigned int &Index)
	Sets one element of the current selection vector $\vec{S}_{i}$ .
void	GetSelectionVector (RMLBoolVector *InputVector) const
	Copies the contents of the `RMLBoolVector` object containing the current position vector $\vec{S}_{i}$ to the `RMLBoolVector` object referred to by `InputVector`.
void	GetSelectionVector (bool *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `bool` values representing the current position vector $\vec{S}_{i}$ to the memory pointed to by `InputVector`.
void	GetSelectionVectorElement (bool *InputValue, const unsigned int &Index) const
	Copies one element of the current selection vector $\vec{S}_{i}$ to the memory pointed to by `InputValue`.
bool	GetSelectionVectorElement (const unsigned int &Index) const
	Returns one single element of the current selection vector $\vec{S}_{i}$ .
void	SetCurrentPositionVector (const RMLDoubleVector &InputVector)
	Sets the current selection vector $\vec{P}_{i}$ by using the an `RMLDoubleVector` object.
void	SetCurrentPositionVector (const double *InputVector)
	Sets the current selection vector $\vec{P}_{i}$ by using a native C `double` array.
void	SetCurrentPositionVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the current selection vector $\vec{P}_{i}$ .
void	GetCurrentPositionVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the current position vector $\vec{P}_{i}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetCurrentPositionVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the current position vector $\vec{P}_{i}$ to the memory pointed to by `InputVector`.
void	GetCurrentPositionVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the current selection vector $\vec{P}_{i}$ to the memory pointed to by `InputValue`.
double	GetCurrentPositionVectorElement (const unsigned int &Index) const
	Returns one single element of the current selection vector $\vec{P}_{i}$ .
void	SetCurrentVelocityVector (const RMLDoubleVector &InputVector)
	Sets the current velocity vector $\vec{V}_{i}$ by using the an `RMLDoubleVector` object.
void	SetCurrentVelocityVector (const double *InputVector)
	Sets the current velocity vector $\vec{V}_{i}$ by using a native C `double` array.
void	SetCurrentVelocityVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the current velocity vector $\vec{V}_{i}$ .
void	GetCurrentVelocityVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the current velocity vector $\vec{V}_{i}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetCurrentVelocityVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the current velocity vector $\vec{V}_{i}$ to the memory pointed to by `InputVector`.
void	GetCurrentVelocityVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the current velocity vector $\vec{V}_{i}$ to the memory pointed to by `InputValue`.
double	GetCurrentVelocityVectorElement (const unsigned int &Index) const
	Returns one single element of the current velocity vector $\vec{V}_{i}$ .
void	SetCurrentAccelerationVector (const RMLDoubleVector &InputVector)
	Sets the current acceleration vector $\vec{A}_{i}$ by using the an `RMLDoubleVector` object.
void	SetCurrentAccelerationVector (const double *InputVector)
	Sets the current acceleration vector $\vec{A}_{i}$ by using a native C `double` array.
void	SetCurrentAccelerationVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the current acceleration vector $\vec{A}_{i}$ .
void	GetCurrentAccelerationVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the current acceleration vector $\vec{A}_{i}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetCurrentAccelerationVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the current acceleration vector $\vec{A}_{i}$ to the memory pointed to by `InputVector`.
void	GetCurrentAccelerationVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the current acceleration vector $\vec{A}_{i}$ to the memory pointed to by `InputValue`.
double	GetCurrentAccelerationVectorElement (const unsigned int &Index) const
	Returns one single element of the current acceleration vector $\vec{A}_{i}$ .
void	SetMaxAccelerationVector (const RMLDoubleVector &InputVector)
	Sets the maximum acceleration vector $\vec{A}_{i}^{\,max}$ by using the an `RMLDoubleVector` object.
void	SetMaxAccelerationVector (const double *InputVector)
	Sets the maximum acceleration vector $\vec{A}_{i}^{\,max}$ by using a native C `double` array.
void	SetMaxAccelerationVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .
void	GetMaxAccelerationVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetMaxAccelerationVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the memory pointed to by `InputVector`.
void	GetMaxAccelerationVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the memory pointed to by `InputValue`.
double	GetMaxAccelerationVectorElement (const unsigned int &Index) const
	Returns one single element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .
void	SetMaxJerkVector (const RMLDoubleVector &InputVector)
	Sets the maximum jerk vector $\vec{J}_{i}^{\,max}$ by using the an `RMLDoubleVector` object.
void	SetMaxJerkVector (const double *InputVector)
	Sets the maximum jerk vector $\vec{J}_{i}^{\,max}$ by using a native C `double` array.
void	SetMaxJerkVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ .
void	GetMaxJerkVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetMaxJerkVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the memory pointed to by `InputVector`.
void	GetMaxJerkVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the memory pointed to by `InputValue`.
double	GetMaxJerkVectorElement (const unsigned int &Index) const
	Returns one single element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ .
void	SetTargetVelocityVector (const RMLDoubleVector &InputVector)
	Sets the target velocity vector $\vec{V}_{i}^{\,trgt}$ by using the an `RMLDoubleVector` object.
void	SetTargetVelocityVector (const double *InputVector)
	Sets the target velocity vector $\vec{V}_{i}^{\,trgt}$ by using a native C `double` array.
void	SetTargetVelocityVectorElement (const double &InputValue, const unsigned int &Index)
	Sets one element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ .
void	GetTargetVelocityVector (RMLDoubleVector *InputVector) const
	Copies the contents of the `RMLDoubleVector` object containing the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the `RMLDoubleVector` object referred to by `InputVector`.
void	GetTargetVelocityVector (double *InputVector, const unsigned int &SizeInBytes) const
	Copies the array of `double` values representing the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the memory pointed to by `InputVector`.
void	GetTargetVelocityVectorElement (double *InputValue, const unsigned int &Index) const
	Copies one element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the memory pointed to by `InputValue`.
double	GetTargetVelocityVectorElement (const unsigned int &Index) const
	Returns one single element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ .
unsigned int	GetNumberOfDOFs (void) const
	Returns the number of degrees of freedom.
double	GetMinimumSynchronizationTime (void) const
	Returns the optional parameter for the desired execution time.
void	SetMinimumSynchronizationTime (double Time)
	Sets the optional parameter for the desired execution time.
Public Attributes
unsigned int	NumberOfDOFs
	The number of degrees of freedom .
double	MinimumSynchronizationTime
	Minimum trajectory execution time in seconds specified by the user (optional input parameter)
RMLBoolVector *	SelectionVector
	A pointer to the selection vector $\vec{S}_{i}$ .
RMLDoubleVector *	CurrentPositionVector
	A pointer to the current position vector $\vec{P}_{i}$ .
RMLDoubleVector *	CurrentVelocityVector
	A pointer to the current velocity vector $\vec{V}_{i}$ .
RMLDoubleVector *	CurrentAccelerationVector
	A pointer to the current acceleration vector $\vec{A}_{i}$ .
RMLDoubleVector *	MaxAccelerationVector
	A pointer to the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .
RMLDoubleVector *	MaxJerkVector
	A pointer to the maximum jerk vector $\vec{J}_{i}^{\,max}$ .
RMLDoubleVector *	TargetVelocityVector
	A pointer to the target velocity vector $\vec{V}_{i}^{\,trgt}$ .
Protected Member Functions
	RMLInputParameters (const unsigned int DegreesOfFreedom)
	Constructor of class RMLInputParameters.
void	Echo (FILE *FileHandler=stdout) const
	Prints the complete set of input parameters to *FileHandler.

Detailed Description

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

The class RMLInputParameters constitutes the basis class for the actual interface classes RMLPositionInputParameters and RMLVelocityInputParameters, which are both derived from this one. For detailed descrpition of the input parameters, please refer to Description of Input Values.

See also:: ReflexxesAPI; RMLPositionInputParameters; RMLVelocityInputParameters; RMLOutputParameters; Description of Input Values

Constructor & Destructor Documentation

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

Constructor of class RMLInputParameters.

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.

RMLInputParameters::RMLInputParameters ( const RMLInputParameters & IP ) [inline]

Copy constructor of class RMLInputParameters.

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

Parameters:

IP	Object to be copied

RMLInputParameters::~RMLInputParameters ( void ) [inline]

Destructor of class RMLInputParameters.

Member Function Documentation

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

Prints the complete set of input parameters to *FileHandler.

Parameters:

FileHandler File handler for the output

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

Reimplemented in RMLPositionInputParameters, and RMLVelocityInputParameters.

void RMLInputParameters::GetCurrentAccelerationVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the current acceleration vector $\vec{A}_{i}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetCurrentAccelerationVector(const RMLDoubleVector &InputVector); GetCurrentAccelerationVector(double *InputVector, const unsigned int &SizeInBytes) const; GetCurrentAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentAccelerationVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the current acceleration vector $\vec{A}_{i}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetCurrentAccelerationVector(const double *InputVector); GetCurrentAccelerationVector(RMLDoubleVector *InputVector) const; GetCurrentAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentAccelerationVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the current acceleration vector $\vec{A}_{i}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetCurrentAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentAccelerationVector(RMLDoubleVector *InputVector) const; GetCurrentAccelerationVectorElement(double *InputValue, const unsigned int &Index) const; GetCurrentAccelerationVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetCurrentAccelerationVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the current acceleration vector $\vec{A}_{i}$ .

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 InputValue.

See also:: SetCurrentAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentPositionVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the current position vector $\vec{P}_{i}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetCurrentPositionVector(const RMLDoubleVector &InputVector); GetCurrentPositionVector(double *InputVector, const unsigned int &SizeInBytes) const; GetCurrentPositionVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentPositionVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the current position vector $\vec{P}_{i}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetCurrentPositionVector(const double *InputVector); GetCurrentPositionVector(RMLDoubleVector *InputVector) const; GetCurrentPositionVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentPositionVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the current selection vector $\vec{P}_{i}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetCurrentPositionVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentPositionVector(RMLDoubleVector *InputVector) const; GetCurrentPositionVectorElement(double *InputValue, const unsigned int &Index) const; GetCurrentPositionVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetCurrentPositionVectorElement ( const unsigned int & Index ) const [inline]

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

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 InputValue.

See also:: SetCurrentPositionVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentPositionVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentVelocityVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the current velocity vector $\vec{V}_{i}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetCurrentVelocityVector(const RMLDoubleVector &InputVector); GetCurrentVelocityVector(double *InputVector, const unsigned int &SizeInBytes) const; GetCurrentVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentVelocityVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the current velocity vector $\vec{V}_{i}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetCurrentVelocityVector(const double *InputVector); GetCurrentVelocityVector(RMLDoubleVector *InputVector) const; GetCurrentVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetCurrentVelocityVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the current velocity vector $\vec{V}_{i}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetCurrentVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentVelocityVector(RMLDoubleVector *InputVector) const; GetCurrentVelocityVectorElement(double *InputValue, const unsigned int &Index) const; GetCurrentVelocityVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetCurrentVelocityVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the current velocity vector $\vec{V}_{i}$ .

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 InputValue.

See also:: SetCurrentVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxAccelerationVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetMaxAccelerationVector(const RMLDoubleVector &InputVector); GetMaxAccelerationVector(double *InputVector, const unsigned int &SizeInBytes) const; GetMaxAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxAccelerationVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetMaxAccelerationVector(const double *InputVector); GetMaxAccelerationVector(RMLDoubleVector *InputVector) const; GetMaxAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxAccelerationVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetMaxAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetMaxAccelerationVector(RMLDoubleVector *InputVector) const; GetMaxAccelerationVectorElement(double *InputValue, const unsigned int &Index) const; GetMaxAccelerationVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetMaxAccelerationVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .

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 InputValue.

See also:: SetMaxAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetMaxAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxJerkVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetMaxJerkVector(const RMLDoubleVector &InputVector); GetMaxJerkVector(double *InputVector, const unsigned int &SizeInBytes) const; GetMaxJerkVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxJerkVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetMaxJerkVector(const double *InputVector); GetMaxJerkVector(RMLDoubleVector *InputVector) const; GetMaxJerkVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetMaxJerkVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetMaxJerkVectorElement(const double &InputValue, const unsigned int &Index); GetMaxJerkVector(RMLDoubleVector *InputVector) const; GetMaxJerkVectorElement(double *InputValue, const unsigned int &Index) const; GetMaxJerkVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetMaxJerkVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ .

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 InputValue.

See also:: SetMaxJerkVectorElement(const double &InputValue, const unsigned int &Index); GetMaxJerkVectorElement(double *InputValue, const unsigned int &Index) const

double RMLInputParameters::GetMinimumSynchronizationTime ( void ) const [inline]

Returns the optional parameter for the desired execution time.

Returns:: Desired execution time in seconds.

See also:: MinimumSynchronizationTime

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

Returns the number of degrees of freedom.

Returns:: The number of degrees of freedom.

void RMLInputParameters::GetSelectionVector ( RMLBoolVector * InputVector ) const [inline]

Copies the contents of the RMLBoolVector object containing the current position vector $\vec{S}_{i}$ to the RMLBoolVector object referred to by InputVector.

Parameters:

InputVector A pointer to an RMLBoolVector object, to which the data will be copied

See also:: SetSelectionVector(const RMLBoolVector &InputVector); GetSelectionVector(bool *InputVector, const unsigned int &SizeInBytes) const; GetSelectionVectorElement(bool *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetSelectionVector	(	bool *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of bool values representing the current position vector $\vec{S}_{i}$ to the memory pointed to by InputVector.

Parameters:

InputVector	A pointer to an array of `bool` values, to which the data will be copied
SizeInBytes	The size of available memory at the location pointed to by `InputVector`. 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 `bool` value.

See also:: SetSelectionVector(const bool *InputVector); GetSelectionVector(RMLBoolVector *InputVector) const; GetSelectionVectorElement(bool *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetSelectionVectorElement	(	bool *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the current selection vector $\vec{S}_{i}$ to the memory pointed to by InputValue.

Parameters:

InputValue	A pointer to one `bool` 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 `InputValue`.

See also:: SetSelectionVectorElement(const bool &InputValue, const unsigned int &Index); GetSelectionVector(RMLBoolVector *InputVector) const; GetSelectionVectorElement(bool *InputValue, const unsigned int &Index) const; GetSelectionVectorElement(const unsigned int &Index) const

bool RMLInputParameters::GetSelectionVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the current selection vector $\vec{S}_{i}$ .

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 InputValue.

See also:: SetSelectionVectorElement(const bool &InputValue, const unsigned int &Index); GetSelectionVectorElement(bool *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetTargetVelocityVector ( RMLDoubleVector * InputVector ) const [inline]

Copies the contents of the RMLDoubleVector object containing the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the RMLDoubleVector object referred to by InputVector.

Parameters:

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

See also:: SetTargetVelocityVector(const RMLDoubleVector &InputVector); GetTargetVelocityVector(double *InputVector, const unsigned int &SizeInBytes) const; GetTargetVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetTargetVelocityVector	(	double *	InputVector,
		const unsigned int &	SizeInBytes
	)		const `[inline]`

Copies the array of double values representing the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the memory pointed to by InputVector.

Parameters:

InputVector	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 `InputVector`. 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:: SetTargetVelocityVector(const double *InputVector); GetTargetVelocityVector(RMLDoubleVector *InputVector) const; GetTargetVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::GetTargetVelocityVectorElement	(	double *	InputValue,
		const unsigned int &	Index
	)		const `[inline]`

Copies one element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ to the memory pointed to by InputValue.

Parameters:

InputValue	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 `InputValue`.

See also:: SetTargetVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetTargetVelocityVector(RMLDoubleVector *InputVector) const; GetTargetVelocityVectorElement(double *InputValue, const unsigned int &Index) const; GetTargetVelocityVectorElement(const unsigned int &Index) const

double RMLInputParameters::GetTargetVelocityVectorElement ( const unsigned int & Index ) const [inline]

Returns one single element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ .

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 InputValue.

See also:: SetTargetVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetTargetVelocityVectorElement(double *InputValue, const unsigned int &Index) const

RMLInputParameters & RMLInputParameters::operator= ( const RMLInputParameters & IP ) [inline]

Copy operator.

Parameters:

IP	RMLInputParameters object to be copied

void RMLInputParameters::SetCurrentAccelerationVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the current acceleration vector $\vec{A}_{i}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetCurrentAccelerationVector(const double *InputVector); SetCurrentAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentAccelerationVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetCurrentAccelerationVector ( const double * InputVector ) [inline]

Sets the current acceleration vector $\vec{A}_{i}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetCurrentAccelerationVector(const RMLDoubleVector &InputVector); SetCurrentAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentAccelerationVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetCurrentAccelerationVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the current acceleration vector $\vec{A}_{i}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the current acceleration input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetCurrentAccelerationVector(const RMLDoubleVector &InputVector); SetCurrentAccelerationVector(const double *InputVector); GetCurrentAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetCurrentPositionVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the current selection vector $\vec{P}_{i}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetCurrentPositionVector(const double *InputVector); SetCurrentPositionVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentPositionVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetCurrentPositionVector ( const double * InputVector ) [inline]

Sets the current selection vector $\vec{P}_{i}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetCurrentPositionVector(const RMLDoubleVector &InputVector); SetCurrentPositionVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentPositionVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetCurrentPositionVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the current selection vector $\vec{P}_{i}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the current position input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetCurrentPositionVector(const RMLDoubleVector &InputVector); SetCurrentPositionVector(const double *InputVector); GetCurrentPositionVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetCurrentVelocityVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the current velocity vector $\vec{V}_{i}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetCurrentVelocityVector(const double *InputVector); SetCurrentVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentVelocityVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetCurrentVelocityVector ( const double * InputVector ) [inline]

Sets the current velocity vector $\vec{V}_{i}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetCurrentVelocityVector(const RMLDoubleVector &InputVector); SetCurrentVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetCurrentVelocityVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetCurrentVelocityVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the current velocity vector $\vec{V}_{i}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the current velocity input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetCurrentVelocityVector(const RMLDoubleVector &InputVector); SetCurrentVelocityVector(const double *InputVector); GetCurrentVelocityVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetMaxAccelerationVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the maximum acceleration vector $\vec{A}_{i}^{\,max}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetMaxAccelerationVector(const double *InputVector); SetMaxAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetMaxAccelerationVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetMaxAccelerationVector ( const double * InputVector ) [inline]

Sets the maximum acceleration vector $\vec{A}_{i}^{\,max}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetMaxAccelerationVector(const RMLDoubleVector &InputVector); SetMaxAccelerationVectorElement(const double &InputValue, const unsigned int &Index); GetMaxAccelerationVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetMaxAccelerationVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the maximum acceleration input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetMaxAccelerationVector(const RMLDoubleVector &InputVector); SetMaxAccelerationVector(const double *InputVector); GetMaxAccelerationVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetMaxJerkVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the maximum jerk vector $\vec{J}_{i}^{\,max}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetMaxJerkVector(const double *InputVector); SetMaxJerkVectorElement(const double &InputValue, const unsigned int &Index); GetMaxJerkVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetMaxJerkVector ( const double * InputVector ) [inline]

Sets the maximum jerk vector $\vec{J}_{i}^{\,max}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetMaxJerkVector(const RMLDoubleVector &InputVector); SetMaxJerkVectorElement(const double &InputValue, const unsigned int &Index); GetMaxJerkVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetMaxJerkVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the maximum jerk vector $\vec{J}_{i}^{\,max}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the maximum jerk input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetMaxJerkVector(const RMLDoubleVector &InputVector); SetMaxJerkVector(const double *InputVector); GetMaxJerkVectorElement(double *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetMinimumSynchronizationTime ( double Time ) [inline]

Sets the optional parameter for the desired execution time.

See also:: MinimumSynchronizationTime

void RMLInputParameters::SetSelectionVector ( const RMLBoolVector & InputVector ) [inline]

Sets the current selection vector $\vec{S}_{i}$ by using the an RMLBoolVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetSelectionVector(const bool *InputVector); SetSelectionVectorElement(const bool &InputValue, const unsigned int &Index); GetSelectionVector(RMLBoolVector *InputVector) const

void RMLInputParameters::SetSelectionVector ( const bool * InputVector ) [inline]

Sets the current selection vector $\vec{S}_{i}$ by using a native C++ bool array.

Parameters:

InputVector The input vector to an array of bool values, whose elements are copied to the attributes of this class.

See also:: SetSelectionVector(const RMLBoolVector &InputVector); SetSelectionVectorElement(const bool &InputValue, const unsigned int &Index); GetSelectionVector(bool *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetSelectionVectorElement	(	const bool &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the current selection vector $\vec{S}_{i}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the current position input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetSelectionVector(const RMLBoolVector &InputVector); SetSelectionVector(const bool *InputVector); GetSelectionVectorElement(bool *InputValue, const unsigned int &Index) const

void RMLInputParameters::SetTargetVelocityVector ( const RMLDoubleVector & InputVector ) [inline]

Sets the target velocity vector $\vec{V}_{i}^{\,trgt}$ by using the an RMLDoubleVector object.

Parameters:

InputVector The input vector, whose elements are copied to the attributes of this class.

See also:: SetTargetVelocityVector(const double *InputVector); SetTargetVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetTargetVelocityVector(RMLDoubleVector *InputVector) const

void RMLInputParameters::SetTargetVelocityVector ( const double * InputVector ) [inline]

Sets the target velocity vector $\vec{V}_{i}^{\,trgt}$ by using a native C double array.

Parameters:

InputVector The input vector to an array of double values, whose elements are copied to the attributes of this class.

See also:: SetTargetVelocityVector(const RMLDoubleVector &InputVector); SetTargetVelocityVectorElement(const double &InputValue, const unsigned int &Index); GetTargetVelocityVector(double *InputVector, const unsigned int &SizeInBytes) const

void RMLInputParameters::SetTargetVelocityVectorElement	(	const double &	InputValue,
		const unsigned int &	Index
	)		`[inline]`

Sets one element of the target velocity vector $\vec{V}_{i}^{\,trgt}$ .

Parameters:

InputValue	The input value that is copied to the element `Index` of the target velocity input vector attribute of this class.
Index	The index of the element to be copied

See also:: SetTargetVelocityVector(const RMLDoubleVector &InputVector); SetTargetVelocityVector(const double *InputVector); GetTargetVelocityVectorElement(double *InputValue, const unsigned int &Index) const

Member Data Documentation

RMLDoubleVector * RMLInputParameters::CurrentAccelerationVector

A pointer to the current acceleration vector $\vec{A}_{i}$ .

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

RMLDoubleVector * RMLInputParameters::CurrentPositionVector

A pointer to the current position vector $\vec{P}_{i}$ .

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

RMLDoubleVector * RMLInputParameters::CurrentVelocityVector

A pointer to the current velocity vector $\vec{V}_{i}$ .

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

RMLDoubleVector * RMLInputParameters::MaxAccelerationVector

A pointer to the maximum acceleration vector $\vec{A}_{i}^{\,max}$ .

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

RMLDoubleVector * RMLInputParameters::MaxJerkVector

A pointer to the maximum jerk vector $\vec{J}_{i}^{\,max}$ .

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

double RMLInputParameters::MinimumSynchronizationTime

Minimum trajectory execution time in seconds specified by the user (optional input parameter)

This input parameter is optional and allows users to specify a desired minimum execution time for time- and phase-synchronized trajectories that will be computed by calling ReflexxesAPI::RMLPosition() or ReflexxesAPI::RMLVelocity().

The following four cases may happen if this input parameter is used for the position-based algorithm (TypeIIRMLPosition):

If the flag RMLFlags::NO_SYNCHRONIZATION is used, the value of MinimumSynchronizationTime will be ignored.
If the value of DesiredExecutionTime is less then the minimum possible synchronization time, it will be ignored and the minimum possible synchronization time will be used.
If the value of DesiredExecutionTime is inside of an inoperative time interval of one or more degrees of freedom, the end of the time interval that will provide the time closest to the desired execution time will be used. This time is greater than the value of MinimumSynchronizationTime.
Otherwise, a trajectory will be computed whose execution time is MinimumSynchronizationTime.

The following three cases may happen if this input parameter is used for the velocity-based algorithm (TypeIIRMLVelocity):

If the flag RMLFlags::NO_SYNCHRONIZATION is used, the value of MinimumSynchronizationTime will be ignored.
If the value of DesiredExecutionTime is less then the minimum possible synchronization time, it will be ignored and the minimum possible synchronization time will be used.
Otherwise, a trajectory will be computed whose execution time is MinimumSynchronizationTime.

See also:: RMLFlags::SyncBehaviorEnum; TypeIIRMLPosition::SynchronizationTime; TypeIIRMLVelocity::SynchronizationTime; RMLOutputParameters::SynchronizationTime; Example 7 — Making Use of the Optional Parameter MinimumSynchronizationTime for the Position-based Algorithm; Example 8 — Making Use of the Optional Parameter MinimumSynchronizationTime for the Velocity-based Algorithm

unsigned int RMLInputParameters::NumberOfDOFs

The number of degrees of freedom $ K $ .

See also:: RMLInputParameters::RMLInputParameters()

RMLBoolVector * RMLInputParameters::SelectionVector

A pointer to the selection vector $\vec{S}_{i}$ .

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

RMLDoubleVector * RMLInputParameters::TargetVelocityVector

A pointer to the target velocity vector $\vec{V}_{i}^{\,trgt}$ .

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

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

include/RMLInputParameters.h

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation