BlendQ 

BlendQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

BlendR1 

BlendR1Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

BlendR2 

BlendR2Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

BlendR3 

BlendR3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

BlendSE3 

BlendSE3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

BlendSO3 

BlendSO3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

Box 

Camera 
The Camera class defines a generel interface to a camera.
A great deal of the interface resembles the DCAM standard since
DCAM allready defines a very wide interface.
typical usage:
Camera c;
// setup camera features modes and so on
c.initialize();
c.start();
// acquire images
c.stop();

CameraFirewire 
The Camera class defines a generel interface to a camera.
A great deal of the interface resembles the DCAM standard since
DCAM allready defines a very wide interface.
typical usage:
Camera c;
// setup camera features modes and so on
c.initialize();
c.start();
// acquire images
c.stop();

CameraFirewire.CameraFeature 
Optional features of a camera

CameraFirewire.CaptureMode 
The resolution of the camera capture

CameraFirewire.CapturePolicy 
defines how images are captured.
When the SINGLE_SHOT CapturePolicy is used the user has to trigger
the camera through acquire.

CameraFirewire.ColorCode 
Optional colormodes available when capturing

CameraFirewire.ErrorCode 
error codes for a camera

CameraFirewire.Format7Mode 
The resolution of the camera capture

CameraFirewire.TriggerMode 
Modes of the camera, inspired by the DCAM standard modes

CameraListener 
interface used for listening for camera events

CameraMatrixd 
The PerspectiveTransform2D is a perspective transform in 2D.
The homographic transform can be used to map one arbitrary 2D quadrilateral
into another.

CameraModel 
The CameraModel class defines a generel pinhole camera model where
camera parameters and state values are stored.

CameraModelCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CameraModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CameraPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ClosedFormIK 
Interface for closed form inverse kinematics algorithms.
The ClosedFormIK interface provides an interface for calculating the
inverse kinematics of a device.
By default it solves the problem beginning at the robot base and
ending with the frame defined as the end of the devices, and which is
accessible through the Device::getEnd() method.

ClosedFormIKPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ClosedFormIKSolverKukaIIWA 
Analytical inverse solver for the Kuka LBR IIWA 7 R800 robot.
Notice that this is a 7 DOF robot and that there is an infinite number of solutions.
The extra DOF means that the middle joint of the robot is able to move in a circle.
This solver will choose a point on this circle randomly and return up to 8 possible solutions.

ClosedFormIKSolverKukaIIWAPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ClosedFormIKSolverUR 
Analytical inverse kinematics solver to the kinematics of a Universal Robots.

ClosedFormIKSolverURCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ClosedFormIKSolverURPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CollisionDetector 
The CollisionDetector implements an efficient way of checking a
complete frame tree for collisions.
It relies on a BroadPhaseDetector to do initial filtering which removes obviously not
colliding frame pairs.
After the filtering the remaining frame pairs are tested for collision using an
CollisionStrategy which is a narrow phase collision detector.
The collision detector does not dictate a specific detection
strategy or algorithm, instead it relies on the CollisionStrategy interface for
the actual collision checking between two frames.
Note: The collision detector is not thread safe and as such should not be used by multiple
threads at a time.

CollisionDetectorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CollisionDetectorQueryResult 
result of a collision query

CollisionDetectorQueryType 
types of collision query

CollisionSetup 
Setup for the collision checker
The CollisionSetup contains information about
which frames, not be checked against each other

CollisionStrategy 
An interface that defines methods to test collision between
two objects.

CollisionStrategy.Contact 

CollisionStrategyCollisionPair 
a collision pair of

CollisionStrategyCollisionPairVector 

CollisionStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CollisionStrategyQueryType 
types of collision query

CollisionStrategyResult 
result of a single collision pair
A collision result is one or all colliding triangles between two objects which may have
several geometries attached.
The collision result does not have access to the actual triangle meshes of the geometries
so to extract the actual contact location the user has to supply the triangles meshes of
the geometries himself.

CollisionToleranceStrategy 
This is a collision strategy that detects collisions between objects
that are closer than a specified tolerance.

CollisionToleranceStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

CompositeDevice 
A device constructed from a sequence of devices.
The configuration of a composite device is equal to the concatenation of
the configurations of the sequence of devices.
The devices that make up the CompositeDevice may not share joints, but
the implementation does not check if this is actually the case.
A composite device implements its operations of Device by querying each
Joint in the straightforward way of JointDevice.

CompositeDevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

CompositeJointDevice 
A device constructed from a sequence of devices.
The configuration of a composite device is equal to the concatenation of
the configurations of the sequence of devices.
The devices that make up the CompositeJointDevice may not share joints, but
the implementation does not check if this is actually the case.
A composite device implements its operations of Device by querying each
Joint in the straightforward way of JointDevice.

Cone 

Contact2D 
data structure for describing a contact in 2D

Contact2DPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Contact3D 
data structure for describing a contact in 3D

Contact3DPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ControllerModel 
Interface to allow modelling of different types of controllers.
A controller is an instance that takes an input manipulates it to an output
that in effect controls something.

ControllerModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ControllerModelPtrVector 

ConvexHull3D 

Cylinder 
Cylinder primitive.

DeformableObject 
The deformable object is an object that contain a deformable mesh.

DeformableObjectPtr 
Ptr stores a pointer and optionally takes ownership of the value.

DeformableObjectPtrVector 

