RobWorkProject
Typedefs | Functions

Define helper functions and all the classes that are being wrapped by SWIG. The wrapped classes are defined as typedefs of other classes in RobWork. More...

Typedefs

typedef rw::RobWork RobWork
 RobWork instance which holds objects to be shared among multiple plugins. More...
 

Functions

void writelog (const std::string &msg)
 Write message to log. More...
 
void setlog (::rw::common::LogWriter::Ptr writer)
 Set the writer to write log to. More...
 
template<typename T >
std::string toString (const T &x)
 Convert an entity to string. More...
 
template<typename T >
char * printCString (const std::vector< T > &x)
 Convert a vector of entities to a C string. More...
 
template<typename T >
char * printCString (const T &x)
 Convert an entity to a C string. More...
 
Rotation3d getRandomRotation3D ()
 Math helper function to obtain random rotation. More...
 
Transform3d getRandomTransform3D (const double translationLength=1)
 Math helper function to obtain random transform. More...
 

common

Wrapped classes in common.

typedef rw::common::PropertyMap PropertyMap
 Container for a collection of Property Objects. More...
 
typedef rw::common::ThreadPool ThreadPool
 A thread pool that can be assigned work. More...
 
typedef rw::common::ThreadTask ThreadTask
 A task that facilitates the use of a hierarchic tree of tasks and subtasks. More...
 
typedef rw::common::Plugin Plugin
 an interface for defining dynamically loadable plugins that define extensions and extension points. More...
 
typedef rw::common::Extension Extension
 The Extension class is used to provide additonal functionality from a Plugin to other extension points of either the system or other plugins. More...
 
typedef rw::common::Extension::Descriptor ExtensionDescriptor
 An extension descriptor. More...
 
typedef rw::common::ExtensionRegistry ExtensionRegistry
 an extension point is a class that defines a point where Extension can be added. This is typically used together with plugins, however any class may register extensions to an extension point. More...
 

geometry

Wrapped classes in geometry.

typedef rw::geometry::GeometryData GeometryData
 an interface for geometry data. More...
 
typedef rw::geometry::GeometryData::GeometryType GeometryType
 geometry data types More...
 
typedef rw::geometry::Primitive Primitive
 defines an interface for a geometric shape that is defined by a set of parameters. More...
 
typedef rw::geometry::Box Box
 a box primitive, origin is in center of box More...
 
typedef rw::geometry::Cone Cone
 cone primitive. Like a cylinder though where a radius can be specified for both ends. More...
 
typedef rw::geometry::Sphere Sphere
 a sphere primitive. centr in (0,0,0) and a radius. More...
 
typedef rw::geometry::Plane Plane
 plane primitive represented in Hessian normal-form: a*nx+b*ny+c*nz+d=0 More...
 
typedef rw::geometry::Cylinder Cylinder
 a cylinder primitive. By default the radius is in the x-y plane and height is along the z-axis More...
 
typedef rw::geometry::Triangle< double > Triangle
 plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise. More...
 
typedef rw::geometry::Triangle< float > Trianglef
 plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise. More...
 
typedef rw::geometry::TriangleN1< double > TriangleN1
 Triangle facet. triangle class of type N1, which means that beside the plain triangle the face normal of the triangle is saved with the facenormal. More...
 
typedef rw::geometry::TriangleN1< float > TriangleN1f
 Triangle facet. triangle class of type N1, which means that beside the plain triangle the face normal of the triangle is saved with the facenormal. More...
 
typedef rw::geometry::TriMesh TriMesh
 interface of a triangle mesh. The interface defines a way to get triangles from a triangle array/mesh. More...
 
typedef rw::geometry::PlainTriMesh< TrianglePlainTriMesh
 a triangle mesh representation that maintains a list of simple triangles. More...
 
typedef rw::geometry::PlainTriMesh< TrianglefPlainTriMeshf
 a triangle mesh representation that maintains a list of simple triangles. More...
 
typedef rw::geometry::PlainTriMesh< TriangleN1PlainTriMeshN1
 a triangle mesh representation that maintains a list of simple triangles. More...
 
typedef rw::geometry::PlainTriMesh< TriangleN1fPlainTriMeshN1f
 a triangle mesh representation that maintains a list of simple triangles. More...
 
typedef rw::geometry::ConvexHull3D ConvexHull3D
 interface for convexhull calculators on 3d point sets More...
 
typedef rw::geometry::Geometry Geometry
 a class for representing a geometry that is scaled and transformed, and which is attached to a frame. More...
 
typedef rw::geometry::PointCloud PointCloud
 A simple point cloud data structure. Points may be ordered or not. An ordered set is kept as a single array in row major order and with a width and a height. An unordered array must have height==1 and width equal to the number of points. More...
 

graphics

Wrapped classes in graphics.

typedef rw::graphics::Model3D Model3D
 a 3d model that has geometry but also material, color and texture information. the model can be composed of multiple objects that are connected in a hierarchical manner. The model is designed for efficient drawing and as such special structures are used to order the indexes such that efficient drawing is possible. More...
 
typedef rw::graphics::Model3D::Material Model3DMaterial
 describes material properties. A material can be either simple or "advanced" and in both cases it can be textured. A simple material is described by a 4-tuple of RGBA values. The advanced material defines multiple properties: diffuse, ambient, emissive, specular, shininess and transparency More...
 
typedef rw::graphics::WorkCellScene WorkCellScene
 class for wrapping the SceneGraph interface such that it extends the scene-graph functionality to work on frames and workcells. More...
 
typedef rw::graphics::SceneViewer SceneViewer
 interface for viewing a scene graph. More...
 
typedef rw::graphics::SceneNode SceneNode
 a node that can have leafs (DrawableNode) or other nodes as children. More...
 
typedef rw::graphics::DrawableNode DrawableNode
 Abstract base class for all drawable classes. More...
 

invkin

Wrapped classes in invkin.

typedef rw::invkin::InvKinSolver InvKinSolver
 Interface for inverse kinematics algorithms. More...
 
typedef rw::invkin::IterativeIK IterativeIK
 Interface for iterative inverse kinematics algorithms. More...
 
typedef rw::invkin::JacobianIKSolver JacobianIKSolver
 A Jacobian based iterative inverse kinematics algorithm for devices with a single end effector. More...
 
typedef rw::invkin::IterativeMultiIK IterativeMultiIK
 Interface for iterative inverse kinematics algorithms for problems or devices that utilize more than one end-effector. More...
 
typedef rw::invkin::JacobianIKSolverM JacobianIKSolverM
 A Jacobian based iterative inverse kinematics algorithm for devices with multiple end effectors. More...
 
typedef rw::invkin::IKMetaSolver IKMetaSolver
 Solve the inverse kinematics problem with respect to joint limits and collisions. More...
 
typedef rw::invkin::ClosedFormIK ClosedFormIK
 Interface for closed form inverse kinematics algorithms. More...
 
typedef rw::invkin::PieperSolver PieperSolver
 Calculates the closed form inverse kinematics of a device using Piepers method. More...
 

kinematics

Wrapped classes in kinematics.

