Main Page Modules Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

MotionPlanning

The Motion Planning Library. More...


Compounds
class	BezierCurve
	This class can be used to generate Bezier Curves from provided control points. A Bezier Curve will interpolate the starting and end points and will stay within the convex hull of the control points. More...
class	BSpline
	This class can be used to generate B-Spline curves. B-Splines are an advanced curve form that allows for the order to be set by the user instead of being defined by the number of control points. The Bezier curve is a special form of the B-Spline. More...
class	CubicPoly
	This class allows the user to create a cubic polynomial trajectory by specifying initial and final positions and accelerations. More...
class	FifthOrderPoly
	This class allows the user to create a fifth order polynomial trajectory by specifying initial and final conditions for positions,velocities and accelerations. More...
class	HandPoseMotion
	This class is designed specifically for developing Cartesian space End-Effector motion using HandPoses. More...
class	MotionParameters
	This class is used to store the parameters used for generating trajectories. These parameters include: total time for trajectory, sampling time, a vector of start positions, a vector of stop positions, and a filename/matrix of motion constraints. This class is passed to the OfflineMotionPlanner before calculating a trajectory. More...
class	OfflineMotionPlanner
	This class is used for generating and storing trajectories off-line (not in real-time). More...
class	ParabolicBlend
	This class can be used to develop a parabolic blend through a set of control points. This creates a smooth 3rd degree curve that passes through each of the control points with C1 continuity. More...
class	PathBlend
	This class implements the constant velocity path blending technique developed R. H. Taylor in "Planning and Execution of Straight-Line Manipulator Trajectories." This class will develop a trajectory that smoothly interpolates straight line motions through a set of via points. More...
class	RRMotionPlan
	This class is the base class for the Motion Planning library. It contains the functionality for setting the motion parameters and performs some of the low level calculations. More...
class	Spline
	An abstract class defining the base-level interface for spline curve generation. This includes the ability to set, insert, and delete the control points. More...
Enumerations
enum	HandPoseInterp { NormalInterp, QuaternionLERP, QuaternionSLERP }
Functions
bool	GenerateLine (const Vector &initialPosition, const Vector &finalPosition, Matrix &pathTrajectory, unsigned int steps, unsigned int degree=2, OSCARError &err=DUMMY_ERROR(noError), char *constraintsFileName=NULL)
bool	InterpolateSlerp (const Quaternion &initialQuaternion, const Quaternion &finalQuaternion, Quaternion &resultQuaternion, double t, OSCARError &err=DUMMY_ERROR(noError))
bool	GenerateHandPath (const HandPose &initialHand, const HandPose &finalHand, Matrix &handTrajectory, unsigned int steps, unsigned int degree=2, HandPoseInterp mode=NormalInterp, OSCARError &err=DUMMY_ERROR(noError))
Variables
const OSCARError	MotionPlanErrors
const OSCARError	generationError
const OSCARError	constraintsError
const OSCARError	constraintsExceeded
const OSCARError	parameterError
const OSCARError	slerpFailure

Detailed Description

This library contains functionality for planning smooth trajectories for robotic manipulators. This includes generic trapezoidal trajectories for joint motion, quaternion interpolations for orientation, and EE path planning with velocity and acceleration constraints. This library also contains several splining techniques for generating spatial trajectories such as Parabolic Blends, Bezier Curves, and B-Splines.

Enumeration Type Documentation

enum OSCAR::HandPoseInterp

Enumeration to store different HandPose interpolation methods.

Enumeration values:

NormalInterp

QuaternionLERP

QuaternionSLERP

Function Documentation

bool GenerateHandPath ( const HandPose & initialHand,

const HandPose & finalHand,

Matrix & handTrajectory,

unsigned int steps,

unsigned int degree = 2,

HandPoseInterp mode = NormalInterp,

OSCARError & err = DUMMY_ERROR(noError)

)

Use this method to generate a trajectory between two HandPoses. This method can use quaternion rotations to provide better rotational planning.

Returns:
true if the method succeeds, false if it fails Call GetError() to get detailed error information