DependentJoint 
Dependent joints are 0dof joints for which the actual joints transformation depends
on one of more other joints.
DependentJoint is an abstract class from which all dependent joints should inherit.

DependentPrismaticJoint 
Dependent prismatic joint.
DependentPrismaticJoint implements a prismatic joint for which the displacement
along the zaxis are linearly dependent on another joint

DependentRevoluteJoint 
Dependent revolute joints.
DependentRevoluteJoint implements a revolute joint for which the rotation about the
zaxis are linearly dependent on another joint.
The parent to frame transform is T * Rz(q) where:
 T is the displacement transform of the joint;
 q = q_owner * scale + offset is the joint value of the joint;
 Rz(q) is the transform that rotates a point an angle q about the
zaxis.

Device 
An abstract device class
The Device class is the basis for all other devices.

DeviceCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

DeviceJacobianCalculator 
Calculator for Jacobians of one or several Devices.
Implements Jacobian calculations for one or several Devices.
If more than one endeffector is given a "stacked" Jacobian is returned.

DevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

DevicePtrVector 

DHParameterSet 
Simple class to help represent a set of DenavitHartenberg
parameters

DHParameterSetVector 

DistanceCalculator 
The DistanceCalculator implements an efficient way of calculating
different distances between two objects, each represented by a frame
A list of frame pairs is contained within the distance calculater,
that specifies which frames are to be checked against each other.
The method of used for distance calculation relies on the DistanceStrategy
chosen.
The DistanceCalculator supports switching between multiple strategies

DistanceCalculatorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

DistanceMultiStrategy 

DistanceMultiStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

DistanceMultiStrategyResult 
DistanceResult contains basic information about the distance
result between two frames.

DistanceMultiStrategyResultVector 

DistanceStrategy 
This is an interface that defines methods for computing the minimum distance
between geometric objects.

DistanceStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

DistanceStrategyResult 

DistanceStrategyResultVector 

DrawableNode 

DrawableNode.DrawType 

DrawableNodePtr 
Ptr stores a pointer and optionally takes ownership of the value.

DrawableNodePtrVector 

EAAd 
A class for representing an equivalent angleaxis rotation
This class defines an equivalentaxisangle orientation vector also known
as an \thetak vector or "axis+angle" vector
The equivalentaxisangle vector is the product of a unit vector
\hat{\mathbf{k}} and an angle of rotation around that axis \theta
Note: given two EAA vectors \theta_1\mathbf{\hat{k}}_1 and
\theta_2\mathbf{\hat{k}}_2 it is generally not possible to subtract
or add these vectors, except for the special case when
\mathbf{\hat{k}}_1 == \mathbf{\hat{k}}_2 this is why this class does
not have any subtraction or addition operators

EAAf 
A class for representing an equivalent angleaxis rotation
This class defines an equivalentaxisangle orientation vector also known
as an \thetak vector or "axis+angle" vector
The equivalentaxisangle vector is the product of a unit vector
\hat{\mathbf{k}} and an angle of rotation around that axis \theta
Note: given two EAA vectors \theta_1\mathbf{\hat{k}}_1 and
\theta_2\mathbf{\hat{k}}_2 it is generally not possible to subtract
or add these vectors, except for the special case when
\mathbf{\hat{k}}_1 == \mathbf{\hat{k}}_2 this is why this class does
not have any subtraction or addition operators

EigenMatrix2d 

EigenMatrix2f 

EigenMatrix3d 

EigenMatrix3f 

EigenMatrix3id 

EigenMatrix4d 

EigenMatrix4f 

EigenMatrixXd 

EigenMatrixXf 

EigenQuaterniond 

EigenQuaternionf 

EigenRowVector3d 

EigenRowVector3f 

EigenRowVector3id 

EigenVector2d 

EigenVector2f 

EigenVector3d 

EigenVector3f 

EigenVector3id 

EigenVector6d 

EigenVector6f 

EigenVector7d 

EigenVector7f 

EigenVectorXd 

EigenVectorXf 

FixedFrame 
FixedFrame is a frame for which the transform relative to the
parent is constant.
A fixed frame can for example be used for attaching a camera, say, with a
fixed offset relative to the tool.

FixedFramePtr 
Ptr stores a pointer and optionally takes ownership of the value.

FKRange 
Forward kinematics between a pair of frames.
FKRange finds the relative transform between a pair of frames.

FKTable 
Forward kinematics for a set of frames.
FKTable finds transforms for frames for a given fixed work cell state.
The frame transforms are calculated relative to the world frame.

Frame 
The type of node of forward kinematic trees.
Types of joints are implemented as subclasses of Frame.

FrameCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

FrameMapd 

FramePair 

FramePairVector 

FramePtr 
Ptr stores a pointer and optionally takes ownership of the value.

FrameType 
Enumeration of all concrete frame types of RobWork.
FrameType::Type is an enumeration of all frame types defined within
RobWork.

FrameType.Type 
FrameType enumeration

FrameVector 

FTSensor 
Interface of a Naxis Force Torque sensor

FTSensorModel 
Naxis Force Torque sensor model

FTSensorModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

FTSensorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Function1Diffddd 
Interface for functions which are 1 time differentiable

Function1DiffdddPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Functiondd 
Interface for functions

Geometry 

GeometryData 

GeometryData.GeometryType 

GeometryDataPtr 
Ptr stores a pointer and optionally takes ownership of the value.

GeometryPtr 
Ptr stores a pointer and optionally takes ownership of the value.