typedef rw::kinematics::StateData StateData
 the basic building block for the stateless design using the StateStructure class. A StateData represents a size, a unique id, and a unique name, when inserted into the StateStructure. The size will allocate "size"-doubles in State objects originating from the StateStructure. More...
 
typedef rw::kinematics::Frame Frame
 The type of node of forward kinematic trees. More...
 
typedef rw::kinematics::MovableFrame MovableFrame
 MovableFrame is a frame for which it is possible to freely change the transform relative to the parent. More...
 
typedef rw::kinematics::FixedFrame FixedFrame
 FixedFrame is a frame for which the transform relative to the parent is constant. More...
 
typedef rw::kinematics::State State
 The state of a work cell (or kinematics tree). More...
 
typedef rw::kinematics::StateStructure StateStructure
 the StateStructure is responsible for handling a structure of StateData and Frames More...
 

loaders

Wrapped classes in loaders.

typedef rw::loaders::ImageLoader ImageLoader
 Image loader interface. More...
 
typedef rw::loaders::ImageLoader::Factory ImageLoaderFactory
 a factory for ImageLoader. This factory also defines an extension point for image loaders. More...
 
typedef rw::loaders::WorkCellLoader WorkCellLoader
 Defines an interface. More...
 
typedef rw::loaders::WorkCellLoader::Factory WorkCellLoaderFactory
 a factory for WorkCellLoader. This factory also defines an extension point for workcell loaders. More...
 
typedef rw::loaders::STLFile STLFile
 static methods for reading and writing geometry to and from STL files. More...
 

math

Wrapped classes in math.

typedef rw::math::Vector2D< double > Vector2d
 A 2D vector $ \mathbf{v}\in \mathbb{R}^2 $. More...
 
typedef rw::math::Vector2D< float > Vector2f
 A 2D vector $ \mathbf{v}\in \mathbb{R}^2 $. More...
 
typedef rw::math::Vector3D< double > Vector3d
 A 3D vector $ \mathbf{v}\in \mathbb{R}^3 $. More...
 
typedef rw::math::Vector3D< float > Vector3f
 A 3D vector $ \mathbf{v}\in \mathbb{R}^3 $. More...
 
typedef rw::math::Rotation3D< double > Rotation3d
 A 3x3 rotation matrix $ \mathbf{R}\in SO(3) $. More...
 
typedef rw::math::Rotation3D< float > Rotation3f
 A 3x3 rotation matrix $ \mathbf{R}\in SO(3) $. More...
 
typedef rw::math::EAA< double > EAAd
 A class for representing an equivalent angle-axis rotation. More...
 
typedef rw::math::EAA< float > EAAf
 A class for representing an equivalent angle-axis rotation. More...
 
typedef rw::math::RPY< double > RPYd
 A class for representing Roll-Pitch-Yaw Euler angle rotations. More...
 
typedef rw::math::RPY< float > RPYf
 A class for representing Roll-Pitch-Yaw Euler angle rotations. More...
 
typedef rw::math::Quaternion< double > Quaterniond
 A Quaternion $ \mathbf{q}\in \mathbb{R}^4 $ a complex number used to describe rotations in 3-dimensional space. $ q_w+{\bf i}\ q_x+ {\bf j} q_y+ {\bf k}\ q_z $. More...
 
typedef rw::math::Quaternion< float > Quaternionf
 A Quaternion $ \mathbf{q}\in \mathbb{R}^4 $ a complex number used to describe rotations in 3-dimensional space. $ q_w+{\bf i}\ q_x+ {\bf j} q_y+ {\bf k}\ q_z $. More...
 
typedef rw::math::Transform3D< double > Transform3d
 A 4x4 homogeneous transform matrix $ \mathbf{T}\in SE(3) $. More...
 
typedef rw::math::Transform3D< float > Transform3f
 A 4x4 homogeneous transform matrix $ \mathbf{T}\in SE(3) $. More...
 
typedef rw::math::Pose6D< double > Pose6d
 A Pose6D $ \mathbf{x}\in \mathbb{R}^6 $ describes a position and orientation in 3-dimensions. More...
 
typedef rw::math::Pose6D< float > Pose6f
 A Pose6D $ \mathbf{x}\in \mathbb{R}^6 $ describes a position and orientation in 3-dimensions. More...
 
typedef rw::math::VelocityScrew6D< double > Screw6d
 Class for representing 6 degrees of freedom velocity screws. More...
 
typedef rw::math::VelocityScrew6D< float > Screw6f
 Class for representing 6 degrees of freedom velocity screws. More...
 
typedef rw::math::Wrench6D< double > Wrench6d
 Class for representing 6 degrees of freedom wrenches. More...
 
typedef rw::math::Wrench6D< float > Wrench6f
 Class for representing 6 degrees of freedom wrenches. More...
 
typedef rw::math::InertiaMatrix< double > InertiaMatrixd
 A 3x3 inertia matrix. More...
 
typedef rw::math::InertiaMatrix< float > InertiaMatrixf
 A 3x3 inertia matrix. More...
 
typedef rw::math::Q Q
 Configuration vector. More...
 
typedef rw::math::Jacobian Jacobian
 A Jacobian class. A jacobian with m rows and n columns. More...
 
typedef rw::math::QMetric MetricQ
 Metrics on configurations. More...
 
typedef rw::math::Transform3DMetric MetricSE3
 Metric on Transdform3D. More...
 
typedef Eigen::MatrixXd Matrix
 Wrapping of an Eigen matrix.
 

models

Wrapped classes in models.

typedef rw::models::WorkCell WorkCell
 WorkCell keeps track of devices, obstacles and objects in the scene. More...
 
typedef rw::models::Joint Joint
 A Joint is a Frame with assignable values for position, velocity limits and acceleration limits. More...
 
typedef rw::models::RevoluteJoint RevoluteJoint
 Revolute joints. More...
 
typedef rw::models::PrismaticJoint PrismaticJoint
 Prismatic joints. More...
 
typedef rw::models::Object 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. More...
 
typedef rw::models::DeformableObject DeformableObject
 The deformable object is an object that contain a deformable mesh. Deformations are part of the state object and they are modeled/controlled through control nodes. each control node correspond to a vertice in the mesh. All vertices are described relative to the base frame of the object. More...
 
typedef rw::models::RigidObject RigidObject
 the RigidObject defines a physical object in the workcell that is rigid in the sence that the geometry does not change. The rigid object also have basic properties such as Inertia and mass. These are default 1.0 kg and inertia of solid sphere with mass 1.0kg and radius of 10cm. The center of mass defaults to origin of the base frame. More...
 
typedef rw::models::Device Device
 An abstract device class. More...
 
typedef rw::models::JointDevice JointDevice
 A device for a sequence of joints. More...
 
typedef rw::models::SerialDevice SerialDevice
 The device for a serial chain. More...
 
typedef rw::models::TreeDevice TreeDevice
 A tree structured device. More...
 
typedef rw::models::CompositeDevice CompositeDevice
 A device constructed from a sequence of devices. More...
 
typedef rw::models::ParallelDevice ParallelDevice
 This class defines the interface for Parallel devices. More...
 
typedef rw::models::DHParameterSet DHParameterSet
 Simple class to help represent a set of Denavit-Hartenberg parameters. More...
 

pathplanning

Wrapped classes in pathplanning.