Parameters:

initialHand A HandPose object containing the initial pose (the orientation type should be the same as finalHand).

finalHand A HandPose object containing the final pose (the orientation type should be the same as initialHand).

handTrajectory A matrix (with # of rows equal to steps, and # of columns equal to 6) that will store the handpose trajectory.

steps The number of steps to use in the trajectory.

degree The order of the motion system. For example, degree=2 will generate a trapezoidal shape in the 2nd derivative (acceleration).

mode Use this parameter to set the type of rotation interpolation to use in the handpose trajectory. This defaults to NORMAL which will just interpolate between the orientation angles in the handposes. This can also be set to QUAT_LERP or QUAT_SLERP. QUAT_LERP will perform a linear quaternion interpolation. QUAT_SLERP will perform a spherical linear interpolation.

err An OSCARError object that on return will hold the value of any errors that were generated during the constructor call. If err is not equal to 'noError' you can call GetError() to get the details of the error code.

Exceptions:

vectorSizeMismatch vectorSizeMismatch

matrixSizeMismatch matrixSizeMismatch

constraintsExceeded constraintsExceeded

generationError generationError

slerpFailure slerpFailure

See also:
extern bool GenerateLine(Vector& initialPosition, Vector& finalPosition, Matrix& pathTrajectory, unsigned int steps, unsigned int degree = 2, OSCARError& err = OSCARError(0, "No Error"), char* constraintsFileName=" ");
extern bool InterpolateSlerp(const Quaternion& initialQuaternion, const Quaternion& finalQuaternion, Quaternion& resultQuaternion, double t, OSCARError& err = OSCARError(0, "No Error"));

bool GenerateLine ( const Vector & initialPosition,

const Vector & finalPosition,

Matrix & pathTrajectory,

unsigned int steps,

unsigned int degree = 2,

OSCARError & err = DUMMY_ERROR(noError),

char * constraintsFileName = NULL

)

Use this method to generate a motion trajectory between two vectors within a given number of steps.

Returns:
true if the method is able to generate the trajectory, false if some error occurs. Call GetError() to get detailed error information

Parameters:

initialPosition A vector of initial positions (should be same length as finalPosition).

finalPosition A vector of final positions (should be same length as initialPosition).

pathTrajectory A matrix to store the generated trajectory. The number of rows of this trajectory will be equal to steps, and the number of columns will be equal to the length of initialPosition/finalPosition.

steps The number of steps to use in the trajectory.

degree The order of the motion system. For example, degree=2 will generate a trapezoidal shape in the 2nd derivative (acceleration).

err An OSCARError object that on return will hold the value of any errors that were generated during the constructor call. If err is not equal to 'noError' you can call GetError() to get the details of the error code.

constraintsFileName A filename containing a DOFx(degree+1) matrix of constraints. If this is not provided, there will be no constraints imposed on the trajectory generation.

Exceptions:

vectorSizeMismatch vectorSizeMismatch

matrixSizeMismatch matrixSizeMismatch

constraintsExceeded constraintsExceeded

generationError generationError

bool InterpolateSlerp ( const Quaternion & initialQuaternion,

const Quaternion & finalQuaternion,

Quaternion & resultQuaternion,

double t,

OSCARError & err = DUMMY_ERROR(noError)

)

Use this method to calculate a Spherical-Linear Interpolation (SLERP) between two quaternions. A SLERP is a smooth method for interpolating rotations.

Returns:
true if the method succeeds, false if it fails Call GetError() to get detailed error information

Parameters:

initialQuaternion A quaternion holding the initial orientation.

finalQuaternion A quaternion holding the final orientation.

resultQuaternion A quaternion to hold the resulting value.

t This variable varies between 0 and 1 along the interpolation. When t=0, resultQuaterion will be equal to initialQuaternion. When t=1, resultQuaternion will be equal to finalQuaternion.

err An OSCARError object that on return will hold the value of any errors that were generated during the constructor call. If err is not equal to 'noError' you can call GetError() to get the details of the error code.

Exceptions:

slerpFailure slerpFailure