GeometryPtrVector 

IKMetaSolver 
Solve the inverse kinematics problem with respect to joint limits and
collisions.
Given an arbitrary iterative inverse kinematics solver, the IKMetaSolver
attempts to find a collision free solution satisfying joint limits.

IKMetaSolverPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Image 
The image class is a simple wrapper around a char data array.
This Image wrapper contain information of width, height and encoding.
The image class is somewhat inspired by the IplImage of opencv.
The coordinate system has its origin located at the topleft position, where from X increases to
the left and Yincreases downwards.
setting pixel values in an efficient manner has been enabled using some template joggling.
It requires that the user know what type of image he/she is working with.

Image.ColorCode 
The color encodings that the image can use.

Image.PixelDepth 
The pixeldepth determines how many bits that are used per pixel per channel

ImageLoader 

ImageLoaderFactory 

ImageLoaderPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ImagePtr 
Ptr stores a pointer and optionally takes ownership of the value.

ImageUtil 
a collection of simple image utility functions

IndexedTriangleU16 
indexed triangle class that has 3 indices that points to 3
vertices in an array typically used with the IndexedTriMesh class.
the indice type (size) is templated.

IndexedTriangleU16Vector 

InertiaMatrixd 
A 3x3 inertia matrix

InertiaMatrixdVector 

InertiaMatrixf 
A 3x3 inertia matrix

InterpolatorQ 

InterpolatorQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorR1 

InterpolatorR1Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorR2 

InterpolatorR2Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorR3 

InterpolatorR3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorSE3 

InterpolatorSE3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorSO3 

InterpolatorSO3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

InterpolatorTrajectoryQ 

InterpolatorTrajectoryR1 

InterpolatorTrajectoryR2 

InterpolatorTrajectoryR3 

InterpolatorTrajectorySE3 

InterpolatorTrajectorySO3 

IntPair 

IntPairVector 

InvKinSolver 
Interface for inverse kinematics algorithms
The InvKinSolver interface provides an interface for calculating
the inverse kinematics of a device.
By default it solves the problem beginning at the robot base and
ending with the frame defined as the end of the devices, and which is
accessible through the Device::getEnd() method.

InvKinSolverPtr 
Ptr stores a pointer and optionally takes ownership of the value.

IterativeIK 
Interface for iterative inverse kinematics algorithms
The IterativeIK interface provides an interface for calculating
the inverse kinematics of a device.
By default it solves the problem beginning at the robot base and
ending with the frame defined as the end of the devices, and which is
accessible through the Device::getEnd() method.

IterativeIKPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Jacobian 

JacobianCalculator 
JacobianCalculator provides an interface for obtaining a Jacobian

JacobianCalculatorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

JacobianIKSolver 
A Jacobian based iterative inverse kinematics algorithm for devices with a single end effector.
This algorithm does implicitly handle joint limits, however it is possible to force the solution within joint
limits using clamping in each iterative step.

JacobianIKSolver.JacobianSolverType 
the type of jacobian solver

JacobianIKSolverPtr 
Ptr stores a pointer and optionally takes ownership of the value.

JacobianUtil 
Primitive utilities for computing jacobians for joints of various
types.

Joint 
A Joint is a Frame with assignable values for
position, velocity limits and acceleration limits.

JointDevice 
A device for a sequence of joints.
Contrary to for example SerialDevice and TreeDevice, the joints need not
have any particular ordering within the kinematic tree.
A JointDevice is a joint for which the values of the configuration Q each
correspond to a frame of type Joint.
To implement a Device it is common to derive from JointDevice and just
add implement methods where your device differs from the standard
behaviour.

JointDeviceCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

JointDeviceJacobianCalculator 
Calculator for Jacobians of a JointDevice
Implements Jacobian calculations for a JointDevice.

JointDevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

JointDevicePtrVector 

JointPointerVector 

JointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Kinematics 
Utility functions for the rw::kinematics module.

Line2D 
Describes a line segment in 2D.

Line2D.IntersectResult 
definition of intersection result values for the intersection test
between two lines.

Line2DPolar 
Describes a line in 2D in polar coordinates.

LinearInterpolator 

LinearInterpolatorQ 

LinearInterpolatorR3 

LinearInterpolatorSE3 

LinearInterpolatorSO3 

MapStringFrame 

Math 

MetricFactory 

MetricPtrTransform3D 
Ptr stores a pointer and optionally takes ownership of the value.

MetricQ 
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.

MetricQCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

MetricQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

MetricTransform3D 
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.

MobileDevice 
Provides a differential controlled mobile device
The MobileDevice class provides a differential controlled mobile device
with nonholonomic constraints.

Model3D 

Model3DPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Model3DPtrVector 

Models 
Utility functions for the rw::models module.

MovableFrame 
MovableFrame is a frame for which it is possible to freely
change the transform relative to the parent.
A MovableFrame can for example be used for modelling objects moving in
the scene based on e.g.

MovableFramePtr 
Ptr stores a pointer and optionally takes ownership of the value.

MovableFrameVector 

Object 
The object class represents a physical thing in the scene which has geometry.
An object has a base frame (similar to a Device) and may have a number of associated frames.

ObjectPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ObjectPtrVector 

PairConstQConstQ 

ParallelDevice 
This class defines the interface for Parallel devices.

ParallelDevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

ParallelDevicePtrVector 

ParallelLeg 
Class representing a single leg in a ParallelDevice

ParallelLegPointerVector 