typedef rw::pathplanning::QToQPlanner QToQPlanner
 Path planner interface. More...
 
typedef rw::pathplanning::QToTPlanner QToTPlanner
 Approach planner interface. More...
 
typedef rw::pathplanning::StopCriteria StopCriteria
 StopCriteria is a class for specifying an instant a compution should be aborted. More...
 
typedef rw::pathplanning::PlannerConstraint PlannerConstraint
 A tuple of (QConstraintPtr, QEdgeConstraintPtr). More...
 

proximity

Wrapped classes in proximity.

typedef rw::proximity::CollisionDetector CollisionDetector
 The CollisionDetector implements an efficient way of checking a complete frame tree for collisions. More...
 
typedef rw::proximity::CollisionStrategy CollisionStrategy
 An interface that defines methods to test collision between two objects. More...
 
typedef rw::proximity::DistanceCalculator DistanceCalculator
 The DistanceCalculator implements an efficient way of calculating different distances between two objects, each represented by a frame. More...
 
typedef rw::proximity::DistanceStrategy DistanceStrategy
 This is an interface that defines methods for computing the minimum distance between geometric objects. If geometry objects has been related to frames (see ProximityStrategy) then distance functions computing the distance between the geometry attached to frames can also be used. More...
 

sensor

Wrapped classes in sensor.

typedef rw::sensor::Image Image
 The image class is a simple wrapper around a char data array. This Image wrapper contain information of width, height and encoding. More...
 
typedef rw::sensor::Sensor Sensor
 a generel hardware sensor interface. The sensor should interface to a statefull instance of either a real world sensor or a simulated sensor. The sensor interface acts as a realistic handle to controlling some specific instance of a sensor. More...
 

assembly

Wrapped classes in assembly.

typedef rwlibs::assembly::AssemblyControlResponse AssemblyControlResponse
 The output from a AssemblyControlStrategy. More...
 
typedef rwlibs::assembly::AssemblyControlStrategy AssemblyControlStrategy
 The interface for control strategies for assembly. More...
 
typedef rwlibs::assembly::AssemblyParameterization AssemblyParameterization
 Interface for a parameterization that can be used by a AssemblyControlStrategy. More...
 
typedef rwlibs::assembly::AssemblyRegistry AssemblyRegistry
 A registry of control strategies. The registry defines an extension point. More...
 
typedef rwlibs::assembly::AssemblyResult AssemblyResult
 A specification of the result from an execution of an AssemblyTask. More...
 
typedef rwlibs::assembly::AssemblyState AssemblyState
 Information about the trajectory of the objects and sensor information during execution. More...
 
typedef rwlibs::assembly::AssemblyTask AssemblyTask
 Specification of a AssemblyTask. More...
 

trajectory

Wrapped classes in trajectory.

typedef rw::trajectory::Blend< QBlendQ
 Interface for blending. More...
 
typedef rw::trajectory::Blend< double > BlendR1
 Interface for blending. More...
 
typedef rw::trajectory::Blend< Vector2dBlendR2
 Interface for blending. More...
 
typedef rw::trajectory::Blend< Vector3dBlendR3
 Interface for blending. More...
 
typedef rw::trajectory::Blend< Rotation3dBlendSO3
 Interface for blending. More...
 
typedef rw::trajectory::Blend< Transform3dBlendSE3
 Interface for blending. More...
 
typedef rw::trajectory::TimedState TimedState
 A tuple of (time, State). See rw::trajectory::Timed<t> template for more info. More...
 
typedef rw::trajectory::Path< QPathQ
 
typedef rw::trajectory::TimedStatePath PathTimedState
 Path of rw::kinematics::State with associated times. More...
 
typedef rw::trajectory::Trajectory< StateTrajectoryState
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< QTrajectoryQ
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< double > TrajectoryR1
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< Vector2dTrajectoryR2
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< Vector3dTrajectoryR3
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< Rotation3dTrajectorySO3
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::Trajectory< Transform3dTrajectorySE3
 Interface for Trajectories in RobWork. More...
 
typedef rw::trajectory::LinearInterpolator< double > LinearInterpolator
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::LinearInterpolator< rw::math::QLinearInterpolatorQ
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::LinearInterpolator< Vector2dLinearInterpolatorR2
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::LinearInterpolator< rw::math::Rotation3D< double > > LinearInterpolatorR3
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::LinearInterpolator< rw::math::Rotation3D< double > > LinearInterpolatorSO3
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::LinearInterpolator< rw::math::Transform3D< double > > LinearInterpolatorSE3
 Make a linear interpolation between to position. More...
 
typedef rw::trajectory::RampInterpolator< double > RampInterpolator
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::RampInterpolator< rw::math::QRampInterpolatorQ
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::RampInterpolator< Vector2dRampInterpolatorR2
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::RampInterpolator< Vector3dRampInterpolatorR3
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::RampInterpolator< rw::math::Rotation3D< double > > RampInterpolatorSO3
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::RampInterpolator< rw::math::Transform3D< double > > RampInterpolatorSE3
 Make a ramp interpolation between two position. More...
 
typedef rw::trajectory::Timed< AssemblyStateTimedAssemblyState
 A tuple of (time, value). More...
 
typedef rw::trajectory::Path< rw::trajectory::Timed< AssemblyState > > PathTimedAssemblyState
 

control

Wrapped classes in control.

typedef rwlibs::control::Controller Controller
 interface that defines functionality for control of devices and actuators More...
 
typedef rwlibs::control::JointController JointController
 the joint controller interface describe how to input to a joint controller. The output Force, Vel, Pos... must be available in the class implementing JointController interface More...
 

pathoptimization

Wrapped classes in pathoptimization.

typedef rwlibs::pathoptimization::PathLengthOptimizer PathLengthOptimizer
 The PathLengthOptimizer implements the 3 different path length optimizers presented in [1]. More...
 
typedef rwlibs::pathoptimization::ClearanceOptimizer ClearanceOptimizer
 The ClearanceOptimizer implements the C-Retraction algorithms from [1]. More...
 

simulation

Wrapped classes in simulation.

typedef rwlibs::simulation::SimulatedController SimulatedController
 interface of a simulated controller More...
 
typedef rwlibs::simulation::SimulatedSensor SimulatedSensor
 simulated sensor interface More...
 
typedef rwlibs::simulation::Simulator Simulator
 interface of a general simulator More...
 
typedef rwlibs::simulation::Simulator::UpdateInfo UpdateInfo
 step info is used when updating controllers, devices and bodies. More...
 

task

Wrapped classes in task.

typedef rwlibs::task::Task< rw::math::Transform3D< double > > TaskSE3
 Template based implementation of Task. More...
 
typedef rwlibs::task::GraspTask GraspTask
 A container for describing one or multiple grasping tasks. It is based on the rwlibs::tasks library. More...
 
typedef rwlibs::task::GraspSubTask GraspSubTask
 Describes a sub task of overall grasp task. More...
 
typedef rwlibs::task::GraspTarget GraspTarget
 Represents a single target for grasping (described as a pose), and its result. More...
 
typedef rwlibs::task::GraspResult GraspResult
 Describes the result of a single grasp. More...
 

Detailed Description

