| Blend_d |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| Blend_d_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| Blend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Blend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Blend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Blend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendQ |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendRotation3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendRotation3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendTransform3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendTransform3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector2D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendVector2D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendVector3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
| BlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| BlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CircularInterpolatorVector3D |
Circular interpolator
See the specific template specializations
|
| CircularInterpolatorVector3D_f |
Circular interpolator
See the specific template specializations
|
| CubicSplineFactory |
Factory for creating cubic splines
|
| CubicSplineInterpolator_d |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolator_d_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorQ |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorRotation3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorRotation3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorTransform3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorTransform3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorTransform3DVector |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorVector2D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorVector2D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorVector3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
| CubicSplineInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| CubicSplineInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Interpolator_d |
Interface for interpolators
See the specific implementations for more details
|
| Interpolator_d_f |
Interface for interpolators
See the specific implementations for more details
|
| Interpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Interpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Interpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Interpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorQ |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorRotation3D |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorRotation3D_f |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectory_d |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectory_d_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectory_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectory_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectory_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectory_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQ |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQuaternion |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryQuaternion_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryQuaternion_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQuaternion_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQuaternionCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryQuaternionPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryRotation3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryRotation3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryTransform3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DVector |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryTransform3DVector_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryTransform3DVector_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DVector_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DVectorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryTransform3DVectorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector2D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryVector2D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryVector3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
| InterpolatorTrajectoryVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTrajectoryVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTransform3D |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorTransform3D_f |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorTransform3DVector |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorUtil |
Utilities used in the implementation of various interpolators
and blends.
|
| InterpolatorVector2D |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorVector2D_f |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector3D |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorVector3D_f |
Interface for interpolators
See the specific implementations for more details
|
| InterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| InterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolator_d |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolator_d_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorQ |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorRotation3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorRotation3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorTransform3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorTransform3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector2D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorVector2D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorVector3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| LinearInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LinearInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlend_d |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlend_d_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendQ |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendRotation3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendRotation3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendTransform3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendTransform3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector2D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendVector2D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendVector3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
| LloydHaywardBlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| LloydHaywardBlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlend_d |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlend_d_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendQ |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendRotation3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendRotation3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendTransform3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendTransform3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector2D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendVector2D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendVector3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
| ParabolicBlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| ParabolicBlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| PathQuaternion |
This is a std::Vector overloaded with some extra constructor functionality
|
| PathState |
This is a std::Vector overloaded with some extra constructor functionality
|
| PathTimedQ |
This is a std::Vector overloaded with some extra constructor functionality
|
| PathTimedState |
This is a std::Vector overloaded with some extra constructor functionality
|
| PathTimedTransform3D |
This is a std::Vector overloaded with some extra constructor functionality
|
| PathTransform3DVector |
This is a std::Vector overloaded with some extra constructor functionality
|
| RampInterpolator_d |
|
| RampInterpolator_d_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorQ |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorRotation3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorRotation3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorTransform3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorTransform3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector2D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorVector2D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorVector3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
| RampInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| RampInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| sdurw_trajectory |
|
| sdurw_trajectoryJNI |
|
| Segment_d |
|
| Segment_f |
|
| SegmentQ |
|
| SegmentQuaternion |
|
| SegmentQuaternion_f |
|
| SegmentRotation3D |
|
| SegmentRotation3D_f |
|
| SegmentTransform3D |
|
| SegmentTransform3D_f |
|
| SegmentTransform3DVector |
|
| SegmentTransform3DVector_f |
|
| SegmentVector2D |
|
| SegmentVector2D_f |
|
| SegmentVector3D |
|
| SegmentVector3D_f |
|
| SWIGTYPE_p_double |
|
| SWIGTYPE_p_float |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__QuaternionT_double_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__QuaternionT_float_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__Transform3DVectorT_double_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__Transform3DVectorT_float_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__QuaternionT_double_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__QuaternionT_float_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__Transform3DVectorT_double_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__Transform3DVectorT_float_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__kinematics__State_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__math__Q_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__trajectory__TimedT_rw__kinematics__State_t_t_t |
|
| SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Q_t_t_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__math__Transform3DT_double_t_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__math__Vector3DT_double_t_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__QuaternionT_double_t_t_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Transform3DVectorT_double_t_t_t |
|
| SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Vector3DT_double_t_t_t |
|
| SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__kinematics__State_t__Ptr |
|
| SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__QuaternionT_double_t_t__Ptr |
|
| SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__QuaternionT_float_t_t__Ptr |
|
| SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__Transform3DVectorT_double_t_t__Ptr |
|
| SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__Transform3DVectorT_float_t_t__Ptr |
|
| SWIGTYPE_p_std__vectorT_rw__math__QuaternionT_float_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_double_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_float_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_double_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_float_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Transform3DVectorT_float_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_double_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_float_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
| SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_float_t_t |
|
| Timed_d |
A tuple of (time, value).
|
| Timed_d_f |
A tuple of (time, value).
|
| Timed_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Timed_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Timed_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Timed_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedQ |
A tuple of (time, value).
|
| TimedQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedRotation3D |
A tuple of (time, value).
|
| TimedRotation3D_f |
A tuple of (time, value).
|
| TimedRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedState |
A tuple of (time, value).
|
| TimedStateVector |
|
| TimedTransform3D |
A tuple of (time, value).
|
| TimedTransform3D_f |
A tuple of (time, value).
|
| TimedTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedUtil |
Construction of paths of Timed values.
|
| TimedVector2D |
A tuple of (time, value).
|
| TimedVector2D_f |
A tuple of (time, value).
|
| TimedVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector3D |
A tuple of (time, value).
|
| TimedVector3D_f |
A tuple of (time, value).
|
| TimedVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimedVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TimeMetricUtil |
methods for analyzing time distance of various paths
|
| Trajectory_d |
Interface for Trajectories in RobWork
|
| Trajectory_d_f |
Interface for Trajectories in RobWork
|
| Trajectory_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Trajectory_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Trajectory_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| Trajectory_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryFactory |
Trajectory constructors
|
| TrajectoryIterator_d |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIterator_d_f |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIterator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIterator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIterator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIterator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorQ |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorRotation3D |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorRotation3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorTransform3D |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorTransform3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector2D |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorVector2D_f |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector3D |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorVector3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
| TrajectoryIteratorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryIteratorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryQ |
Interface for Trajectories in RobWork
|
| TrajectoryQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryQuaternion |
Interface for Trajectories in RobWork
|
| TrajectoryQuaternion_f |
Interface for Trajectories in RobWork
|
| TrajectoryRotation3D |
Interface for Trajectories in RobWork
|
| TrajectoryRotation3D_f |
Interface for Trajectories in RobWork
|
| TrajectoryRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequence_d |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequence_d_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequence_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequence_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequence_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequence_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceQ |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceRotation3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceRotation3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceTransform3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceTransform3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector2D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceVector2D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceVector3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
| TrajectorySequenceVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectorySequenceVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryState |
Interface for Trajectories in RobWork
|
| TrajectoryStatePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryTransform3D |
Interface for Trajectories in RobWork
|
| TrajectoryTransform3D_f |
Interface for Trajectories in RobWork
|
| TrajectoryTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryTransform3DVector |
Interface for Trajectories in RobWork
|
| TrajectoryTransform3DVector_f |
Interface for Trajectories in RobWork
|
| TrajectoryVector2D |
Interface for Trajectories in RobWork
|
| TrajectoryVector2D_f |
Interface for Trajectories in RobWork
|
| TrajectoryVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector3D |
Interface for Trajectories in RobWork
|
| TrajectoryVector3D_f |
Interface for Trajectories in RobWork
|
| TrajectoryVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| TrajectoryVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
| VectorPathQ |
|
| VectorQuaternion |
|
| VectorTimedQ |
|
| VectorTimedTransform3D |
|
| VectorTrajectoryQPtr |
|
| VectorTransform3dVector |
|