ParallelLegPointerVectorVector 

ParallelLegPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ParallelLegPtrVector 

PathPlannerQQ 

PathPlannerQQSampler 

PathQ 

PathQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PathSE3 

PathSE3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

PathState 

PathStatePtr 
Ptr stores a pointer and optionally takes ownership of the value.

PathTimedQ 

PathTimedQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PathTimedState 

PathTimedStatePtr 
Ptr stores a pointer and optionally takes ownership of the value.

PieperSolver 
Calculates the closed form inverse kinematics of
a device using Piepers method
To use Piepers method it is required that the device has
6 DOF revolute joints, and that last three axis intersects.
In this implementation it will be assumed that the that
rotation of these last three axis are equivalent to an
Euler ZYZ or Z(Y)Z rotation.
See Introduction to Robotics Mechanics and Control, by
John J.

Pixel4f 

Pixel4i 

PlainTriMeshN1 

PlainTriMeshN1f 

PlainTriMeshN1fPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PlainTriMeshN1Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

Plane 

PlannerConstraint 

PlannerConstraintPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PointCloud 
A simple point cloud data structure.

PointCloudPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Polynomiald 
Representation of an ordinary polynomial with scalar coefficients (that can be both
real and complex).
Representation of a polynomial of the following form:
f(x) = c_n x^n + c_(n1) x^(n1) + c_2 x^2 + c_1 x + c_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

Polynomialf 
Representation of an ordinary polynomial with scalar coefficients (that can be both
real and complex).
Representation of a polynomial of the following form:
f(x) = c_n x^n + c_(n1) x^(n1) + c_2 x^2 + c_1 x + c_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