Define helper functions and all the classes that are being wrapped by SWIG. The wrapped classes are defined as typedefs of other classes in RobWork.

SWIG generated interface for Robwork. The supported generated interface languages are: Lua, Python and Java.

The SWIG interface to RobWork is very similar to the RobWork c++ interface. However, due to limitations in other languages, then the interfaces cannot match the c++ interface exactly. Class's in this module are documented as c++ classes with c++ functions, but they really only define the classes and functions that was wrapped and available through SWIG.

Typedef Documentation

◆ AssemblyControlResponse

The output from a AssemblyControlStrategy.

◆ AssemblyControlStrategy

The interface for control strategies for assembly.

The control strategy must implement the getApproach(), update(), createParameterization(), getID() and getDescription() methods.

The createState() can be overriden if the user wants to save specific strategy state between calls to update().

◆ AssemblyParameterization

Interface for a parameterization that can be used by a AssemblyControlStrategy.

Each AssemblyControlStrategy will typically derive its own AssemblyParameterization that includes the parameters necessary to specify the assembly operation when using that specific strategy.

By deriving from this class, the parameterization can be stored and restored via a PropertyMap structure. This is mainly used as a way to extend the assembly assembly specification with additional data, while maintaining the ability to serialize, load and save the AssemblyTask. Derived classes should override the clone(), make(), reset() and toPropertyMap() functions.

Notice that this is also a concrete class, allowing the user to create a parameterization that is always empty, or create a parameterization based on a custom PropertyMap. The latter is especially useful if scripting interfaces are used, where subclassing is not possible.

◆ AssemblyRegistry

A registry of control strategies. The registry defines an extension point.

Users can define custom assembly control strategies in two ways. Either an extension must be registered, or the user must create an AssemblyRegistry and add the strategy to this registry manually.

◆ AssemblyResult

A specification of the result from an execution of an AssemblyTask.

The class provides serialization through the CartesianTask format.

◆ AssemblyState

Information about the trajectory of the objects and sensor information during execution.

This information is serializable through the CartesianTarget format.

◆ AssemblyTask

Specification of a AssemblyTask.

Assembly task is a generic description that covers all tasks where two objects are to be assembled. This can for instance be Peg in Hole or screwing operations.

The class supports serialization through the CartesianTask format. For deserialization an AssemblyRegistry should be provided when loading the AssemblyTask. This is required if user specifies its own AssemblyControlStrategy.

◆ BlendQ

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ BlendR1

typedef rw::trajectory::Blend<double> BlendR1

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ BlendR2

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ BlendR3

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ BlendSE3

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ BlendSO3

Interface for blending.

A Blend describes a way to blend between to consecutive interpolators. If we let $t_1$ be the time switching from one interpolator to the next, then the blend control the path in the interval $[t_1-\tau_1;t_1+\tau_2]$.

See the specific implementations for at description of which template arguments that are valid.

◆ Box

a box primitive, origin is in center of box

◆ ClearanceOptimizer

The ClearanceOptimizer implements the C-Retraction algorithms from [1].

[1]: R. Geraerts and M.H. Overmars, Creating High-Quality Paths for Motion Planning, The International Journal of Robotics Research, Vol. 26, No. 8, 845-863 (2007)

The algorithms work by first subdividing the path, to give a dense and even distribution of nodes along the path. Nodes are then tried moved in a random direction to improve the clearance. After having iterated through the entire path some nodes will be moved, thus a validation step is used to insert extra nodes where the density is not high enough. This is then followed by a method for removing undesired branches.

◆ ClosedFormIK

Interface for closed form inverse kinematics algorithms.

The ClosedFormIK interface provides an interface for calculating the inverse kinematics of a device. That is to calculate the solutions $\mathbf{q}_i, i=0,\ldots,$, such that $\robabx{base}{end}{\mathbf{T}}(\mathbf{q}_i)= \robabx{}{desired}{\mathbf{T}}$.

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.

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

◆ CollisionStrategy

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

◆ 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 straight-forward way of JointDevice. The notable exception is Device::setQ() which is implemented by forwarding the Device::setQ() calls to the sequence of devices. This means that CompositeDevice works also for example for devices of type ParallelDevice that have an overwritten implementation of Device::setQ().

The devices from which the composite device is constructed must all be of type JointDevice. An exception is thrown by the constructor if one of the devices is not of this subtype.

The computation of Jacobians of CompositeDevice is not correct in general, but is correct only for devices for which the standard technique of JointDevice is correct. We cannot in general in RobWork do any better currently. The implementation does not check if the requirements for the computation of Jacobians are indeed satisfied.

CompositeDevice is related to TreeDevice in the sense that CompositeDevice has also multiple end-effectors (one end-effector for each device). CompositeDevice differs from TreeDevice by not requiring that the child-to-parent paths of the end-effectors connect to a common base.

◆ Cone

cone primitive. Like a cylinder though where a radius can be specified for both ends.

The cone is aligned with the z-axis such that top is in the positive z-axis and the bottom is in the negative z-axis. The center of the cone will be in (0,0,0) which is inside the cone.

◆ Controller

interface that defines functionality for control of devices and actuators

◆ ConvexHull3D

interface for convexhull calculators on 3d point sets

◆ Cylinder

a cylinder primitive. By default the radius is in the x-y plane and height is along the z-axis

◆ DeformableObject

The deformable object is an object that contain a deformable mesh. Deformations are part of the state object and they are modeled/controlled through control nodes. each control node correspond to a vertice in the mesh. All vertices are described relative to the base frame of the object.

◆ Device

An abstract device class.

The Device class is the basis for all other devices. It is assumed that all devices have a configuration which can be encoded by a rw::math::Q, that all have a base frame representing where in the work cell they are located and a primary end frame. Notice that some devices may have multiple end-frames.

◆ DHParameterSet

Simple class to help represent a set of Denavit-Hartenberg parameters.

◆ 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

◆ DistanceStrategy

This is an interface that defines methods for computing the minimum distance between geometric objects. If geometry objects has been related to frames (see ProximityStrategy) then distance functions computing the distance between the geometry attached to frames can also be used.

◆ DrawableNode

Abstract base class for all drawable classes.

Classes that are able to draw them self, may inherit from this class.

The drawable class use a draw mask to distinguish between different groups to draw. E.g. when taking snapshots with a simulated camera virtual objects such as the red laser vector or the lines showing the camera view angle is should not be rendered. Hence objects that are virtual should be set to virtual.

A call to draw enabling Physical and User1 defined objects look like:

drawable->draw(DrawableNode::Physical | DrawableNode::User1);

◆ EAAd

typedef rw::math::EAA<double> EAAd

A class for representing an equivalent angle-axis rotation.

This class defines an equivalent-axis-angle orientation vector also known as an $ \thetak $ vector or "axis+angle" vector

The equivalent-axis-angle 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

typedef rw::math::EAA<float> EAAf

A class for representing an equivalent angle-axis rotation.

This class defines an equivalent-axis-angle orientation vector also known as an $ \thetak $ vector or "axis+angle" vector

The equivalent-axis-angle 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

◆ Extension

The Extension class is used to provide additonal functionality from a Plugin to other extension points of either the system or other plugins.

Extension points in RobWork:

rw.common.DOMParser (rw::common::DOMParser::Factory): for extensions of type rw::common::DOMParser

rw.loaders.ImageLoader (rw::loaders::ImageLoader::Factory): for extensions of type rw::loaders::ImageLoader

rw.loaders.Model3DLoader (rw::loaders::Model3DLoader::Factory): for extensions of type rw::loaders::Model3DLoader

% rw.loaders.WorkCellLoader (rw::loaders::WorkCellLoader::Factory): for extensions of type rw::loaders::WorkCellLoader

rw::pathplanning::QToTPlanner (rw::pathplanning::QToTPlanner::Factory): for extensions of type rw::pathplanning::QToTPlanner

rw.proximity.CollisionStrategy (rw::proximity::CollisionStrategy::Factory): for extensions of type rw::proximity::CollisionStrategy

rw.proximity.CollisionToleranceStrategy (rw::proximity::CollisionToleranceStrategy::Factory): for extensions of type rw::proximity::CollisionToleranceStrategy

rw.proximity.DistanceMultiStrategy (rw::proximity::DistanceMultiStrategy::Factory): for extensions of type rw::proximity::DistanceMultiStrategy

rw.proximity.DistanceStrategy (rw::proximity::DistanceStrategy::Factory): for extensions of type rw::proximity::DistanceStrategy

rw.proximity.ProximityStrategy (rw::proximity::ProximityStrategy::Factory): for extensions of type rw::proximity::ProximityStrategy

rwlibs.assembly.AssemblyControlStrategy (rwlibs::assembly::AssemblyRegistry): for extensions of type rwlibs::assembly::AssemblyControlStrategy

rwlibs.swig.LuaState.LuaLibrary (rwlibs::swig::LuaState::Factory): for extensions of type rwlibs::swig::LuaState::LuaLibrary

% rwlibs.task.TaskLoader (rwlibs::task::TaskLoader::Factory): for extensions of type rwlibs::task::TaskLoader

% rwlibs.task.TaskSaver (rwlibs::task::TaskSaver::Factory): for extensions of type rwlibs::task::TaskSaver

rwsim.log.SimulatorLogEntry (rwsim::log::SimulatorLogEntry::Factory): for extensions of type rwsim::log::SimulatorLogEntry

rwsim.simulator.PhysicsEngine (rwsim::simulator::PhysicsEngine::Factory): for extensions of type rwsim::simulator::PhysicsEngine::Dispatcher

rwsimlibs.gui.SimulatorLogEntryWidget (rwsimlibs::gui::SimulatorLogEntryWidget::Factory): for extensions of type rwsimlibs::gui::SimulatorLogEntryWidget::Dispatcher

rwsimlibs.rwpe.RWPECollisionSolver (rwsimlibs::rwpe::RWPECollisionSolver::Factory): for extensions of type rwsimlibs::rwpe::RWPECollisionSolver

rwsimlibs.rwpe.RWPEConstraintSolver (rwsimlibs::rwpe::RWPEConstraintSolver::Factory): for extensions of type rwsimlibs::rwpe::RWPEConstraintSolver

rwsimlibs.rwpe.RWPEContactResolver (rwsimlibs::rwpe::RWPEContactResolver::Factory): for extensions of type rwsimlibs::rwpe::RWPEContactResolver

rwsimlibs.rwpe.RWPEFrictionModel (rwsimlibs::rwpe::RWPEFrictionModel::Factory): for extensions of type rwsimlibs::rwpe::RWPEFrictionModel

rwsimlibs.rwpe.RWPEIntegrator (rwsimlibs::rwpe::RWPEIntegrator::Factory): for extensions of type rwsimlibs::rwpe::RWPEIntegrator

rwsimlibs.rwpe.RWPERestitutionModel (rwsimlibs::rwpe::RWPERestitutionModel::Factory): for extensions of type rwsimlibs::rwpe::RWPERestitutionModel

rwsimlibs.rwpe.RWPERollbackMethod (rwsimlibs::rwpe::RWPERollbackMethod::Factory): for extensions of type rwsimlibs::rwpe::RWPERollbackMethod

rwsimlibs.test.EngineTest (rwsimlibs::test::EngineTest::Factory): for extensions of type rwsimlibs::test::EngineTest

◆ ExtensionDescriptor

An extension descriptor.

The descriptor holds meta-data for an extension, and makes it possible to do lazy-loading of plugins.

◆ ExtensionRegistry

an extension point is a class that defines a point where Extension can be added. This is typically used together with plugins, however any class may register extensions to an extension point.

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

◆ Frame

The type of node of forward kinematic trees.

Types of joints are implemented as subclasses of Frame. The responsibility of a joint is to implement the getTransform() method that returns the transform of the frame relative to whatever parent it is attached to.

The getTransform() method takes as parameter the set of joint values State for the tree. Joint values for a particular frame can be accessed via State::getQ(). A frame may contain pointers to other frames so that the transform of a frame may depend on the joint values for other frames also.

◆ Geometry

a class for representing a geometry that is scaled and transformed, and which is attached to a frame.

Each geometry must have a unique ID. This is either auto generated or specified by user. The ids are used in collision detection and other algorithms where the object need an association other than its memory address.

◆ GeometryData

an interface for geometry data.

◆ GeometryType

geometry data types

◆ GraspResult

Describes the result of a single grasp.

◆ GraspSubTask

Describes a sub task of overall grasp task.

It is concerned with a specific way of grasping a single target object, describing:

  • target object name,
  • gripper open and close configurations,
  • approach and retract vectors

◆ GraspTarget

Represents a single target for grasping (described as a pose), and its result.

◆ GraspTask

A container for describing one or multiple grasping tasks. It is based on the rwlibs::tasks library.

Definition of GraspTask xml format

GraspTask

  • p:string:"GripperName" - name of the gripper device
  • p:string:"ControllerName" - defaults to GraspController
  • p:string:"TCP" - name of the TCP frame

◆ 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. It repeatingly calls the iterative solver with new random start configurations until either a solution is found or a specified max attempts has been reached.

Usage example:

// create a inverse kinematics solver for your dvs. here we use ResolvedRateSolver
ResolvedRateSolver iksolver(&myDevice); // takes a pointer to your device
// if we want colision free ik results then create or get the collisiondetector
CollisionDetector *detector = NULL; // here we don't care about collisions
// now create the meta solver
IKMetaSolver mSolver(&iksolver, &myDevice, detector);
// the pose that you want the endeffector to be in
Transform3D<> pose(Vector3D<>(0,0,1),RPY<>(1,0,0));
// and use it to generate joint configurations
std::vector<Q> result;
result = mSolver.solve( pose , state, 200, true );

◆ 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 top-left position, where from X increases to the left and Y-increases 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.

◆ ImageLoader

Image loader interface.

◆ ImageLoaderFactory

a factory for ImageLoader. This factory also defines an extension point for image loaders.

◆ InertiaMatrixd

A 3x3 inertia matrix.

◆ InertiaMatrixf

A 3x3 inertia matrix.

◆ InvKinSolver

Interface for inverse kinematics algorithms.

The InvKinSolver interface provides an interface for calculating the inverse kinematics of a device. That is to calculate $\mathbf{q}$ such that $\robabx{base}{end}{\mathbf{T}}(\mathbf{q})= \robabx{}{desired}{\mathbf{T}}$.

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.