Polynomialid 
Representation of an ordinary polynomial with scalar coefficients (that can be both
real and complex).
Representation of a polynomial of the following form:
f(x) = c_n x^n + c_(n1) x^(n1) + c_2 x^2 + c_1 x + c_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDdDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenMatrix3dDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenMatrix3fFloat 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenMatrix3ifComplexDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenRowVector3dDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenRowVector3fFloat 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenRowVector3idComplexDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenVector3dDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenVector3fFloat 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDEigenVector3idComplexDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDfFloat 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialNDidComplexDouble 
Representation of a polynomial that can have nonscalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n1) x^(n1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowestorder term to
highestorder term, {c_0,c_1,...,c_n} .

PolynomialSolver 
Find solutions for roots of real and complex polynomial equations.
The solutions are found analytically if the polynomial is of maximum order 3.
For polynomials of order 4 and higher, Laguerre's Method is used to find
roots until the polynomial can be deflated to order 3.
The remaining roots will then be found analytically.
Some Polynomials are particularly easy to solve.

Pose2Dd 
A Pose3D \mathbf{x}\in \mathbb{R}^6 describes a position
and orientation in 3dimensions.
{\mathbf{x}} = \left[
\begin{array}{c}
x \\
y \\
z \\
\theta k_x \\
\theta k_y \\
\theta k_z
\end{array}
\right]
where (x,y,z) is the 3d position and (\theta k_x, \theta k_y,
\theta k_z) describes the orientation in equal angle axis (EAA)
format.

Pose2Df 
A Pose3D \mathbf{x}\in \mathbb{R}^6 describes a position
and orientation in 3dimensions.
{\mathbf{x}} = \left[
\begin{array}{c}
x \\
y \\
z \\
\theta k_x \\
\theta k_y \\
\theta k_z
\end{array}
\right]
where (x,y,z) is the 3d position and (\theta k_x, \theta k_y,
\theta k_z) describes the orientation in equal angle axis (EAA)
format.

Pose6Dd 
A Pose6D \mathbf{x}\in \mathbb{R}^6 describes a position
and orientation in 3dimensions.
{\mathbf{x}} = \left[
\begin{array}{c}
x \\
y \\
z \\
\theta k_x \\
\theta k_y \\
\theta k_z
\end{array}
\right]
where (x,y,z) is the 3d position and (\theta k_x, \theta k_y,
\theta k_z) describes the orientation in equal angle axis (EAA)
format.

Pose6Df 
A Pose6D \mathbf{x}\in \mathbb{R}^6 describes a position
and orientation in 3dimensions.
{\mathbf{x}} = \left[
\begin{array}{c}
x \\
y \\
z \\
\theta k_x \\
\theta k_y \\
\theta k_z
\end{array}
\right]
where (x,y,z) is the 3d position and (\theta k_x, \theta k_y,
\theta k_z) describes the orientation in equal angle axis (EAA)
format.

Primitive 

PrismaticJoint 
Prismatic joints.
PrismaticJoint implements a prismatic joint for the displacement in the
direction of the zaxis of an arbitrary displacement transform.

PrismaticJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PrismaticSphericalJoint 
A prismatic spherical joint that allows rotations in all directions and translation
along one direction.
Rotation is allowed around all axes.

PrismaticSphericalJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

PrismaticUniversalJoint 
A prismatic universal joint that allows rotations in two directions and translation
along the third.
Rotation is allowed around the x and y axes.

PrismaticUniversalJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProjectionMatrix 
projection matrix

ProximityCache 

ProximityCachePtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityData 

ProximityDataPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityFilter 
this class is used for fetching frame pairs using some proximity filtering strategy.
The proximity filter is statefull and in the simplest case its an iterator over a set of frame pairs.
The filter implementations should support early existing, to reduce computations.

ProximityFilterPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityFilterStrategy 
describe the interface of a broad phase proximity strategy or proximity culler.
A broadphase strategy implement heuristics or rules for finding frame pairs that
are possibly overlapping and excluding framepairs that are definitely not overlapping.
The interface supports early exiting by returning framepairs in an iterative manor.

ProximityFilterStrategyCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityFilterStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityModel 

ProximityModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximitySetup 
Setup for the collision checker
The ProximitySetup contains the rules about which frames should be
checked against each other

ProximitySetupRule 
Rule specifying include/exclude of frame pairs
The rule has two patterns, pattern A and pattern B, to which frames can be matched.

ProximitySetupRule.RuleType 
Include and Exclude identifiers

ProximitySetupRuleVector 

ProximityStrategy 
The ProximityStrategy interface is a clean interface
for defining methods that are common for different proximity
strategy classes.

ProximityStrategyData 

ProximityStrategyDataPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ProximityStrategyDataPtrVector 

ProximityStrategyDataVector 

ProximityStrategyPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Q 
Configuration vector

QConstraint 
Interface for the checking for collisions for work cell states.

QConstraintCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QConstraintPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QConstraintPtrVector 

QEdgeConstraint 
Edge constraint interface.
An edge constraint represents a path that connects a pair of
configurations and checks if this path can be traversed.
The edge constraint may assume that the start and end configurations are
valid (e.g.

QEdgeConstraintIncremental 
Edge constraint interface for incremental testing of an edge
An edge constraint represents a path that connects a pair of
configurations and checks if this path can be traversed.
The edge constraint may assume that the start and end configurations are
valid (e.g.

QEdgeConstraintIncrementalPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QEdgeConstraintPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QEdgeConstraintPtrVector 

QIKSampler 
Interface for the sampling a configuration that solves an IK
problem.

QIKSamplerCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QIKSamplerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QNormalizer 
Normalization of configurations.
QNormalizer linearly maps configurations of a rectangular configuration
space into a square configuration space with lower corner (0, 0, ..., 0)
and upper corner (1, 1, ..., 1).

QNormalizerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QPair 

QSampler 
Interface for the sampling a configuration.

QSamplerCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QSamplerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QState 
The configuration state of a work cell.
The configuration state contains state data values for all
valid StateData in a StateStructure.

QToQPlanner 

QToQPlannerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QToQSamplerPlanner 
Sampled region planner interface.
QToQSamplerPlanner plans a configuration space path from a start
configuration to any configuration in the set represented by a sampler.

QToQSamplerPlannerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

QToTPlanner 

QToTPlannerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Quaterniond 
A Quaternion \mathbf{q}\in \mathbb{R}^4 a complex
number used to describe rotations in 3dimensional space.
q_w+{\bf i}\ q_x+ {\bf j} q_y+ {\bf k}\ q_z
Quaternions can be added and multiplied in a similar way as usual
algebraic numbers.

Quaternionf 
A Quaternion \mathbf{q}\in \mathbb{R}^4 a complex
number used to describe rotations in 3dimensional space.
q_w+{\bf i}\ q_x+ {\bf j} q_y+ {\bf k}\ q_z
Quaternions can be added and multiplied in a similar way as usual
algebraic numbers.

QVector 

RampInterpolator 

RampInterpolatorQ 

RampInterpolatorR3 

RampInterpolatorSE3 

RampInterpolatorSO3 

Random 
Generation of random numbers.

Render 

RenderInfo 

RenderPtr 
Ptr stores a pointer and optionally takes ownership of the value.

RevoluteJoint 

RevoluteJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

RGBDCameraModel 

RGBDCameraModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

RigidBodyInfo 
A class to wrap rigid body information.

RigidObject 
the RigidObject defines a physical object in the workcell that is rigid in the sence that
the geometry does not change.

RigidObjectPtr 
Ptr stores a pointer and optionally takes ownership of the value.

RigidObjectPtrVector 

Rotation2Dd 
A 2x2 rotation matrix \mathbf{R}\in SO(2)
\mathbf{R}=
\left[
\begin{array}{cc}
{}^A\hat{X}_B {}^A\hat{Y}_B
\end{array}
\right]
=
\left[
\begin{array}{cc}
r_{11} r_{12} \\
r_{21} r_{22}
\end{array}
\right]

Rotation2Df 
A 2x2 rotation matrix \mathbf{R}\in SO(2)
\mathbf{R}=
\left[
\begin{array}{cc}
{}^A\hat{X}_B {}^A\hat{Y}_B
\end{array}
\right]
=
\left[
\begin{array}{cc}
r_{11} r_{12} \\
r_{21} r_{22}
\end{array}
\right]

Rotation3Dd 
A 3x3 rotation matrix \mathbf{R}\in SO(3)
\mathbf{R}=
\left[
\begin{array}{ccc}
{}^A\hat{X}_B {}^A\hat{Y}_B {}^A\hat{Z}_B
\end{array}
\right]
=
\left[
\begin{array}{ccc}
r_{11} r_{12} r_{13} \\
r_{21} r_{22} r_{23} \\
r_{31} r_{32} r_{33}
\end{array}
\right]

Rotation3Df 
A 3x3 rotation matrix \mathbf{R}\in SO(3)
\mathbf{R}=
\left[
\begin{array}{ccc}
{}^A\hat{X}_B {}^A\hat{Y}_B {}^A\hat{Z}_B
\end{array}
\right]
=
\left[
\begin{array}{ccc}
r_{11} r_{12} r_{13} \\
r_{21} r_{22} r_{23} \\
r_{31} r_{32} r_{33}
\end{array}
\right]

Rotation3DVectord 
An abstract base class for Rotation3D parameterisations
Classes that represents a parametrisation of a 3D rotation may inherit
from this class

Rotation3DVectorf 
An abstract base class for Rotation3D parameterisations
Classes that represents a parametrisation of a 3D rotation may inherit
from this class

RPYd 
A class for representing RollPitchYaw Euler angle rotations.

RPYdVector 

RPYf 
A class for representing RollPitchYaw Euler angle rotations.

RWVectord 
Configuration vector

RWVectorf 
Configuration vector

Scanner 
this interface describe a generic range scanning class.

Scanner1D 
a one dimensional range scanner.

Scanner25D 
an interface describing a 3D scanner sensor.

Scanner25DModel 
Model of a 25D (2D with depth information) scanner.

Scanner25DModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Scanner25DPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Scanner2D 
The Scanner2D sensor encapsulate the basic interface of a
2 dimensional range scanning device such as SICK or Hokyuo laser
range scanners.
The interface supports any range scanner that measures distance in
an arc around the origin of the sensor.

Scanner2DModel 
The Scanner2DModel encapsulate the basic model of a
2 dimensional range scanning device such as SICK or Hokyuo laser
range scanners.
The model supports any range scanner that measures distance in
an arc around the origin of the sensor.

Scanner2DModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Scanner2DPtr 
Ptr stores a pointer and optionally takes ownership of the value.

ScannerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

SceneViewer 

SceneViewerPtr 
Ptr stores a pointer and optionally takes ownership of the value.

sdurw 

SE3Device 
A Cartesian 6Dof device
The SE3Device is a 6dof device with 6 independent inputs that
enables the device to place its endeffector anywhere in the workspace.
The \mathbf{q}\in \mathbb{R}^6 input vector maps directly to the
endeffector pose \robabx{b}{e}{\mathbf{x}} , thus:
\robabx{b}{e}{\mathbf{x}} =
\left[
\begin{array}{c}
x\\
y\\
z\\
\theta k_x\\
\theta k_y\\
\theta k_z
\end{array}
\right] =
\left[
\begin{array}{c}
q_1\\
q_2\\
q_3\\
q_4\\
q_5\\
q_6
\end{array}
\right] =
\mathbf{q}
It is easily seen that the jacobian
{^b_6}\mathbf{J}_{\mathbf{q}}(\mathbf{q}) = \frac{\partial
^b\mathbf{x}_6}{\partial \mathbf{q}} equals the 6\times 6
identity matrix \mathbf{I}^{6\times 6}
The device can be seen as a "perfect" robot, it has no singularities
anywhere in the task space, no kinematic or dynamic limits (it can
instantaneous move anywhere at any time).

Sensor 
a generel hardware sensor interface.

SensorData 
toplevel class for sensor data.

SensorModel 
a general sensormodel interface.

SensorModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

SensorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

SerialDevice 
The device for a serial chain.
SerialChain is like JointDevice except that SerialChain has the
additional guarantee that the joints lie on a single parent to child
path of the kinematic tree.

SerialDeviceCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

SerialDevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

SerialDevicePtrVector 

Sphere 

SphericalJoint 
A spherical joint that allows rotations in all directions.
Rotation is allowed around the x, y and zaxes.

SphericalJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

State 
The state of a work cell (or kinematics tree).
You need a work cell state in order to calculate forward kinematics for
trees of frames.
Work cell states can be copied and assigned freely.
The work cell state consists of a part for the tree structure and a part
for the configuration values.

StateCache 
the basic building block for the stateless desing using
the StateStructure class.

StateCachePtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateConstraint 
Interface for the checking for collisions for work cell states.

StateConstraintCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateConstraintPtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateConstraintPtrVector 

StateData 
the basic building block for the stateless design using
the StateStructure class.

StateDataPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Stateless 
interface for a stateless or typically a part stateless class.

StatelessPtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateSetup 
Utility class to help construct a State
StateSetup contains the data to share among QState objects and
TreeState objects, namely the assignment of offsets to frames,
the mapping of frame indexes to indexes in the QState,
the mapping of frame indexes to daf and dafparent index in
the TreeState,

StateSetupPtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateStructure 
the StateStructure is responsible for handling a
structure of StateData and Frames

StateStructurePtr 
Ptr stores a pointer and optionally takes ownership of the value.

StateVector 

StereoCameraModel 
The Camera class defines a general interface to a stereo camera.
A stereo camera consists of two cameras with the same intrinsic parameters,
but with different extrinsic parameters.
Since ideal cameras are assumed, the intrinsics are given as a horizontal/vertical
pixel resolution as well as a horizontal field of view (FOV).
The extrinsic parameters are given simply as two transformation matrices,
which give the pose of the cameras relative some external frame.

StereoCameraModel.CalibrationFormat 
output calibration file format for SaveCalibration()

StereoCameraModel.FOVDirection 
FOV direction

StereoCameraModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

STLFile 

StopCriteria 

StopCriteriaPtr 
Ptr stores a pointer and optionally takes ownership of the value.

StopCriteriaPtrVector 

StringPair 

StringPairVector 

SWIGTYPE_p_double 

SWIGTYPE_p_Eigen__MatrixT_std__complexT_float_t_3_3_t 

SWIGTYPE_p_float 

SWIGTYPE_p_InputArchive 

SWIGTYPE_p_OutputArchive 

SWIGTYPE_p_ProximitySetup 

SWIGTYPE_p_rw__core__FireFunctorT_WorkCellChangedListener_int_rw__core___n1_rw__core___n1_rw__core___n1_rw__core___n1_t 

SWIGTYPE_p_rw__core__PtrT_rw__geometry__IndexedTriMeshT_float_t_t 

SWIGTYPE_p_rw__core__PtrT_rw__models__WorkCell_t 

SWIGTYPE_p_rw__core__PtrT_SceneCamera_t 

SWIGTYPE_p_rw__core__PtrT_SceneDescriptor_t 

SWIGTYPE_p_rw__math__PolynomialNDT_Eigen__MatrixT_std__complexT_double_t_3_3_t_std__complexT_double_t_t 

SWIGTYPE_p_rw__models__WorkCell 

SWIGTYPE_p_rw__proximity__CollisionSetup 

SWIGTYPE_p_std__listT_rw__core__EventListenerT_WorkCellChangedListener_t_t 

SWIGTYPE_p_std__ostream 

SWIGTYPE_p_std__vectorT_Eigen__MatrixT_std__complexT_double_t_1_3_t_t 

SWIGTYPE_p_std__vectorT_Eigen__MatrixT_std__complexT_float_t_3_3_t_t 

SWIGTYPE_p_uint16_t 

SWIGTYPE_p_void 

SWIGTYPE_p_WorkCellChangedListener 

TactileArray 

TactileArrayModel 
the TactileArrayModel describes tactile sensor consisting of
arrays of tactile cells that can be placed on a defined shape.

TactileArrayModelPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TactileArrayPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TactileArrayUtil 
Utillity class for general computations on a tactile array

TactileVertexMatrix 

TimedQ 

TimedQVector 

TimedQVectorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TimedState 

TimedStateVector 

TimedStateVectorPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectoryQ 

TrajectoryQPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectoryR1 

TrajectoryR1Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectoryR2 

TrajectoryR2Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectoryR3 

TrajectoryR3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectorySE3 

TrajectorySE3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectorySO3 

TrajectorySO3Ptr 
Ptr stores a pointer and optionally takes ownership of the value.

TrajectoryState 

TrajectoryStatePtr 
Ptr stores a pointer and optionally takes ownership of the value.

Transform2Dd 
A 4x4 homogeneous transform matrix \mathbf{T}\in SE(3)
\mathbf{T} =
\left[
\begin{array}{cc}
\mathbf{R} \mathbf{d} \\
\begin{array}{ccc}0 0 0\end{array} 1
\end{array}
\right]

Transform2Df 
A 4x4 homogeneous transform matrix \mathbf{T}\in SE(3)
\mathbf{T} =
\left[
\begin{array}{cc}
\mathbf{R} \mathbf{d} \\
\begin{array}{ccc}0 0 0\end{array} 1
\end{array}
\right]

Transform3Dd 
A 4x4 homogeneous transform matrix \mathbf{T}\in SE(3)
\mathbf{T} =
\left[
\begin{array}{cc}
\mathbf{R} \mathbf{d} \\
\begin{array}{ccc}0 0 0\end{array} 1
\end{array}
\right]

Transform3Df 
A 4x4 homogeneous transform matrix \mathbf{T}\in SE(3)
\mathbf{T} =
\left[
\begin{array}{cc}
\mathbf{R} \mathbf{d} \\
\begin{array}{ccc}0 0 0\end{array} 1
\end{array}
\right]

Transform3DVectord 
this class is a interpolatable Transform3D, consisting of a Vecor3D and a Quaternion.
It is implemented to be very Interconvertable with a Transform3D, and allow operations souch
as Transform * scalar and Transform + Transform.

Transform3DVectorf 
this class is a interpolatable Transform3D, consisting of a Vecor3D and a Quaternion.
It is implemented to be very Interconvertable with a Transform3D, and allow operations souch
as Transform * scalar and Transform + Transform.

TreeDevice 
A tree structured device
This device type defines devices that are treestructured, with multiple end effectors.
Typical for dexterous hands, and multiarmed robots.

TreeDeviceCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

TreeDevicePtr 
Ptr stores a pointer and optionally takes ownership of the value.

TreeDevicePtrVector 

TreeState 
The tree structure state of a work cell.
The tree structure state gives access to the parent and child frames of a
frame.
Currently modification of the tree structure is not supported.

TriangleD 

TriangleF 

TriMesh 

TriMeshPtr 
Ptr stores a pointer and optionally takes ownership of the value.

UniversalJoint 
A universal joint that allows rotations in two directions.
Rotation is allowed around the x and y axes.

UniversalJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

Vector2Dd 
A 2D vector \mathbf{v}\in \mathbb{R}^2
\robabx{i}{j}{\mathbf{v}} = \left[
\begin{array}{c}
v_x \\
v_y
\end{array}
\right]
In addition, Vector2D supports the cross product operator:
v3 = cross(v1, v2)
Usage example:
using namespace rw::math;
Vector2Ddouble v1(1.0, 2.0);
Vector2Ddouble v2(6.0, 7.0);
Vector2Ddouble v3 = cross( v1, v2 );
Vector2Ddouble v4 = v2  v1;

Vector2DdVector 

Vector2Df 
A 2D vector \mathbf{v}\in \mathbb{R}^2
\robabx{i}{j}{\mathbf{v}} = \left[
\begin{array}{c}
v_x \\
v_y
\end{array}
\right]
In addition, Vector2D supports the cross product operator:
v3 = cross(v1, v2)
Usage example:
using namespace rw::math;
Vector2Ddouble v1(1.0, 2.0);
Vector2Ddouble v2(6.0, 7.0);
Vector2Ddouble v3 = cross( v1, v2 );
Vector2Ddouble v4 = v2  v1;

Vector3Dd 
A 3D vector \mathbf{v}\in \mathbb{R}^3
\robabx{i}{j}{\mathbf{v}} = \left[
\begin{array}{c}
v_x \\
v_y \\
v_z
\end{array}
\right]
Usage example:
const Vector3Ddouble v1(1.0, 2.0, 3.0);
const Vector3Ddouble v2(6.0, 7.0, 8.0);
const Vector3Ddouble v3 = cross(v1, v2);
const double d = dot(v1, v2);
const Vector3Ddouble v4 = v2  v1;

Vector3DdVector 

Vector3Df 
A 3D vector \mathbf{v}\in \mathbb{R}^3
\robabx{i}{j}{\mathbf{v}} = \left[
\begin{array}{c}
v_x \\
v_y \\
v_z
\end{array}
\right]
Usage example:
const Vector3Ddouble v1(1.0, 2.0, 3.0);
const Vector3Ddouble v2(6.0, 7.0, 8.0);
const Vector3Ddouble v3 = cross(v1, v2);
const double d = dot(v1, v2);
const Vector3Ddouble v4 = v2  v1;

Vector3DfVector 

VectorContact3D 

VectorEAAd 

VectorEigenMatrix3d 

VectorEigenMatrix3f 

VectorEigenMatrix3id 

VectorEigenRowVector3d 

VectorEigenRowVector3f 

VectorEigenVector3d 

VectorEigenVector3f 

VectorEigenVector3id 

VectorFixedFrame 

VectorPose6Dd 

VectorQuaterniond 

VectorRotation3D 

VectorSensorModelPtr 

VectorStateDataPtr 

VectorTransform3Dd 

VectorTransform3DVectord 

VectorTransform3DVectorf 

VectorVectorFrame 

VectorVelocityScrew6d 

VectorWrench6Dd 

VelocityScrew6Dd 
Class for representing 6 degrees of freedom velocity screws.
\mathbf{\nu} =
\left[
\begin{array}{c}
v_x\\
v_y\\
v_z\\
\omega_x\\
\omega_y\\
\omega_z
\end{array}
\right]
A VelocityScrew is the description of a frames linear and rotational velocity
with respect to some reference frame.

VelocityScrew6Df 
Class for representing 6 degrees of freedom velocity screws.
\mathbf{\nu} =
\left[
\begin{array}{c}
v_x\\
v_y\\
v_z\\
\omega_x\\
\omega_y\\
\omega_z
\end{array}
\right]
A VelocityScrew is the description of a frames linear and rotational velocity
with respect to some reference frame.

VirtualJoint 
Virtuals joints.
VirtualJoint is a joint with a role similar to a rw::kinematics::FixedFrame with
an optional number of dof allocated in the state.
Virtual joints are useful when you want a store joint values of e.g.
a number of passive joints.

VirtualJointPtr 
Ptr stores a pointer and optionally takes ownership of the value.

WorkCell 
WorkCell keeps track of devices, obstacles and objects in the
scene.
WorkCell is a pretty dumb container to which you can add your devices and
the frames you your GUI to show as objects or camera views.
WorkCell is responsible for keeping track of everything including all
devices, object and obstacles in the environment.

WorkCellChangedEvent 
Event is used for managing subscribtions and firing of events.
Event is used for managing subscribtions and firing of events.

WorkCellCPtr 
Ptr stores a pointer and optionally takes ownership of the value.

WorkCellLoader 
Extendible interface for loading of WorkCells from files.
By default, the following formats are supported:
 File extensions ".wu", ".wc", ".tag", ".dev" will be loaded using
the TULLoader.
 Remaining file extensions will be loaded using the standard RobWork
XML format (XMLRWLoader).
The Factory defines an extension point "rw.loaders.WorkCellLoader"
that makes it possible to add loaders for other file formats than the
ones above.

WorkCellLoaderFactory 
A factory for WorkCellLoader.

WorkCellLoaderPtr 
Ptr stores a pointer and optionally takes ownership of the value.

WorkCellPtr 
Ptr stores a pointer and optionally takes ownership of the value.

WorkCellScene 

WorkCellScenePtr 
Ptr stores a pointer and optionally takes ownership of the value.

Wrench6Dd 
Class for representing 6 degrees of freedom wrenches.
\mathbf{\nu} =
\left[
\begin{array}{c}
f_x\\
f_y\\
f_z\\
\tau_x\\
\tau_y\\
\tau_z
\end{array}
\right]
A Wrench is the description of a frames linear force and rotational torque
with respect to some reference frame.

Wrench6Df 
Class for representing 6 degrees of freedom wrenches.
\mathbf{\nu} =
\left[
\begin{array}{c}
f_x\\
f_y\\
f_z\\
\tau_x\\
\tau_y\\
\tau_z
\end{array}
\right]
A Wrench is the description of a frames linear force and rotational torque
with respect to some reference frame.