◆ IterativeIK

Interface for iterative inverse kinematics algorithms.

The IterativeIK interface provides an interface for calculating the inverse kinematics of a device. That is to calculate $\mathbf{q}$ such that $\robabx{base}{end}{\mathbf{T}}(\mathbf{q})= \robabx{}{desired}{\mathbf{T}}$.

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.

◆ IterativeMultiIK

Interface for iterative inverse kinematics algorithms for problems or devices that utilize more than one end-effector.

The IterativeMultiIK interface provides an interface for calculating the inverse kinematics of a device with multiple end-effectors. That is to calculate $\mathbf{q}$ such that $\robabx{base}{end}{\mathbf{T}}(\mathbf{q})= \robabx{}{desired}{\mathbf{T}}$.

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.

◆ Jacobian

A Jacobian class. A jacobian with m rows and n columns.

An ordinary robot jacobian defined over the joints 0 to n with configuration q is expressed as a $ 6\times n $ matrix:

\[ \robabx{0}{n}{\bf{J}}(\bf{q}) = [ \robabx{0}{1}{\bf{J}}(\bf{q}), \robabx{1}{2}{\bf{J}}(\bf{q}),..., \robabx{n-1}{n}{\bf{J}}(\bf{q}) ] \]

◆ 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. If joint clamping is not enabled then this algorithm might contain joint values that are out of bounds.

The method uses an Newton-Raphson iterative approach and is based on using the inverse of the device Jacobian to compute each local solution in each iteration. Several methods for calculating/approximating the inverse Jacobian are available, where the SVD method currently is the most stable, see the JacobianSolverType option for additional options.

The method is based on the following approximation:

$ \Delta \mathbf{x}\approx \mathbf{J}(\mathbf{q})\Delta \mathbf{q} $

Where $ \Delta \mathbf{x} $ is calculated like:

$ \robabx{b}{e}{\mathbf{T}}(\mathbf{q}) = \robabx{b}{e}{\mathbf{T}}(\mathbf{q}_{init}+\Delta \mathbf{q}) \approx \robabx{b}{e}{\mathbf{T}}(\mathbf{q}_{init})\Delta \mathbf{T}(\Delta \mathbf{q}) = \robabx{b}{e*}{\mathbf{T}} $

$ \Delta \mathbf{T}(\Delta \mathbf{q}) = \robabx{j}{i}{\mathbf{T}}\robabx{b}{e*}{\mathbf{T}}=\mathbf{I}^{4x4}+\mathbf{L} $

$ \mathbf{L} = \left[ \begin{array}{cccc} 0 & -\omega_z & \omega_y & v_x \\ \omega_z & 0 & -\omega_x & v_y \\ -\omega_y & \omega_x & 0 & v_z \\ 0 & 0 & 0 & 0 \end{array} \right] $

◆ JacobianIKSolverM

A Jacobian based iterative inverse kinematics algorithm for devices with multiple end effectors.

This algorithm does not implicitly handle joint limits, however it is possible to force the solution within joint limits using clamping in each iterative step. If joint clamping is not enabled then this algorithm might contain joint values that are out of bounds.

The method uses an Newton-Raphson iterative approach and is based on using the inverse of the device Jacobian to compute each local solution in each iteration. Several methods for calculating/approximating the inverse Jacobian are available, where the SVD method currently is the most stable, see the JacobianSolverType option for additional options.

The method is based on the following approximation:

$ \Delta \mathbf{x}\approx \mathbf{J}(\mathbf{q})\Delta \mathbf{q} $

Where $ \Delta \mathbf{x} $ is calculated like:

$ \robabx{b}{e}{\mathbf{T}}(\mathbf{q}) = \robabx{b}{e}{\mathbf{T}}(\mathbf{q}_{init}+\Delta \mathbf{q}) \approx \robabx{b}{e}{\mathbf{T}}(\mathbf{q}_{init})\Delta \mathbf{T}(\Delta \mathbf{q}) = \robabx{b}{e*}{\mathbf{T}} $

$ \Delta \mathbf{T}(\Delta \mathbf{q}) = \robabx{j}{i}{\mathbf{T}}\robabx{b}{e*}{\mathbf{T}}=\mathbf{I}^{4x4}+\mathbf{L} $

$ \mathbf{L} = \left[ \begin{array}{cccc} 0 & -\omega_z & \omega_y & v_x \\ \omega_z & 0 & -\omega_x & v_y \\ -\omega_y & \omega_x & 0 & v_z \\ 0 & 0 & 0 & 0 \end{array} \right] $

◆ Joint

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

◆ JointController

the joint controller interface describe how to input to a joint controller. The output Force, Vel, Pos... must be available in the class implementing JointController interface

◆ 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. Subclasses typically differ in their implementation of setQ() and the Jacobian computation.

◆ LinearInterpolator

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

◆ 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

◆ LinearInterpolatorR2

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

◆ LinearInterpolatorR3

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

◆ LinearInterpolatorSE3

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

◆ LinearInterpolatorSO3

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

◆ MetricQ

Metrics on configurations.

◆ MetricSE3

Metric on Transdform3D.

◆ Model3D

a 3d model that has geometry but also material, color and texture information. the model can be composed of multiple objects that are connected in a hierarchical manner. The model is designed for efficient drawing and as such special structures are used to order the indexes such that efficient drawing is possible.

◆ Model3DMaterial

describes material properties. A material can be either simple or "advanced" and in both cases it can be textured. A simple material is described by a 4-tuple of RGBA values. The advanced material defines multiple properties: diffuse, ambient, emissive, specular, shininess and transparency

◆ 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. user input.

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

◆ ParallelDevice

This class defines the interface for Parallel devices.

◆ PathLengthOptimizer

The PathLengthOptimizer implements the 3 different path length optimizers presented in [1].

[1]: R. Geraerts and M.H. Overmars, Creating High-Quality Paths for Motion Planning, The International Journal of Robotics Research, Vol. 26, No. 8, 845-863 (2007)

The simplest algorithm pathPruning runs through the path an tests if nodes with index i and i+2 can be directly connected. If so it removed node i+1.

The shortCut algorithm works similary except that it takes two random indices i and j and tries to connect those. This algorithm is non-deterministic but more powerful than pathPruning.

The partialShortCut algorithm select two random node indices i and j and a random position in the configuration vector. A shortcut is then only tried between the values corresponding to the random position. This algorithm is generally more powerful than shortCut but may in some cases be more computational expensive.

◆ PathQ

◆ PathTimedAssemblyState

◆ PathTimedState

Path of rw::kinematics::State with associated times.

◆ 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. Craig for further information about the algorithm.

◆ PlainTriMesh

a triangle mesh representation that maintains a list of simple triangles.

This class is templated and can be setup with different types of triangle storage. Mainly this concerns single or double precision but also number of normals in each Triangle. Check out Triangle.hpp to get an idea of the different types.

The PlainTriMesh can be used as follows

// create trimesh
PlainTriMesh<TriangleN1<float> > mesh;
// add data
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
// and access the mesh
TriangleN1<float> tri_index1 = mesh[1];
Vector3D<float> normal = mesh[2].getFaceNormal();

To convert the plain trimesh to a more efficient mesh representation take a look at TriangleUtil::toIndexedTriMesh().

◆ PlainTriMeshf

a triangle mesh representation that maintains a list of simple triangles.

This class is templated and can be setup with different types of triangle storage. Mainly this concerns single or double precision but also number of normals in each Triangle. Check out Triangle.hpp to get an idea of the different types.

The PlainTriMesh can be used as follows

// create trimesh
PlainTriMesh<TriangleN1<float> > mesh;
// add data
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
// and access the mesh
TriangleN1<float> tri_index1 = mesh[1];
Vector3D<float> normal = mesh[2].getFaceNormal();

To convert the plain trimesh to a more efficient mesh representation take a look at TriangleUtil::toIndexedTriMesh().

◆ PlainTriMeshN1

a triangle mesh representation that maintains a list of simple triangles.

This class is templated and can be setup with different types of triangle storage. Mainly this concerns single or double precision but also number of normals in each Triangle. Check out Triangle.hpp to get an idea of the different types.

The PlainTriMesh can be used as follows

// create trimesh
PlainTriMesh<TriangleN1<float> > mesh;
// add data
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
// and access the mesh
TriangleN1<float> tri_index1 = mesh[1];
Vector3D<float> normal = mesh[2].getFaceNormal();

To convert the plain trimesh to a more efficient mesh representation take a look at TriangleUtil::toIndexedTriMesh().

◆ PlainTriMeshN1f

a triangle mesh representation that maintains a list of simple triangles.

This class is templated and can be setup with different types of triangle storage. Mainly this concerns single or double precision but also number of normals in each Triangle. Check out Triangle.hpp to get an idea of the different types.

The PlainTriMesh can be used as follows

// create trimesh
PlainTriMesh<TriangleN1<float> > mesh;
// add data
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
mesh.add( TriangleN1<float>(v1,v2,v3) );
// and access the mesh
TriangleN1<float> tri_index1 = mesh[1];
Vector3D<float> normal = mesh[2].getFaceNormal();

To convert the plain trimesh to a more efficient mesh representation take a look at TriangleUtil::toIndexedTriMesh().

◆ Plane

plane primitive represented in Hessian normal-form: a*nx+b*ny+c*nz+d=0

◆ PlannerConstraint

A tuple of (QConstraintPtr, QEdgeConstraintPtr).

A planner constraint is a small copyable object containing pointers to a configuration constraint and an edge constraint. Sampling based path planners and path optimizers typically use a PlannerConstraint object for the collision checking for the paths.

A number of make() utility constructors are provided for applications where defaults for configuration and edge constraints can be used.

◆ Plugin

an interface for defining dynamically loadable plugins that define extensions and extension points.

◆ PointCloud

A simple point cloud data structure. Points may be ordered or not. An ordered set is kept as a single array in row major order and with a width and a height. An unordered array must have height==1 and width equal to the number of points.

◆ Pose6d

typedef rw::math::Pose6D<double> Pose6d

A Pose6D $ \mathbf{x}\in \mathbb{R}^6 $ describes a position and orientation in 3-dimensions.

$ {\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.

◆ Pose6f

typedef rw::math::Pose6D<float> Pose6f

A Pose6D $ \mathbf{x}\in \mathbb{R}^6 $ describes a position and orientation in 3-dimensions.

$ {\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

defines an interface for a geometric shape that is defined by a set of parameters.

◆ PrismaticJoint

Prismatic joints.

PrismaticJoint implements a prismatic joint for the displacement in the direction of the z-axis of an arbitrary displacement transform.

◆ PropertyMap

Container for a collection of Property Objects.

This container is used to bind various user information to for example Frame.

Example: Getting a string property with ID "Camera" from a frame

const std::string* ptr = frame.getPropertyMap().getPtr<std::string>("Camera");
if (ptr) {
std::cout << "Property 'Camera' has value " << *ptr << "\n";
}

◆ Q

typedef rw::math::Q Q

Configuration vector.

◆ QToQPlanner

Path planner interface.

A path planner plans a path in the configuration space from a start configuration to a goal configuration.

◆ QToTPlanner

Approach planner interface.

An approach planner plans a path from a configuration for the device to a configuration for the tool.

◆ Quaterniond

A Quaternion $ \mathbf{q}\in \mathbb{R}^4 $ a complex number used to describe rotations in 3-dimensional 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. Though there are differences. Quaternion multiplication is not commutative which means $Q\cdot P \neq P\cdot Q $

◆ Quaternionf

A Quaternion $ \mathbf{q}\in \mathbb{R}^4 $ a complex number used to describe rotations in 3-dimensional 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. Though there are differences. Quaternion multiplication is not commutative which means $Q\cdot P \neq P\cdot Q $

◆ RampInterpolator

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

◆ 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

◆ RampInterpolatorR2

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

◆ RampInterpolatorR3

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

◆ RampInterpolatorSE3

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

◆ RampInterpolatorSO3

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

◆ RevoluteJoint

Revolute joints.

RevoluteJoint implements a revolute joint for the rotation about the z-axis of an arbitrary displacement transform.

◆ RigidObject

the RigidObject defines a physical object in the workcell that is rigid in the sence that the geometry does not change. The rigid object also have basic properties such as Inertia and mass. These are default 1.0 kg and inertia of solid sphere with mass 1.0kg and radius of 10cm. The center of mass defaults to origin of the base frame.

◆ RobWork

RobWork instance which holds objects to be shared among multiple plugins.

A RobWork instance contains common objects and configuration which may be used by multiple plugins which may originate from different shared libraries.

◆ Rotation3d

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] $

◆ Rotation3f

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] $

◆ RPYd

typedef rw::math::RPY<double> RPYd

A class for representing Roll-Pitch-Yaw Euler angle rotations.

◆ RPYf

typedef rw::math::RPY<float> RPYf

A class for representing Roll-Pitch-Yaw Euler angle rotations.

◆ SceneNode

a node that can have leafs (DrawableNode) or other nodes as children.

◆ SceneViewer

interface for viewing a scene graph.

The scene graph viewer

◆ Screw6d

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.

◆ Screw6f

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.

◆ Sensor

a generel hardware sensor interface. The sensor should interface to a statefull instance of either a real world sensor or a simulated sensor. The sensor interface acts as a realistic handle to controlling some specific instance of a sensor.

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

◆ SimulatedController

interface of a simulated controller

◆ SimulatedSensor

simulated sensor interface

◆ Simulator

interface of a general simulator

◆ Sphere

a sphere primitive. centr in (0,0,0) and a radius.

◆ 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. You are encouraged to use the getParent(), getChildren(), getQ() and setQ() utility functions rather than explicitly type, say, state.getQState().getQ(). That way you will have a much easier time of updating the code if we decide to change the way the kinematics data structures are stored (!). Also getQ(state, frame) is shorter to type also.

The operation of a work cell state is undefined valid if the tree used for its initialization is modified. (The implementation takes some care to check for this and crashes the program in a controlled way if it takes place.)

◆ StateData

the basic building block for the stateless design using the StateStructure class. A StateData represents a size, a unique id, and a unique name, when inserted into the StateStructure. The size will allocate "size"-doubles in State objects originating from the StateStructure.

◆ StateStructure

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

◆ STLFile

static methods for reading and writing geometry to and from STL files.

◆ StopCriteria

StopCriteria is a class for specifying an instant a compution should be aborted.

The computation determines when to stop by repeatedly polling the StopCriteria::stop() method. Therefore the stop() method should be implemented to have a very short, preferably deterministic running time.

◆ TaskSE3

Template based implementation of Task.

◆ ThreadPool

A thread pool that can be assigned work.

Work is handled in a FIFO manner, and the pool is intended to be very simple and basic.

For more complex behaviour please look at the ThreadTask type, which has a higher abstraction for adding tasks to a ThreadPool.

◆ ThreadTask

A task that facilitates the use of a hierarchic tree of tasks and subtasks.

Often parallel processing can be done at multiple levels. Typically it is not known beforehand if some task can be split into multiple smaller subtasks or not. The ThreadTask keeps track of the state of all its subtasks - only when all subtasks have been processed, the parent task will be able to finish. Instead of finishing, it can also choose to add new subtasks that depends on the result of the previously run subtasks.

The ThreadTask can utilize a ThreadPool of arbitrary size (down to 0 threads). When 0 threads are used, the addSubTask() function will be blocking and execute the work immediately. If more than 0 threads are used, the addSubTask function will return immediately, and the task is instead added to the work queue for processing when a thread becomes available.

There are two ways to use the ThreadTask:

  • Use it as a grouping mechanism: here one or more subtasks can be added for parallel processing. One can use the ThreadPool size to adjust the number of threads one wants to use for a specific application.
  • Subclass it and override the four standard functions to make more complex "branch-and-combine-results" type of tasks.

The four standard functions are as follows:

run() is the main work unit of the ThreadTask.

subTaskDone() is called each time a subtask has ended.

idle() is called when the task has finished its run() function and all subtasks has ended.

done() is the final function called before the ThreadTask is ended completely.

Please remember that the four functions can in general not be expected to be run in the same thread! In the first three functions it is allowed to add new subtasks to keep the thread running. In the done() function this is not allowed (it is simply ignored as the task will end immediately after this function has been called).

◆ TimedAssemblyState

A tuple of (time, value).

◆ TimedState

A tuple of (time, State). See rw::trajectory::Timed<t> template for more info.

◆ TrajectoryQ

Interface for Trajectories in RobWork.

◆ TrajectoryR1

Interface for Trajectories in RobWork.

◆ TrajectoryR2

Interface for Trajectories in RobWork.

◆ TrajectoryR3

Interface for Trajectories in RobWork.

◆ TrajectorySE3

Interface for Trajectories in RobWork.

◆ TrajectorySO3

Interface for Trajectories in RobWork.

◆ TrajectoryState

Interface for Trajectories in RobWork.

◆ Transform3d

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] $

◆ Transform3f

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] $

◆ TreeDevice

A tree structured device.

This device type defines devices that are tree-structured, with multiple end effectors. Typical for dexterous hands, and multi-armed robots.

dot_inline_dotgraph_1.png

◆ Triangle

plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise.

◆ Trianglef

plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise.

◆ TriangleN1

Triangle facet. triangle class of type N1, which means that beside the plain triangle the face normal of the triangle is saved with the facenormal.

◆ TriangleN1f

Triangle facet. triangle class of type N1, which means that beside the plain triangle the face normal of the triangle is saved with the facenormal.

◆ TriMesh

interface of a triangle mesh. The interface defines a way to get triangles from a triangle array/mesh.

◆ UpdateInfo

step info is used when updating controllers, devices and bodies.

◆ Vector2d

typedef rw::math::Vector2D<double> Vector2d

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;
Vector2D<> v1(1.0, 2.0);
Vector2D<> v2(6.0, 7.0);
Vector2D<> v3 = cross( v1, v2 );
Vector2D<> v4 = v2 - v1;

◆ Vector2f

typedef rw::math::Vector2D<float> Vector2f

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;
Vector2D<> v1(1.0, 2.0);
Vector2D<> v2(6.0, 7.0);
Vector2D<> v3 = cross( v1, v2 );
Vector2D<> v4 = v2 - v1;

◆ Vector3d

typedef rw::math::Vector3D<double> Vector3d

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 Vector3D<> v1(1.0, 2.0, 3.0);
const Vector3D<> v2(6.0, 7.0, 8.0);
const Vector3D<> v3 = cross(v1, v2);
const double d = dot(v1, v2);
const Vector3D<> v4 = v2 - v1;

◆ Vector3f

typedef rw::math::Vector3D<float> Vector3f

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 Vector3D<> v1(1.0, 2.0, 3.0);
const Vector3D<> v2(6.0, 7.0, 8.0);
const Vector3D<> v3 = cross(v1, v2);
const double d = dot(v1, v2);
const Vector3D<> v4 = v2 - v1;

◆ 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. WorkCell contains the World Frame, which represents the root and the only frame without a parent.

◆ WorkCellLoader

Defines an interface.

◆ WorkCellLoaderFactory

a factory for WorkCellLoader. This factory also defines an extension point for workcell loaders.

◆ WorkCellScene

class for wrapping the SceneGraph interface such that it extends the scene-graph functionality to work on frames and workcells.

The scene graph is composed of nodes which are related to Frames. Each frame can have several Drawables attached which can be considered as leafs. Beside keeping track of the mapping from frames to scenenodes, this class also adds settings such as highlighted, adding of frameaxis(per Frame), visibility and so on.

◆ Wrench6d

typedef rw::math::Wrench6D<double> Wrench6d

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.

◆ Wrench6f

typedef rw::math::Wrench6D<float> Wrench6f

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.

Function Documentation

◆ getRandomRotation3D()

Rotation3d rwlibs::swig::getRandomRotation3D ( )

Math helper function to obtain random rotation.

Returns
a random rotation.

◆ getRandomTransform3D()

Transform3d rwlibs::swig::getRandomTransform3D ( const double  translationLength = 1)

Math helper function to obtain random transform.

Parameters
translationLength[in] (optional) the length to translate - default is one meter.
Returns
a random transform.

◆ printCString() [1/2]

char* rwlibs::swig::printCString ( const std::vector< T > &  x)

Convert a vector of entities to a C string.

This function uses the toString function to do the conversion.

Parameters
x[in] the entities to convert.
Returns
a C string representation.

◆ printCString() [2/2]

char* rwlibs::swig::printCString ( const T &  x)

Convert an entity to a C string.

This function uses the toString function to do the conversion.

Parameters
x[in] the entity to convert.
Returns
a C string representation.

◆ setlog()

void rwlibs::swig::setlog ( ::rw::common::LogWriter::Ptr  writer)

Set the writer to write log to.

Parameters
writer[in] the writer.

◆ toString()

std::string rwlibs::swig::toString ( const T &  x)

Convert an entity to string.

It must be possible to stream the entity, x, to a ostringstream. The entity should in general have a stream operator implemented.

Parameters
x[in] the entity to convert to string.
Returns
the string representation.

◆ writelog()

void rwlibs::swig::writelog ( const std::string &  msg)

Write message to log.

Parameters
msg[in] message to write.