All Classes Interface Summary Class Summary
Class |
Description |
AABB |
Axis Aligned Bounding Box class
|
AmbiguityResolver |
Wraps a InvKinSolver and searches for ambiguities due to joint able to rotate
2 \ pi or more.
For each solution \mathbf{q} the method tries to see if a j exists s.t.
\mathbf{q}(i)=\mathbf{q}(i)+j * 2 \ pi is a valid solution.
The AmbiguityResolver always tests for joint limits.
|
AnalyticUtil |
Utility functions for functions dealing with analytic geometry.
|
AnyPtr |
Smart pointer that can point to any type, and optionally takes ownership of the object pointer.
|
ApproachMeasure3D |
computes the quality as a function of the angle between
the approach angle and some planar surface.
|
Archive |
archive interface for serializaion classes.
|
ARWExpand |
ARWExpand expands a random walk in the configuration space by one
step.
|
ARWExpandPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ARWPlanner |
Adaptive Random Walk planners
The ARW planners are based on the algorithm of: Stefano Carpin and
Gianluigi Pillonetto, Motion Planning Using Adaptive Random Walks, IEEE
Transactions on Robotics, Vol.
|
ARWPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyControlResponse |
|
AssemblyControlResponsePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyControlStrategy |
Interface for assembly control strategies.
|
AssemblyControlStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyParameterization |
|
AssemblyParameterizationPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyRegistry |
|
AssemblyRegistryPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyResult |
|
AssemblyResultPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyResultPtrVector |
|
AssemblySimulator |
|
AssemblySimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyState |
|
AssemblyStatePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyTask |
|
AssemblyTaskPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
AssemblyTaskPtrVector |
|
BasicFilterStrategy |
a simple rule based broadphase filter strategy.
|
BINArchive |
archive for loading and saving serializable classes.
|
Blend_d |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
Blend_d_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
Blend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Blend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Blend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Blend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendQ |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendRotation3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendRotation3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendTransform3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendTransform3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector2D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendVector2D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector3D |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendVector3D_f |
Interface for blending
A Blend describes a way to blend between to consecutive interpolators.
|
BlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Body |
|
BodyController |
|
BodyControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BodyInfo |
|
BodyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BodyPtrVector |
|
Box |
a box primitive, origin is in center of box
|
BoxCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BoxPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BREP |
Boundary representation (or B-Rep) of a geometric shape, using a collection of
connected surfaces, edges and vertices.
In the Shell representation, the geometric shape is formed as a collection of disconnected
faces.
|
BREP.CommonCurveSet |
Convenience type for a set of curves in a BREP.
|
BREPCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BREPPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BSphere |
class representing an Bounding sphere
|
BSphere_f |
class representing an Bounding sphere
|
BSphere_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BSphere_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BSphereCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BSpherePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
BvAABB |
a general bounding volume class for template inheritance.
|
BVBSphere |
a general bounding volume class for template inheritance.
|
BVBSphere_f |
a general bounding volume class for template inheritance.
|
BVColliderOBBColiderOBB |
abstract class describing interface of a bounding volume collision
detector.
|
BVColliderOBBColiderOBB_f |
abstract class describing interface of a bounding volume collision
detector.
|
BVColliderOBBToleranceCollider |
abstract class describing interface of a bounding volume collision
detector.
|
BVColliderOBBToleranceCollider_f |
abstract class describing interface of a bounding volume collision
detector.
|
BVDistanceCalcSphereDistanceCalc |
|
BVDistanceCalcSphereDistanceCalc_f |
|
BVFactoryOBB |
interface of bounding volume factory
|
BVFactoryOBB_f |
interface of bounding volume factory
|
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();
|
CameraCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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
|
CameraFirewireCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CameraFirewirePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CameraGroup |
A group of cameras.
|
CameraListener |
interface used for listening for camera events
|
CameraListenerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CameraListenerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
CCDSolver |
This inverse kinematics method is a heuristic search technique called
the Cyclic-Coordinate Descent method.
|
CircularInterpolatorVector3D |
Circular interpolator
See the specific template specializations
|
CircularInterpolatorVector3D_f |
Circular interpolator
See the specific template specializations
|
ClearanceCalculator |
Interface for ClearanceCalculator
A ClearanceCalculator provides a mean for calculating the clearance of for a state.
|
ClearanceCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ClearanceCalculatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ClearanceOptimizer |
The ClearanceOptimizer implements the C-Retraction algorithms from [1]
[1]: R.
|
ClearanceOptimizerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ClearanceOptimizerPtr |
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.
|
ClosedFormIKCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
ClosedFormIKSolverKukaIIWACPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
CMDistCCPMeasure3D |
computes the quality as a function of the distance between
the center of mass (COM) and the Center of the Contact Polygon (CCP)
See ROA 3.2.3
|
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.
|
CollisionDetector.CollisionDetectorQueryResult |
result of a collision query
|
CollisionDetector.CollisionDetectorQueryType |
types of collision query
|
CollisionDetectorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CollisionDetectorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CollisionPairVector |
|
CollisionResult |
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.
|
CollisionResult.CollisionPair |
a collision pair of
|
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.CollisionStrategyFactory |
A factory for a CollisionStrategy.
|
CollisionStrategy.Contact |
describes a simple collision contact data structure
|
CollisionStrategy.QueryType |
the type of query that is to be performed
|
CollisionStrategyCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CollisionStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CollisionToleranceStrategy |
This is a collision strategy that detects collisions between objects
that are closer than a specified tolerance.
|
CollisionToleranceStrategy.CollisionToleranceStrategyFactory |
A factory for a CollisionToleranceStrategy.
|
CollisionToleranceStrategyCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CollisionToleranceStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
complexd |
|
complexf |
|
CompositeContactFilter |
makes it possible to combine several contact filters into one contact filter.
Statistics are maintained of the validation succes which can be queried and analysed.
|
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.
|
CompositeDeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CompositeDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CompositeGraspFilter |
makes it possible to combine several contact filters into one contact filter.
Statistics are maintained of the validation succes which can be queried and analyzed.
|
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 straight-forward way of JointDevice.
|
CompositeJointDeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CompositeJointDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Cone |
cone primitive.
|
ConeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Constraint |
|
Constraint.ConstraintType |
|
Constraint.SpringParams |
|
ConstraintPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConstraintPtrVector |
|
Contact |
|
Contact2D |
data structure for describing a contact in 2D
|
Contact2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Contact2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Contact3D |
data structure for describing a contact in 3D
|
Contact3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Contact3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ContactDetector |
|
ContactDetectorData |
|
ContactDetectorDataPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ContactDetectorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ContactDetectorTracking |
|
ContactDetectorTrackingPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ContactDistThresFilter |
tests if contact points in a grasp is too close or too far from each other.
Two points that are very close is not allowed unless they are approached from opposite
directions.
|
ContactStrategy |
|
ContactStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ContactValidateFilter |
tests if a contact is valid in respect to some criterias implemented
by a sub class.
|
ContactVector |
|
Contour2D |
class representing a 2d contour
|
Contour2D.Point |
the point description of the contour
|
Contour2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Contour2DInfoMap |
class for analysing 2d contours.
|
Contour2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Controller |
interface that defines functionality for control of devices and actuators
|
ControllerCPtr |
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.
|
ControllerModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ControllerModelPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ControllerModelPtrVector |
|
ControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConvexHull2D |
interface for convexhull calculators on 2d point sets
|
ConvexHull2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConvexHull2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConvexHull3D |
interface for convexhull calculators on 3d point sets
|
ConvexHull3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ConvexHull3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Covariance |
class for estimating the covariance of different data
|
CubicSplineFactory |
Factory for creating cubic splines
|
CubicSplineInterpolator_d |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolator_d_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorQ |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorRotation3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorRotation3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorTransform3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorTransform3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorTransform3DVector |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorVector2D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorVector2D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector3D |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorVector3D_f |
This class represents a 3-degree polynomial function, used
in Cubic Splines hence the name CubicSegment.
\bf{f}(t)= \bf{a} + \bf{b}\cdot t + \bf{c}\cdot t^2 \bf{d}\cdot t^3
|
CubicSplineInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CubicSplineInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CurvatureThresFilter |
tests if a grasp is valid in respect to the curvature of the object
surface in and around the contact points.
This class requires that the face in which the contact point is extracted is
registered in the Contact3D data.
|
Curve |
Curve is an abstract representation of a smooth curve geometry in 3D.
The interface provides functions for affine transformations, such as scaling, rotation and
translation.
|
CurveCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CurvePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Cylinder |
a cylinder primitive.
|
CylinderCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
CylinderPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DeformableObject |
The deformable object is an object that contain a deformable mesh.
|
DeformableObjectCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DeformableObjectPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DeformableObjectPtrVector |
|
Delaunay |
Utility functions for doing Delaunay triangulations.
|
DependentJoint |
Dependent joints are 0-dof 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.
|
DependentJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DependentJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DependentPrismaticJoint |
Dependent prismatic joint.
DependentPrismaticJoint implements a prismatic joint for which the displacement
along the z-axis are linearly dependent on another joint
|
DependentPrismaticJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DependentPrismaticJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DependentRevoluteJoint |
Dependent revolute joints.
DependentRevoluteJoint implements a revolute joint for which the rotation about the
z-axis 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
z-axis.
|
DependentRevoluteJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DependentRevoluteJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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 end-effector is given a "stacked" Jacobian is returned.
|
DeviceJacobianCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DeviceJacobianCalculatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DevicePtrVector |
|
DHParameterSet |
Simple class to help represent a set of Denavit-Hartenberg
parameters
|
DHParameterSetCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DHParameterSetPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DHParameterSetVector |
|
DiceContactG3D |
generates candidate contact point sets (contact grasps) for
grasping a given object.
|
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
|
DistanceCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceCalculatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceMultiCalculator |
The Proximity calculator implements an efficient and standardized way of using the
following proximity strategies:
CollisionStrategy
DistanceStrategy
MultiDistanceStrategy
The Calculate function is designed to fit the chosen strategy individually implementing a
fitting aproach for calculating the respective proximity.
The CollisionDetector
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 Proximity calculator does not dictate a specific detection
strategy or algorithm, instead it relies on the CollisionStrategy interface for
the actual collision checking between two frames.
Distance and MultiDistance Calculator
A list of frame pairs is contained within the Proximity calculator,
that specifies which frames are to be checked against each other.
The method of used for distance calculation relies on the DistanceStrategy
chosen.
|
DistanceMultiStrategy |
This interface allows the definition of computing all points between two
geometric objects that are closer than a specified tolerance.
|
DistanceMultiStrategy.DistanceMultiStrategyFactory |
A factory for a DistanceMultiStrategy.
|
DistanceMultiStrategy.DistanceMultiStrategyResult |
DistanceResult contains basic information about the distance
result between two frames.
|
DistanceMultiStrategyCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceMultiStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceMultiStrategyResultVector |
|
DistanceStrategy |
This is an interface that defines methods for computing the minimum distance
between geometric objects.
|
DistanceStrategy.DistanceStrategyFactory |
A factory for a DistanceStrategy.
|
DistanceStrategy.DistanceStrategyResult |
DistanceResult contains basic information about the distance
result between two sets of geometries.
|
DistanceStrategyCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceStrategyResultVector |
|
DistanceUtil |
a class for performing distance calculations between different
geometric primitives
|
DistanceUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DistanceUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DOMElem |
an wrapper interface for easy access to XML DOM parser.
|
DOMElem.Iterator |
DOMElem iterator based on concrete ItImpl implementations.
|
DOMElem.ItImpl |
The DOMElem Iterator is initialized with a specific implementation
of this interface.
|
DOMElemCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DOMElemPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DOMParser |
interface for parsing documents in a DOM fasion.
The factory method in the DOM parser enables extensions to be added by the user through
plugins.
|
DOMParser.Factory |
a factory for DOMParsers.
|
DOMParserCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DOMParserPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DOMPropertyMapFormat |
Class storing the identifiers used for properties
|
DOMPropertyMapFormat.Initializer |
Utility class which initializes local static variables.
If the DOMPropertyMapFormat is used outside main (as a part of global
initialization/destruction), the Initializer should be used explicitly to control the
static initialization/destruction order.
Notice that the Initializer is automatically defined as a global variable, hence it
should not be necessary to specify the initializer explicitly if DOMPropertyMapFormat is
to be used in local static initialization/destruction.
|
DrawableGeometryNode |
A specific type of DrawableNode that is able to draw a rw::geometry::Geometry.
|
DrawableGeometryNodeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DrawableGeometryNodePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
DrawableNode.DrawableTypeMask |
draw mask is used to filter which drawables to exclude from rendering.
|
DrawableNode.DrawType |
when calling render on the draw mode or type
can be specified.
|
DrawableNode.RenderInfo |
Information for rendering.
|
DrawableNodeClone |
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.
|
DrawableNodeCloneCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DrawableNodeClonePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DrawableNodeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DrawableNodePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DynamicDevice |
|
DynamicDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DynamicDevicePtrVector |
|
DynamicSimulator |
|
DynamicSimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DynamicWorkCell |
the DynamicWorkcell class is a container class for dynamic
information/data in a workcell, much like WorkCell is a container
class for the kinematic information/data in a workcell
The dynamic description includes:
- Body: severel different forms of bodies that may be constrained by rules
- Constraint: constraining the bodies to move in a specific way relative to each other
- Controllers: severel controllers that in some way control/influence the bodies
- Sensors: bodies that have tactile sensing capability
|
DynamicWorkCell.DWCEventType |
Types of events a DynamicWorkCell can emit.
|
DynamicWorkCellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
DynamicWorkCellLoader |
class for loading of dynamic owrkcells
|
DynamicWorkCellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
EAA |
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 |
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
|
EigenDecomposition |
Type representing a set of eigen values and eigen vectors.
|
EigenDecomposition_f |
Type representing a set of eigen values and eigen vectors.
|
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 |
|
EuclideanMetricQ |
Euclidean distance metric for vector types.
The distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(p_i - q_i)^2}
|
EuclideanMetricVector2D |
Euclidean distance metric for vector types.
The distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(p_i - q_i)^2}
|
EuclideanMetricVector3D |
Euclidean distance metric for vector types.
The distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(p_i - q_i)^2}
|
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:
|
Extension.Descriptor |
An extension descriptor.
The descriptor holds meta-data for an extension, and makes it possible to do lazy-loading
of plugins.
|
ExtensionCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ExtensionPointCollisionStrategy |
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.
|
ExtensionPointCollisionToleranceStrategy |
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.
|
ExtensionPointDistanceMultiStrategy |
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.
|
ExtensionPointDistanceStrategy |
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.
|
ExtensionPointDOMParser |
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.
|
ExtensionPointProximityStrategy |
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.
|
ExtensionPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Face |
Abstract interface for geometric faces.
A face consist of a surface and curves that form the boundary of the face.
For all faces there must be the same number of vertices and curves.
The order of vertices and curves are ordered such that a curve at a certain index will have a
corresponding start vertex at the same vertex index.
|
FaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FixedBody |
|
FixedBodyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FixedBodyPtrVector |
|
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.
|
FixedFrameCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
FKRangeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FKRangePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
FKTableCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FKTablePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
FrameGrabber |
The FrameGrabber abstract interface, can be used to grab images from a
specialized source.
|
FrameGrabber25D |
The FrameGrabber25D abstract interface, can be used to grab images from a
specialized source.
|
FrameGrabber25DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FrameGrabberPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FrameMap |
a specialized mapping implementation for frames.
|
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
|
FrameTypeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FrameTypePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FrameVector |
|
FTSensor |
Interface of a N-axis Force Torque sensor
|
FTSensorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FTSensorModel |
N-axis Force Torque sensor model
|
FTSensorModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FTSensorModelPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
FTSensorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GenericFace |
The GenericFace implementation is a type of Face that consist of abstract Surfaces and
Curves.
|
GenericFaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GenericFacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Geometry.GeometryGroupMask |
A geometry may belong to a specific group of geometries.
|
GeometryCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GeometryData |
an interface for geometry data.
|
GeometryData.GeometryType |
geometry data types
|
GeometryDataCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GeometryDataPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GeometryPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GeometryUtil |
Utility functions for calculating properties of geometry
The methods for calculation of volume, inertia, and the center of gravity, is as described in
[1].
[1]: Fast and Accurate Computation of Polyhedral Mass Properties, Brian Mirtich.
|
GeometryUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GeometryUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GLFrameGrabber |
An implementation of the FrameGrabber interface.
|
GLFrameGrabber25D |
An implementation of the FrameGrabber interface.
|
GLFrameGrabber25DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GLFrameGrabber25DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GLFrameGrabberCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GLFrameGrabberPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Grasp2D |
a grasp is a set of contacts between the object to be grasped and
the robot gripper.
|
Grasp3D |
a grasp is a set of contacts between the object to be grasped and
the robot gripper.
|
GraspQualityMeasure3D |
an interface for methods evaluating the quality of a specific grasp
|
GraspResult |
|
GraspResult.TestStatus |
|
GraspResultPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GraspTable |
A table of grasp configurations that has been generated using a robot hand,
a number of preshapes, and some grasp policy.
|
GraspTable.GraspData |
data for describing a single grasp
|
GraspTask |
|
GraspTaskPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GraspTaskSimulator |
|
GraspTaskSimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GraspValidateFilter |
tests if a grasp is valid in respect to some criterias implemented
by a sub class.
|
GroupNode |
a SceneNode that has a transformation and 0 to many children.
|
GroupNodeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
GroupNodePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
HyperSphere |
A hyper-sphere of K dimensions.
Functions are provided to create (almost) uniform distribution of points on a hyper-sphere as
shown in [1].
The distribution of points is illustrated below for 2 and 3 dimensional hyper-spheres.
Notice that the tessellation is best when \delta is small.
[1] Lovisolo, L., and E.
|
HyperSphereCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
HyperSpherePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
IKMetaSolverCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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 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.
|
Image.ColorCode |
The color encodings that the image can use.
|
Image.Pixel4i |
|
Image.PixelDepth |
The pixeldepth determines how many bits that are used per pixel per channel
|
ImageCPtr |
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
|
ImageUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImageUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitBREP |
Type of BREP where all surfaces are of type ImplicitSurface,
and edges are of type ParametricCurve.
|
ImplicitBREP.CommonParametricCurveSet |
Convenience type for a set of curves in a BREP.
|
ImplicitBREPCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitBREPPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitFace |
Type of Face, where the surface is an ImplicitSurface and the
edges are of type ParametricCurve.
|
ImplicitFaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitFacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitShell |
Type of Shell where all surfaces are of type ImplicitSurface and
all curves are of type ParametricCurve.
|
ImplicitShellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitShellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitSurface |
Interface for implicit surfaces.
|
ImplicitSurfaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitSurfacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitTorus |
|
ImplicitTorusCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ImplicitTorusPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedFaceArray |
An indexed face array is a proxy to a Shell, that makes it possible to easily sort
faces and take subsets without modifying the underlying Shell.
|
IndexedFaceArray.IndexedFace |
Structure that holds information for each face.
|
IndexedFaceArrayCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedFaceArrayPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedPolygon |
indexed polygon class that saves N indices to the N vertices of the polygon
|
IndexedPolygon_32 |
indexed polygon class that saves N indices to the N vertices of the polygon
|
IndexedPolygon_32CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedPolygon_32Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedPolygonCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedPolygonN |
Polygon with N vertice indices and 0 normals
|
IndexedPolygonN_32 |
Polygon with N vertice indices and 0 normals
|
IndexedPolygonNN |
Polygon with N vertices and N normals.
|
IndexedPolygonNN_32 |
Polygon with N vertices and N normals.
|
IndexedPolygonPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedQuadraticFaceArray |
Proxy class for a QuadraticShell, that allows sorting of faces without modifying the
original object.
|
IndexedQuadraticFaceArray.QuadIndexedFace |
Structure that holds information for each face.
|
IndexedQuadraticFaceArrayCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedQuadraticFaceArrayPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangle |
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.
|
IndexedTriangle_32 |
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.
|
IndexedTriangle_32CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangle_32Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN1 |
indexed triangle class with an additional index for an face normal
|
IndexedTriangleN1_32 |
indexed triangle class with an additional index for an face normal
|
IndexedTriangleN1_32CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN1_32Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN1CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN1Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN3 |
indexed triangle class with an additional index for 3 normals one for each vertice in
the triangle
|
IndexedTriangleN3_32 |
indexed triangle class with an additional index for 3 normals one for each vertice in
the triangle
|
IndexedTriangleN3_32CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN3_32Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN3CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriangleN3Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTrianglePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriArray |
this class is a proxy to a triangle mesh where the triangles
can be indirectly copied in an efficient manner.
Each "virtual" triangle index is mapped to the actual triangle index.
By rearanging the mapping the order of the triangles in the mesh are
rearanged to the proxy user, without changing the actual triangle mesh.
|
IndexedTriArrayCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriArrayPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMesh |
Interface for indexed triangle meshes.
An indexed triangle mesh has a list of vertices and a list of
indicies.
|
IndexedTriMesh_f |
Interface for indexed triangle meshes.
An indexed triangle mesh has a list of vertices and a list of
indicies.
|
IndexedTriMesh_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMeshN0 |
an Indexed Triangle mesh with zero normals
|
IndexedTriMeshN0_f |
an Indexed Triangle mesh with zero normals
|
IndexedTriMeshN0_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMeshN0_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMeshN0CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMeshN0Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IndexedTriMeshPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InertiaMatrixd |
A 3x3 inertia matrix
|
InertiaMatrixf |
A 3x3 inertia matrix
|
InfinityMetricQ |
Infinity norm distance metric for vector types.
InfinityMetric is a metric of the Euclidean n-Plane.
|
InfinityMetricVector2D |
Infinity norm distance metric for vector types.
InfinityMetric is a metric of the Euclidean n-Plane.
|
InfinityMetricVector3D |
Infinity norm distance metric for vector types.
InfinityMetric is a metric of the Euclidean n-Plane.
|
INIArchive |
archive for loading and saving serializable classes to an ini-file format.
|
InputArchive |
an archive interface for reading from a serialized class.
|
Interpolator_d |
Interface for interpolators
See the specific implementations for more details
|
Interpolator_d_f |
Interface for interpolators
See the specific implementations for more details
|
Interpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Interpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Interpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Interpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorQ |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorRotation3D |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorRotation3D_f |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectory_d |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectory_d_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectory_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectory_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectory_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectory_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQ |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQuaternion |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryQuaternion_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryQuaternion_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQuaternion_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQuaternionCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryQuaternionPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryRotation3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryRotation3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryTransform3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DVector |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryTransform3DVector_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryTransform3DVector_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DVector_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DVectorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryTransform3DVectorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector2D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryVector2D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector3D |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryVector3D_f |
Sequence of interpolators and blends giving a trajectory
A trajectory is defined as a sequence of interpolators and blends.
Multiple interpolators can follow each other, whereas a Blend must be
preceded and followed by interpolators.
The length of a Trajectory is defined as the time it takes to go from
start to finish.
When performing random queries the trajectory needs to do a binary search
through all interpolators and blend, giving the random access an O(lg n)
complexity.
For accessing multiple consecutive values use TrajectoryInterpolator.
Example of usage:
Transform3D<> T1(Vector3D<>(0,0,0), EAA<>(0,0,0));
Transform3D<> T2(Vector3D<>(1,1,0), EAA<>(1,1,0));
Transform3D<> T3(Vector3D<>(2,0,0), EAA<>(2,2,0));
LinearInterpolator<Transform3D<> >::Ptr cartInt1 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T1, T2, 1));
LinearInterpolator<Transform3D<> >::Ptr cartInt2 =
ownedPtr(new LinearInterpolator<Transform3D<> >(T2, T3, 1));
ParabolicBlend<Transform3D<> >::Ptr blend1 =
ownedPtr(new ParabolicBlend<Transform3D<> >(cartInt1, cartInt2, 0.25));
InterpolatorTrajectory<Transform3D<> > trajectory;
trajectory.add(cartInt1);
trajectory.add(blend1, cartInt2);
std::ofstream out("test.dat");
for (double t = 0; t<=trajectory.duration(); t += dt) {
Transform3D<> x = trajectory.x(t);
out<<t<<" "<<x.P()(0)<<" "<<x.P()(1)<<" "<<x.P()(2)<<std::endl;
}
out.close();
|
InterpolatorTrajectoryVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTrajectoryVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTransform3D |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorTransform3D_f |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorTransform3DVector |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorUtil |
Utilities used in the implementation of various interpolators
and blends.
|
InterpolatorVector2D |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorVector2D_f |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector3D |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorVector3D_f |
Interface for interpolators
See the specific implementations for more details
|
InterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
InvKinSolver |
Interface for inverse kinematics algorithms
The InvKinSolver interface provides an interface for calculating
the inverse kinematics of a device.
|
InvKinSolverPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IOUtil |
Collection of IO related utilities
|
IterativeIK |
Interface for iterative inverse kinematics algorithms
The IterativeIK interface provides an interface for calculating
the inverse kinematics of a device.
|
IterativeIKCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
IterativeIKPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Jacobian |
A Jacobian class.
|
JacobianCalculator |
JacobianCalculator provides an interface for obtaining a Jacobian
|
JacobianCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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
|
JacobianIKSolverCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
JacobianIKSolverM.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.
|
JacobianUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
JacobianUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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...
|
JointController.ControlMode |
control mode
|
JointControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
JointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
JointDeviceJacobianCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
JointDeviceJacobianCalculatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
JointDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
JointDevicePtrVector |
|
JointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
KinematicBody |
|
KinematicBodyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
KinematicBodyPtrVector |
|
Kinematics |
Utility functions for the rw::kinematics module.
|
KinematicsCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
KinematicsPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Line |
A line in 3D, described by a two points.
|
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.
|
LinearAlgebra |
Collection of Linear Algebra functions
|
LinearInterpolator_d |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolator_d_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorQ |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorRotation3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorRotation3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorTransform3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorTransform3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector2D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorVector2D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector3D |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorVector3D_f |
Make a linear interpolation between to position
Given a start \mathbf{s}, end \mathbf{e} and duration d
the interpolation is implemented as \mathbf{x}(t)=\mathbf{s} +
(\mathbf{e}-\mathbf{s})*t/d.
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
LinearInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LinearInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LineCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LineMetric |
A metric for calculating line-to-line distance.
|
LinePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlend_d |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlend_d_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendQ |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendRotation3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendRotation3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendTransform3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendTransform3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector2D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendVector2D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector3D |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendVector3D_f |
Implements LloydHayward blending
The LloydHayward blend [1], makes a smooth continous differentiable transition between
two interpolators.
[1]: J.
|
LloydHaywardBlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LloydHaywardBlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LoaderRW |
Automatically class generated by CMake for convenient loading of the native RobWork libraries.
|
LoaderRWS |
Automatically class generated by CMake for convenient loading of the native RobWorkStudio library.
|
LoaderRWSim |
Automatically class generated by CMake for convenient loading of the native RobWorkSim library.
|
Log |
Provides basic log functionality.
The Log class owns a number of LogWriters in a static map, which can be accessed
using a string identifier.
|
Log.LogIndex |
Indices for different logs.
|
Log.LogIndexMask |
loglevel mask
|
LogBufferedChar |
Buffers characters before writing them to the output stream.
The size of the buffer is fixed.
|
LogBufferedChar.OverflowPolicy |
Behaviors for the OverflowPolicy
|
LogBufferedMsg |
Buffers messages before writing them to the output stream.
The size of the buffer is not fixed and will grow until flush is called.
To have a fixed size buffer use LogBufferedChar instead.
|
LogCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LogFileWriter |
Writes log output to a file
|
LogMultiWriter |
Writes log output to multiple LogWriters
|
LogPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LogStreamWriter |
Writes log output to a std::ostream
|
LogWriter |
Write interface for Logs
LogWriter provides an output strategy for a log.
|
LogWriterCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
LogWriterPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ManhattanMetricVector2D |
Manhattan distance metric for vector types.
The ManhattanMetric, also known as the taxicab metric or the 1-norm, is a
metric on the Euclidean n-Plane.
|
ManhattanMetricVector3D |
Manhattan distance metric for vector types.
The ManhattanMetric, also known as the taxicab metric or the 1-norm, is a
metric on the Euclidean n-Plane.
|
ManhattenMatricQ |
Manhattan distance metric for vector types.
The ManhattanMetric, also known as the taxicab metric or the 1-norm, is a
metric on the Euclidean n-Plane.
|
MapStringFrame |
|
Math |
Utility functions for the rw::math module.
|
Message |
Standard type for user messages of robwork.
Messages are used for exception, warnings, and other things that are
reported to the user.
Message values should contain the source file name and line number so
that it is easy to look up the place in the code responsible for the
generation of the message.
RW_THROW and RW_WARN of macros.hpp have been introduced for the throwing
of exceptions and emission of warnings.
|
MetricFactory |
Metric constructor functions.
The constructor functions are parameterized by a type of vector.
|
MetricLine |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricLineCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricLinePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricPlane |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricPlaneCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricPlanePtr |
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.
|
MetricRotation3D |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricRotation3D_f |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricRotation3DPtr |
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.
|
MetricTransform3D_f |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricUtil |
Various metrics and other distance measures.
|
MetricVector2D |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricVector3D |
Template interface for metrics on type T.
A metric is a function that defines a scalar distance between elements.
|
MetricVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MetricVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MinimumClearanceCalculator |
Implements a MinimumClearanceCalculator
The minimum clearance is defined as the minimal distance between any two geometries, which
are not excluded by the collision setup.
|
MinimumClearanceCalculatorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MinimumClearanceCalculatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MobileDevice |
Provides a differential controlled mobile device
The MobileDevice class provides a differential controlled mobile device
with non-holonomic constraints.
|
MobileDeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MobileDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Model3D |
a 3d model that has geometry but also material and color.
he model can be composed of multiple objects that are connected in
a hierarchical manner.
|
Model3D.Material |
describes material properties.
|
Model3D.SmoothMethod |
Method to do smoothing.
|
Model3D.Texture |
|
Model3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Model3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Model3DPtrVector |
|
Models |
Utility functions for the rw::models module.
|
ModelsCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ModelsPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
MovableFrameCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MovableFramePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
MovableFrameVector |
|
OBB |
class representing an Oriented Bounding Box (OBB)
|
OBB_f |
class representing an Oriented Bounding Box (OBB)
|
OBBCollider |
class for testing if two Oriented Bounding Boxes (OBBs) are overlapping.
The method used is based on the seperating axis theorem.
|
OBBCollider_f |
class for testing if two Oriented Bounding Boxes (OBBs) are overlapping.
The method used is based on the seperating axis theorem.
|
OBBColliderCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBColliderPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBFactory |
factory for computing tight fitting Oriented Bounding Boxes.
|
OBBFactory_f |
factory for computing tight fitting Oriented Bounding Boxes.
|
OBBFactory_f.FitMethod |
The supported methods to generate an oriented bounding box from a mesh.
|
OBBFactory.FitMethod |
The supported methods to generate an oriented bounding box from a mesh.
|
OBBFactoryCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBFactoryPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBToleranceCollider |
class for testing if two Oriented Bounding Boxes are overlapping
|
OBBToleranceCollider_f |
class for testing if two Oriented Bounding Boxes are overlapping
|
OBBToleranceColliderCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OBBToleranceColliderPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Object3DGeneric |
An abstract 3d object consisting of geometry information, material and texture.
To reduce memory, the geometry is implemented slightly differently for different mesh
sizes.
|
Object3DGeneric.MaterialMapData |
Mapping from triangles to materials.
|
Object3DGeneric.MaterialPolys |
ordering polygons by material consumes more memmory but reduce switches between
textures.
|
ObjectCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ObjectPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ObjectPtrVector |
|
ObvOBB |
a general oriented bounding volume class
|
ObvOBB_f |
a general oriented bounding volume class
|
ODESimulator |
|
ODESimulator.StepMethod |
|
ODESimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
OS |
encapsulates os dependent functionality
|
OutputArchive |
serializable objects can be written to an output archive.
This class define an interface for serializing data.
|
pair_b_d |
|
pair_b_i |
|
pair_b_l |
|
pair_b_ui |
|
pair_b_ul |
|
pair_d_d |
|
pair_f_f |
|
Pair_i_i |
|
Pair_s_s |
|
pair_ui_ui |
|
pairBoolVectorDouble |
|
pairBoolVectorInt |
|
pairBoolVectorLong |
|
pairBoolVectorUInt |
|
pairBoolVectorULong |
|
PairConstQ |
|
pairEigenMatrixX_d_EigenVectorX_d |
|
pairEigenMatrixXComplex_d_EigenVectorXComplex_d |
|
PairQ |
|
ParabolicBlend_d |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlend_d_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlend_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlend_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlend_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlend_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendQ |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendRotation3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendRotation3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendTransform3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendTransform3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector2D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendVector2D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector3D |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendVector3D_f |
Implements a parabolic blend
A parabolic blend is characterized by a constant acceleration through the blend.
|
ParabolicBlendVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParabolicBlendVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParallelDevice |
This class defines the interface for Parallel devices.
|
ParallelDeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParallelDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParallelIKSolver |
Inverse kinematics method for parallel devices.
The method is based on solving for two simultaneous constraints.
First, the junctions defined in the ParallelDevice must remain connected.
Second, the target(s) given by the user should be fulfilled.
A stacked Jacobian is used to form an equation system that includes these objectives.
The Singular Value Decomposition is used to find the solution for the joint values
in this equation system.
|
ParallelIKSolver.Target |
A target definition used in the multi-target solve function.
|
ParallelLeg |
Class representing a single leg in a ParallelDevice
|
ParallelLegCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParallelLegPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParametricCurve |
Interface for parametric curves.
|
ParametricCurveCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ParametricCurvePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PathAnalyzer |
The PathAnalyzer provides a set a basic tools for analyzing a path.
Features in the PathAnalyzer include analysis of joint space, Cartesian space,
estimation of execution time and measures for clearance.
|
PathAnalyzer.CartesianAnalysis |
Result struct for Cartesian analysis
|
PathAnalyzer.ClearanceAnalysis |
Result struct for CleracenAnalysis
|
PathAnalyzer.JointSpaceAnalysis |
Result struct for joint space analysis
|
PathAnalyzer.TimeAnalysis |
Result struct for Time analysis
|
PathLengthOptimizer |
The PathLengthOptimizer implements the 3 different path length optimizers
presented in [1].
[1]: R.
|
PathLengthOptimizerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PathLengthOptimizerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PathPlannerQQ |
Path planner interface.
PathPlanner<From, To, Path> plans a path in the configuration space
From from a start configuration of type From to a goal destination
specified by a parameter of type To.
|
PathPlannerQQSampler |
Path planner interface.
PathPlanner<From, To, Path> plans a path in the configuration space
From from a start configuration of type From to a goal destination
specified by a parameter of type To.
|
PathPlannerQTransform3D |
Path planner interface.
PathPlanner<From, To, Path> plans a path in the configuration space
From from a start configuration of type From to a goal destination
specified by a parameter of type To.
|
PathQuaternion |
This is a std::Vector overloaded with some extra constructor functionality
|
PathState |
This is a std::Vector overloaded with some extra constructor functionality
|
PathTimedAssemblyState |
This is a std::Vector overloaded with some extra constructor functionality
|
PathTimedQ |
This is a std::Vector overloaded with some extra constructor functionality
|
PathTimedState |
This is a std::Vector overloaded with some extra constructor functionality
|
PathTimedTransform3D |
This is a std::Vector overloaded with some extra constructor functionality
|
PathTransform3DVector |
This is a std::Vector overloaded with some extra constructor functionality
|
PDController |
|
PDControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PDParam |
|
PDParamVector |
|
PerspectiveTransform2D |
The PerspectiveTransform2D is a perspective transform in 2D.
The homographic transform can be used to map one arbitrary 2D
quadrilateral into another.
|
PerspectiveTransform2Df |
The PerspectiveTransform2D is a perspective transform in 2D.
The homographic transform can be used to map one arbitrary 2D
quadrilateral into another.
|
PhysicsEngine |
|
PhysicsEngineFactory |
|
PhysicsEnginePtr |
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.
|
PieperSolverCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PieperSolverPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Pixel4f |
|
PlainQuadraticShell |
A collection of concrete Quadratic surface patches, that together form a shell.
|
PlainQuadraticShellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainQuadraticShellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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().
|
PlainTriMesh_f |
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().
|
PlainTriMesh_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMesh_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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().
|
PlainTriMeshN1_f |
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_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN1_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN1CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN1Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN3 |
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().
|
PlainTriMeshN3_f |
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().
|
PlainTriMeshN3_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN3_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN3CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshN3Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlainTriMeshPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Plane |
plane primitive represented in Hessian normal-form: a*nx+b*ny+c*nz+d=0
|
PlaneClearanceFilter |
tests if a grasp is valid in respect to the distance of each
contact point to some plane.
The plane is defined by the xy-plane in
a transform that is specified relative to the frame that the object
is specified relative to.
|
PlaneCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlaneMetric |
A metric for calculating plane-to-plane distance.
|
PlanePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlannerConstraint |
A tuple of (QConstraintPtr, QEdgeConstraintPtr).
A planner constraint is a small copyable object containing pointers to a
configuration constraint and an edge constraint.
|
PlannerConstraintCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlannerConstraintPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PlannerUtil |
PlannerUtil provides various utilities useful in path planning
|
PlannerUtil.EstimateType |
Description of the different estimation type possible in the
estimateMotionWeights(EsitmateType, size_t) method
|
Plugin |
this define is to be used whenever dynamically loadable RobWork libraries are
being created.
|
PluginCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PluginPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PointCloud |
A simple point cloud data structure.
|
PointCloudCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PointCloudPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Polygon |
indexed polygon class that saves N indices to the N vertices of the polygon
|
Polygon_f |
indexed polygon class that saves N indices to the N vertices of the polygon
|
Polygon_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Polygon_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Polygon2D |
indexed polygon class that saves N indices to the N vertices of the polygon
|
Polygon2D_f |
indexed polygon class that saves N indices to the N vertices of the polygon
|
PolygonCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PolygonPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PolygonUtil |
Utility functions for operations on polygons, such as convex partitioning.
The algorithm for convex partitioning of polygons has time complexity O(n r^2 \log r)
where n is the number of vertices and r is the number of reflex vertices (vertices that gives
an inward notch).
|
PolynomialNDdDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenMatrix3dDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenMatrix3fFloat |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenMatrix3ifComplexDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenRowVector3dDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenRowVector3fFloat |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenRowVector3idComplexDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenVector3dDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenVector3fFloat |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDEigenVector3idComplexDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDfFloat |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order term, {c_0,c_1,...,c_n}.
|
PolynomialNDidComplexDouble |
Representation of a polynomial that can have non-scalar coefficients (polynomial
matrix).
Representation of a polynomial of the following form:
f(x) = C_n x^n + C_(n-1) x^(n-1) + C_2 x^2 + C_1 x + C_0
The polynomial is represented as a list of coefficients ordered from lowest-order term to
highest-order 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.
|
Pose2D |
A Pose3D \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.
|
Pose2Df |
A Pose3D \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.
|
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.
|
Pose6Df |
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.
|
PoseController |
|
Primitive |
defines an interface for a geometric shape that is defined
by a set of parameters.
|
PrimitiveCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PrimitivePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PrismaticJoint |
Prismatic joints.
PrismaticJoint implements a prismatic joint for the displacement in the
direction of the z-axis of an arbitrary displacement transform.
|
PrismaticJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
PrismaticSphericalJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
PrismaticUniversalJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PrismaticUniversalJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PRMPlanner |
Implements a probabilistic roadmap (PRM) planner.
The PRMPlanner is implemented freely after [1], and has a number of options:
- Lazy Collision Checking: Using lazy collision checking as in [2], the
planner can be used for single as well as multiple queries.
- Nearest Neighbor Search: The algorithm can either use a partial index
table [3] or a simple brute force method to do the nearest neighbor
search.
- Shortest Path Algorithm: Using the Boost Graph Library, both A* and
Dijkstra's Algorithm may be used for finding the shortest path.
As default the algorithm runs with lazy collision checking, brute force
neighbor search and with A* for shortest path search.
As metric the PRMPlanner uses a WeightedEuclideanMetric for which it
estimates the weights such that it provides a worst-case estimate of the
Cartesian motion of the robots given a change in the configuration.
Example of use
PRMPlanner* prm = new PRMPlanner(device, workcell, state, collisionDetector, resolution);
prm->setCollisionCheckingStrategy(PRMPlanner::LAZY);
prm->setNeighSearchStrategy(PRMPlanner::BRUTE_FORCE);
prm->setShortestPathSearchStrategy(PRMPlanner::A_STAR);
prm->buildRoadmap(1000);
Path path;
bool pathFound = prm->query(qstart, qgoal, path, maxtime);
[1]: Probabilistic Roadmaps for Path Planning in High-Dimensional
Configuration Spaces, L.E.
|
PRMPlanner.CollisionCheckingStrategy |
Enumeration for selecting the collision checking strategy
|
PRMPlanner.NeighborSearchStrategy |
Enumeration for selecting the node neighbor search strategy
|
PRMPlanner.ShortestPathSearchStrategy |
Enumeration for selecing the shortest path search strategy
|
PRMPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProgramOptions |
a class for parsing program command line into a PropertyMap
|
ProjectionMatrix |
projection matrix
|
Property_b |
Property class
The Property class is a template to support properties of any type.
|
Property_d |
Property class
The Property class is a template to support properties of any type.
|
Property_f |
Property class
The Property class is a template to support properties of any type.
|
Property_i |
Property class
The Property class is a template to support properties of any type.
|
Property_s |
Property class
The Property class is a template to support properties of any type.
|
PropertyBase |
Base class for Property handling
|
PropertyBaseCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PropertyBasePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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";
}
|
PropertyPropertyMap |
Property class
The Property class is a template to support properties of any type.
|
PropertyType |
Represents type of a property
PropertyType has a number of predefined property types.
|
PropertyType.Types |
Predefined types
|
PropertyValue_b |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValue_d |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValue_f |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValue_i |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValue_s |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValueBase |
Base class for Property handling
|
PropertyValueBaseCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PropertyValueBasePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PropertyValuePropertyMap |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValueVector_d |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValueVector_i |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyValueVector_s |
PropertyValue class
The PropertyValue class is a template to support property values of any
type.
|
PropertyVector_d |
Property class
The Property class is a template to support properties of any type.
|
PropertyVector_i |
Property class
The Property class is a template to support properties of any type.
|
PropertyVector_s |
Property class
The Property class is a template to support properties of any type.
|
ProximityCache |
Interface for cache used by ProximityStrategy
|
ProximityCacheCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCachePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorCollision |
The Proximity calculator implements an efficient and standardized way of using the
following proximity strategies:
CollisionStrategy
DistanceStrategy
MultiDistanceStrategy
The Calculate function is designed to fit the chosen strategy individually implementing a
fitting aproach for calculating the respective proximity.
The CollisionDetector
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 Proximity calculator does not dictate a specific detection
strategy or algorithm, instead it relies on the CollisionStrategy interface for
the actual collision checking between two frames.
Distance and MultiDistance Calculator
A list of frame pairs is contained within the Proximity calculator,
that specifies which frames are to be checked against each other.
The method of used for distance calculation relies on the DistanceStrategy
chosen.
|
ProximityCalculatorCollisionCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorCollisionPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorDistance |
The Proximity calculator implements an efficient and standardized way of using the
following proximity strategies:
CollisionStrategy
DistanceStrategy
MultiDistanceStrategy
The Calculate function is designed to fit the chosen strategy individually implementing a
fitting aproach for calculating the respective proximity.
The CollisionDetector
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 Proximity calculator does not dictate a specific detection
strategy or algorithm, instead it relies on the CollisionStrategy interface for
the actual collision checking between two frames.
Distance and MultiDistance Calculator
A list of frame pairs is contained within the Proximity calculator,
that specifies which frames are to be checked against each other.
The method of used for distance calculation relies on the DistanceStrategy
chosen.
|
ProximityCalculatorDistanceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorDistanceMultiCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorDistanceMultiPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityCalculatorDistancePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityData |
Holds settings and cached data for collision detectors.
The cache makes it possible for some algorithms to perform faster
detections.
|
ProximityDataCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
ProximityFilterCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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 frame-pairs 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 |
Class for managing the collision geometries associated to a frame
|
ProximityModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
ProximityStrategy.ProximityStrategyFactory |
A factory for a ProximityStrategy.
|
ProximityStrategyCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityStrategyData |
|
ProximityStrategyDataCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityStrategyDataPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ProximityStrategyFactory |
|
ProximityStrategyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Pyramid |
a pyrimidal geometric primitive.
|
PyramidCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
PyramidPtr |
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.
|
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.
|
QEdgeConstraintCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
QHull3D |
calculates the convex hull of a set of 3d points.
The GiftWrap convex hull algorithm is used, hence the
class name.
Note: It is important that there are not multiple vertices at the same coordinates.
Filter these away before using this convex hull calculation.
|
QHull3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QHull3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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).
|
QNormalizerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QNormalizerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
QStateCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QStatePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QString |
|
QToQPlanner |
Path planner interface.
A path planner plans a path in the configuration space from a start
configuration to a goal configuration.
|
QToQPlannerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
QToQSamplerPlannerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QToQSamplerPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QToTPlanner |
Approach planner interface.
An approach planner plans a path from a configuration for the device to a
configuration for the tool.
|
QToTPlannerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QToTPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticBREP |
A boundary representation where the geometry of a face is a QuadraticSurface,
and an edge curve is a QuadraticCurve.
This implementation adds the geometry related to Quadrics, based on BREP which handles the
topology.
To build a geometry composed of Quadratic surfaces and curves, follow the following
procedure:
1.
|
QuadraticBREP.CommonQuadraticCurveSet |
Convenience type for a set of curves in a QuadraticBREP.
|
QuadraticBREPCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticBREPPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticCurve |
A quadratic curve.
A quadratic curve is given explicitly by the expression \mathbf{p} = \mathbf{c} + r(t)
\mathbf{u} + s(t) \mathbf{v} where \mathbf{c},\mathbf{u},\mathbf{v},\mathbf{p} \in
\mathbb{R}^3 and \mathbf{u}^T \mathbf{v} = 0 .
The following four types of curves are possible:
- Ellipse: (r,s)=(\sin t,\cos t)
- Hyperbola: (r,s)=(\sinh t,\cosh t)
- Line: (r,s)=(t,0)
- Parabola: (r,s)=(t,t^2)
|
QuadraticCurve.Type |
The four possible curve types.
|
QuadraticCurveCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticCurvePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticFace |
A Quadratic surface patch bounded by Quadratic curves.
|
QuadraticFaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticFacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticShell |
A collection of Quadratic surface patches, that together form a shell.
|
QuadraticShellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticShellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticSurface |
A quadratic surface.
The general quadratic surface is described as an implicit surface of the form:
x^T A x + 2 a^T x + u = 0
where
A is a symmetric matrix, A \in \mathbb{R}^{3\times3} , and a \in \mathbb{R}^3, u
\in \mathbb{R}
|
QuadraticSurfaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticSurfacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
QuadraticUtil |
Utility functions for operations on quadratic surfaces and curves.
Functions are provided to find approximate closest points between different combinations of
quadratics surfaces and curves.
|
Quaternion |
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.
|
Quaternion_f |
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.
|
QWidget |
|
RampInterpolator_d |
|
RampInterpolator_d_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorQ |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorRotation3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorRotation3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorTransform3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorTransform3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector2D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorVector2D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector3D |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorVector3D_f |
Make a ramp interpolation between two position
The template argument given needs to support addition with the "+" operator
and scaling with a double using the "*" operator.
For use with a rw::math::Transform3D see the template specialization
|
RampInterpolatorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RampInterpolatorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Random |
Generation of random numbers.
|
Raycaster |
a raycast implementation that relies on a collision strategy for finding the
collision between the ray and the scene.
|
Raycaster.QueryType |
result structure of ray cast
|
Raycaster.RaycasterQueryResult |
result of a Raycast query.
|
Render |
Abstract base class for all renderable classes
Classes that are able to render them self, may inherit from this class.
|
RenderCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RenderImage |
RenderImage renders a image in a plane defined by
[-w/2;h/2][w/2;-h/2].
|
RenderImagePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RenderPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RevoluteJoint |
Revolute joints.
RevoluteJoint implements a revolute joint for the rotation about the
z-axis of an arbitrary displacement transform.
|
RevoluteJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RevoluteJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RGBDCameraModel |
|
RGBDCameraModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RGBDCameraModelPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidBody |
|
RigidBodyInfo |
A class to wrap rigid body information.
|
RigidBodyInfoCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidBodyInfoPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidBodyPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidBodyPtrVector |
|
RigidDevice |
|
RigidDevice.MotorControlMode |
|
RigidDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidDevicePtrVector |
|
RigidObject |
the RigidObject defines a physical object in the workcell that is rigid in the sence
that the geometry does not change.
|
RigidObjectCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RigidObjectPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
RobWorkCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RobWorkPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RobWorkStudio |
|
RobWorkStudioApp |
a RobWorkStudio main application which may be instantiated in its own thread.
The app can be started with either a call to the run() function or the start() function depending
on weather you want to run it from current thread or start it up in another tread.
For convinienve when running the app from the main tread the macros
RWS_START(RobWorkStudioApp app) and RWS_END() can be used to capsulate code to run in a new
thread
|
RobWorkStudioPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Rotation2D |
|
Rotation2Df |
|
Rotation3D |
|
Rotation3DAngleMetric_d |
a distance metric over rotations.
|
Rotation3DAngleMetric_f |
a distance metric over rotations.
|
Rotation3Df |
|
Rotation3DVector |
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
|
RPY |
A class for representing Roll-Pitch-Yaw Euler angle rotations.
|
RPYf |
A class for representing Roll-Pitch-Yaw Euler angle rotations.
|
RRTPlanner |
RRT based planners
|
RRTPlanner.PlannerType |
The type of RRT planner to construct.
|
RRTPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
RWException |
Standard exception type of RobWork.
All exception thrown within RobWork are of the type Exception.
An exception contains a message (of type Message) for the user and
nothing else.
|
RWStudioView3D |
|
RWStudioView3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SBLExpand |
Interface for sampling a configuration in the vicinity of some
other configuration.
SBLExpand is a primitive for planners in the SBL family.
|
SBLExpandPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SBLOptions |
SBL planner setup.
SBLOptions is the value stored in SBLSetup.
SBLOptions is a seperate file so that we can keep SBLSetup as abstract as
possible.
SBLOptions is used by SBLInternal and is for internal use only.
|
SBLOptions.ConnectFrequency |
Policy for how often to connect trees.
|
SBLOptions.NearNodeSelection |
Policy for choosing a node in the vicinity of a given node, n.
|
SBLOptions.TreeSelection |
Policy for selecting a tree.
|
SBLPlanner |
SBL based planners.
|
SBLPlannerConstraint |
A SBL planner constraint.
|
SBLPlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SBLSetup |
Common parameters for SBL based planners.
All versions of the SBL planner base verify configurations and paths in
the configuration space using a PlannerConstraint object.
In addition, parameters can given to define how expansion around a node
of the tree should be done and under what circumstances the two trees
should be connected.
A SBLSetup object stores pointers to the shared objects, but can be
copied and assigned freely.
|
Scanner |
this interface describe a generic range scanning class.
|
Scanner1D |
a one dimensional range scanner.
|
Scanner1DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Scanner1DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Scanner25D |
an interface describing a 3D scanner sensor.
|
Scanner25DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Scanner25DModel |
Model of a 25D (2D with depth information) scanner.
|
Scanner25DModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Scanner2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
Scanner2DModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Scanner2DModelPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Scanner2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ScannerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ScannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneCamera |
Node representing a camera in the scene.
|
SceneCamera.AspectRatioControl |
Mode for aspect ratio control.
|
SceneGraph |
interface for a minimalistic scenegraph that does not depend on the frame structure.
See WorkCellScene for an implementation that wraps this interface to enable a more RobWork
specific use.
Cameras - SceneCameras define how the world is rendered from a specific point of view,
render setting, projection matrix, viewport and so on.
Cameras are ordered in CameraGroups.
|
SceneGraph.SceneGraphRenderInfo |
all general render information is located in this struct
|
SceneGraphCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneGraphPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneNode |
a node that can have leafs (DrawableNode) or other nodes as children.
|
SceneNode.AddPolicy |
Policy for adding parent nodes.
|
SceneNode.NodeType |
Node types.
|
SceneNodeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneNodePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneViewer |
interface for viewing a scene graph.
The scene graph viewer
|
SceneViewer.View |
|
SceneViewerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SceneViewerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ScopedTimer |
Times what is executed in a scope.
Automatically calls resume on the timer given in construction and pause when destroyed.
Note: usage
...
long time;
{
// put code here that is not to be timed
ScopedTimer timer(time);
// put code here that is to be timed
}
std::cout << "Time: " << time << std::endl;
|
sdurw |
|
sdurw_assembly |
|
sdurw_assemblyJNI |
|
sdurw_common |
|
sdurw_commonJNI |
|
sdurw_control |
|
sdurw_controlJNI |
|
sdurw_core |
|
sdurw_geometry |
|
sdurw_geometryJNI |
|
sdurw_graphics |
|
sdurw_graphicsConstants |
|
sdurw_graphicsJNI |
|
sdurw_graspplanning |
|
sdurw_graspplanningJNI |
|
sdurw_invkin |
|
sdurw_invkinJNI |
|
sdurw_kinematics |
|
sdurw_kinematicsConstants |
|
sdurw_kinematicsJNI |
|
sdurw_math |
|
sdurw_mathConstants |
|
sdurw_mathJNI |
|
sdurw_models |
|
sdurw_modelsJNI |
|
sdurw_opengl |
|
sdurw_openglJNI |
|
sdurw_pathoptimization |
|
sdurw_pathoptimizationJNI |
|
sdurw_pathplanners |
|
sdurw_pathplannersJNI |
|
sdurw_pathplanning |
|
sdurw_pathplanningJNI |
|
sdurw_proximity |
|
sdurw_proximityJNI |
|
sdurw_proximitystrategies |
|
sdurw_proximitystrategiesJNI |
|
sdurw_sensor |
|
sdurw_sensorJNI |
|
sdurw_simulation |
|
sdurw_simulationJNI |
|
sdurw_task |
|
sdurw_taskJNI |
|
sdurw_trajectory |
|
sdurw_trajectoryJNI |
|
sdurws |
|
sdurwsim |
|
sdurwsimConstants |
|
SE3Device |
A Cartesian 6-Dof device
The SE3Device is a 6-dof device with 6 independent inputs that
enables the device to place its end-effector anywhere in the workspace.
The \mathbf{q}\in \mathbb{R}^6 input vector maps directly to the
end-effector 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).
|
SE3DeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SE3DevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Segment_d |
|
Segment_f |
|
SegmentQ |
|
SegmentQuaternion |
|
SegmentQuaternion_f |
|
SegmentRotation3D |
|
SegmentRotation3D_f |
|
SegmentTransform3D |
|
SegmentTransform3D_f |
|
SegmentTransform3DVector |
|
SegmentTransform3DVector_f |
|
SegmentVector2D |
|
SegmentVector2D_f |
|
SegmentVector3D |
|
SegmentVector3D_f |
|
SemiForceClosureFilter |
A conservative estimate of the force closure properties of the grasp are
used to indicate weather a grasp is valid or not.
The method is described in "Grasping the Dice by Dicing the Grasp"
|
Sensor |
a generel hardware sensor interface.
|
SensorCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SensorModel |
a general sensormodel interface.
|
SensorModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
SerialDeviceController |
|
SerialDeviceControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SerialDeviceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SerialDevicePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Serializable |
interface for defining serialization of classes.
|
Shell |
A shell represents the geometry of an object as a collection of non-connected faces.
Each face is composed of a trimmed surface, the edge curves, and vertices that connects the
edges.
|
ShellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ShellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedCamera |
The SimulatedCamera class makes it posible to use virtual camera
sensors by using different framegrapper implementations.
The SimulatedCamera implements the camera interface though the setting of
framerate has no meaning to the virtual camera since no timing is done in
this implementation.
|
SimulatedCameraCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedCameraPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedController |
interface of a simulated controller
|
SimulatedControllerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedControllerPtrVector |
|
SimulatedFTSensor |
|
SimulatedFTSensorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedScanner25D |
a simulated range scanner for 2.5D images, that is basically
pointclouds without color information.
|
SimulatedScanner25DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedScanner25DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedScanner2D |
Simulated scanner in 2D.
|
SimulatedScanner2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedScanner2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedSensor |
simulated sensor interface
|
SimulatedSensorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SimulatedSensorPtrVector |
|
Simulator |
interface of a general simulator
|
Simulator.UpdateInfo |
step info is used when updating controllers, devices and bodies.
|
SimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Sphere |
a sphere primitive.
|
SphereCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SphereDistanceCalc |
class for testing if two Oriented Bounding Boxes are overlapping
|
SphereDistanceCalc_f |
class for testing if two Oriented Bounding Boxes are overlapping
|
SphereDistanceCalcCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SphereDistanceCalcPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SpherePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SphericalJoint |
A spherical joint that allows rotations in all directions.
Rotation is allowed around the x-, y- and z-axes.
|
SphericalJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
StateCacheCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
StateData |
the basic building block for the stateless design using
the StateStructure class.
|
StateDataCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
StateDataPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Stateless |
interface for a stateless or typically a part stateless class.
|
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,
|
StateSetupCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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
|
StateStructureCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
StateStructurePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Statistics |
Class for collecting data and calculating simple statistics.
|
Statistics_f |
Class for collecting data and calculating simple statistics.
|
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
|
StereoCameraModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
StereoCameraModelPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
StopCriteriaCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
StopCriteriaPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
StringUtil |
Collection of string manipulation utilities
|
SuctionCup |
|
SuctionCupCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SuctionCupPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Surface |
Surface is an abstract representation of a smooth surface geometry.
The interface provides functions for affine transformations, such as
scaling, rotation and translation.
In case of a trimmed surface, it is also possible to make a discretization
of the surface to triangle mesh.
|
SurfaceCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SurfacePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SWIGTYPE_p_Body__Ptr |
|
SWIGTYPE_p_bool |
|
SWIGTYPE_p_bool |
|
SWIGTYPE_p_bool |
|
SWIGTYPE_p_boost__functionT_bool_fF_t |
|
SWIGTYPE_p_boost__functionT_void_frw__common__ThreadPool_pF_t |
|
SWIGTYPE_p_boost__program_options__options_description |
|
SWIGTYPE_p_boost__program_options__positional_options_description |
|
SWIGTYPE_p_Constraint__Ptr |
|
SWIGTYPE_p_ContactDataMap |
|
SWIGTYPE_p_double |
|
SWIGTYPE_p_double |
|
SWIGTYPE_p_double |
|
SWIGTYPE_p_double |
|
SWIGTYPE_p_double |
|
SWIGTYPE_p_DynamicDevice__Ptr |
|
SWIGTYPE_p_Eigen__DiagonalMatrixT_double_3_3_t |
|
SWIGTYPE_p_Eigen__DiagonalT_Eigen__Matrix3d_t |
|
SWIGTYPE_p_Eigen__Matrix3d |
|
SWIGTYPE_p_Eigen__Matrix3d |
|
SWIGTYPE_p_Eigen__Matrix3f |
|
SWIGTYPE_p_Eigen__MatrixT_double_4_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_double_5_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_double_Eigen__Dynamic_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_double_Eigen__Dynamic_Eigen__Dynamic_t |
|
SWIGTYPE_p_Eigen__MatrixT_double_Eigen__Dynamic_Eigen__Dynamic_t |
|
SWIGTYPE_p_Eigen__MatrixT_float_4_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_float_5_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_float_Eigen__Dynamic_1_t |
|
SWIGTYPE_p_Eigen__MatrixT_float_Eigen__Dynamic_Eigen__Dynamic_t |
|
SWIGTYPE_p_Eigen__MatrixT_std__complexT_float_t_3_3_t |
|
SWIGTYPE_p_Eigen__MatrixXf |
|
SWIGTYPE_p_Eigen__Rotation2DT_double_t |
|
SWIGTYPE_p_Eigen__Rotation2DT_float_t |
|
SWIGTYPE_p_Eigen__SelfAdjointViewT_Eigen__Matrix3d_const_Eigen__Lower_t |
|
SWIGTYPE_p_Eigen__SelfAdjointViewT_Eigen__Matrix3d_const_Eigen__Upper_t |
|
SWIGTYPE_p_Eigen__SelfAdjointViewT_Eigen__Matrix3d_Eigen__Lower_t |
|
SWIGTYPE_p_Eigen__SelfAdjointViewT_Eigen__Matrix3d_Eigen__Upper_t |
|
SWIGTYPE_p_Eigen__Vector3d |
|
SWIGTYPE_p_Eigen__Vector3d |
|
SWIGTYPE_p_Eigen__Vector3f |
|
SWIGTYPE_p_Eigen__VectorXd |
|
SWIGTYPE_p_f_r_std__ostream__r_std__ostream |
|
SWIGTYPE_p_float |
|
SWIGTYPE_p_float |
|
SWIGTYPE_p_float |
|
SWIGTYPE_p_float |
|
SWIGTYPE_p_float |
|
SWIGTYPE_p_int |
|
SWIGTYPE_p_int |
|
SWIGTYPE_p_int |
|
SWIGTYPE_p_int16_t |
|
SWIGTYPE_p_int32_t |
|
SWIGTYPE_p_int64_t |
|
SWIGTYPE_p_int8_t |
|
SWIGTYPE_p_int8_t |
|
SWIGTYPE_p_MaterialDataMap |
|
SWIGTYPE_p_p_char |
|
SWIGTYPE_p_p_char |
|
SWIGTYPE_p_rw__core__EventT_boost__functionT_void_frwsim__dynamics__DynamicWorkCell__DWCEventType_boost__anyF_t_rwsim__dynamics__DynamicWorkCell__DWCEventType_boost__any_rw__core___n1_rw__core___n1_t |
|
SWIGTYPE_p_rw__core__iter_pairT_rw__common__ConcatVectorIteratorT_rw__kinematics__Frame_t_t |
|
SWIGTYPE_p_rw__core__iter_pairT_rw__common__ConcatVectorIteratorT_rw__kinematics__Frame_t_t |
|
SWIGTYPE_p_rw__core__iter_pairT_rw__core__DOMElem__Iterator_t |
|
SWIGTYPE_p_rw__core__Plugin__OSHandle |
|
SWIGTYPE_p_rw__core__PtrT_Body_const_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__ExtensionRegistry_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyMap_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyMap_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_bool_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_double_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_float_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_int_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__string_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__vectorT_bool_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__vectorT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__vectorT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__vectorT_int_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__core__PropertyT_std__vectorT_std__string_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__geometry__BREP__CommonCurveSet_const_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__geometry__ImplicitBREP__CommonParametricCurveSet_const_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__geometry__Object3DGeneric_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__geometry__QuadraticBREP__CommonQuadraticCurveSet_const_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__CameraGroup_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__DrawableNode_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__SceneCamera_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__SceneDescriptor_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__SceneViewer__View_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__SceneViewer_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__SceneViewer_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graphics__WorkCellScene_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__graspplanning__GraspTable_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__invkin__IterativeIK_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__pathplanning__QConstraint_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__proximity__CollisionDetector_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__QuaternionT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__QuaternionT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__Transform3DVectorT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__BlendT_rw__math__Transform3DVectorT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__QuaternionT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__QuaternionT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__Transform3DVectorT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__InterpolatorT_rw__math__Transform3DVectorT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__kinematics__State_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__math__Q_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__math__Q_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__math__Q_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__math__Transform3DT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__trajectory__TimedT_rw__kinematics__State_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__trajectory__TimedT_rw__kinematics__State_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Q_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_SimulatedController_t |
|
SWIGTYPE_p_rw__core__PtrT_SimulatedSensor_t |
|
SWIGTYPE_p_rw__core__PtrT_std__vectorT_rw__geometry__IndexedTriangleT_uint16_t_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_std__vectorT_rw__math__Vector3DT_double_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_std__vectorT_rw__math__Vector3DT_float_t_t_t |
|
SWIGTYPE_p_rw__core__PtrT_std__vectorT_rw__proximity__ProximityStrategyData_t_t |
|
SWIGTYPE_p_rw__core__PtrT_std__vectorT_unsigned_long_t_t |
|
SWIGTYPE_p_rw__graphics__DrawableNode__DrawType |
|
SWIGTYPE_p_rw__graphics__DrawableNode__RenderInfo |
|
SWIGTYPE_p_rw__math__EAAT_double_t |
|
SWIGTYPE_p_rw__math__Function1DiffT_double_double_double_t__Ptr |
|
SWIGTYPE_p_rw__math__LinearAlgebra__EigenMatrixT_double_t__type |
|
SWIGTYPE_p_rw__math__LinearAlgebra__EigenMatrixT_std__complexT_double_t_t__type |
|
SWIGTYPE_p_rw__math__LinearAlgebra__EigenVectorT_double_t__type |
|
SWIGTYPE_p_rw__math__LinearAlgebra__EigenVectorT_std__complexT_double_t_t__type |
|
SWIGTYPE_p_rw__math__PolynomialNDT_Eigen__Matrix3d_double_t |
|
SWIGTYPE_p_rw__math__PolynomialNDT_Eigen__Matrix3f_float_t |
|
SWIGTYPE_p_rw__math__PolynomialNDT_Eigen__Vector3d_double_t |
|
SWIGTYPE_p_rw__math__PolynomialNDT_Eigen__Vector3f_float_t |
|
SWIGTYPE_p_rw__math__PolynomialT_double_t |
|
SWIGTYPE_p_rw__math__PolynomialT_float_t |
|
SWIGTYPE_p_rw__math__PolynomialT_std__complexT_double_t_t |
|
SWIGTYPE_p_rw__math__Q |
|
SWIGTYPE_p_rw__math__QuaternionT_double_t |
|
SWIGTYPE_p_rw__math__Rotation2DT_double_t |
|
SWIGTYPE_p_rw__math__Rotation2DT_t |
|
SWIGTYPE_p_rw__math__Rotation3DT_double_t |
|
SWIGTYPE_p_rw__math__Rotation3DT_t |
|
SWIGTYPE_p_rw__math__Rotation3DT_t |
|
SWIGTYPE_p_rw__math__RPYT_double_t |
|
SWIGTYPE_p_rw__math__Transform2DT_double_t |
|
SWIGTYPE_p_rw__math__Transform2DT_float_t |
|
SWIGTYPE_p_rw__math__Transform3DT_double_t |
|
SWIGTYPE_p_rw__math__Transform3DT_rw__TraitsT_rw__geometry__OBBT_double_t_t__value_type_t |
|
SWIGTYPE_p_rw__math__Transform3DT_rw__TraitsT_rw__geometry__OBBT_float_t_t__value_type_t |
|
SWIGTYPE_p_rw__math__Vector2DT_double_t |
|
SWIGTYPE_p_rw__math__Vector3DT_double_t |
|
SWIGTYPE_p_rw__math__VectorNDT_6_bool_t |
|
SWIGTYPE_p_rw__math__VelocityScrew6DT_double_t |
|
SWIGTYPE_p_rw__proximity__CollisionSetup |
|
SWIGTYPE_p_rw__TraitsT_rw__geometry__OBBT_double_t_t__value_type |
|
SWIGTYPE_p_rw__TraitsT_rw__geometry__OBBT_float_t_t__value_type |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Q_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__QuaternionT_double_t_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Transform3DVectorT_double_t_t_t |
|
SWIGTYPE_p_rw__trajectory__PathT_rw__trajectory__TimedT_rw__math__Vector3DT_double_t_t_t |
|
SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__kinematics__State_t__Ptr |
|
SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__QuaternionT_double_t_t__Ptr |
|
SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__QuaternionT_float_t_t__Ptr |
|
SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__Transform3DVectorT_double_t_t__Ptr |
|
SWIGTYPE_p_rw__trajectory__TrajectoryIteratorT_rw__math__Transform3DVectorT_float_t_t__Ptr |
|
SWIGTYPE_p_std__functionT_void_frw__core__PropertyMap_p_rw__core__PropertyBase_pF_t |
|
SWIGTYPE_p_std__iostream |
|
SWIGTYPE_p_std__istream |
|
SWIGTYPE_p_std__istream |
|
SWIGTYPE_p_std__istringstream |
|
SWIGTYPE_p_std__istringstream |
|
SWIGTYPE_p_std__listT_double_t |
|
SWIGTYPE_p_std__listT_float_t |
|
SWIGTYPE_p_std__listT_rw__core__PtrT_rw__graphics__CameraGroup_t_t |
|
SWIGTYPE_p_std__listT_rw__core__PtrT_rw__graphics__SceneCamera_t_t |
|
SWIGTYPE_p_std__listT_rw__core__PtrT_rw__graphics__SceneNode_t_t |
|
SWIGTYPE_p_std__listT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__listT_std__vectorT_rw__math__Vector3DT_double_t_t_t |
|
SWIGTYPE_p_std__listT_std__vectorT_unsigned_long_t_t |
|
SWIGTYPE_p_std__ostream |
|
SWIGTYPE_p_std__ostream |
|
SWIGTYPE_p_std__ostream |
|
SWIGTYPE_p_std__ostream |
|
SWIGTYPE_p_std__pairT_rw__core__PtrT_rw__kinematics__Frame_t_rw__core__PtrT_rw__kinematics__Frame_t_t |
|
SWIGTYPE_p_std__pairT_rw__geometry__QuadraticSurface_rw__math__Rotation3DT_t_t |
|
SWIGTYPE_p_std__pairT_rw__math__Vector3DT_double_t_rw__math__InertiaMatrixT_double_t_t |
|
SWIGTYPE_p_std__pairT_rw__math__Vector3DT_double_t_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__pairT_rw__math__Vector3DT_double_t_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__setT_std__pairT_rw__kinematics__Frame_p_rw__kinematics__Frame_p_t_t |
|
SWIGTYPE_p_std__setT_std__string_t |
|
SWIGTYPE_p_std__setT_unsigned_long_t |
|
SWIGTYPE_p_std__string |
|
SWIGTYPE_p_std__time_t |
|
SWIGTYPE_p_std__type_info |
|
SWIGTYPE_p_std__vectorT_Body__Ptr_t |
|
SWIGTYPE_p_std__vectorT_Constraint__Ptr_t |
|
SWIGTYPE_p_std__vectorT_DynamicDevice__Ptr_t |
|
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_std__vectorT_Eigen__MatrixXf_t |
|
SWIGTYPE_p_std__vectorT_Eigen__VectorXd_t |
|
SWIGTYPE_p_std__vectorT_rw__core__Exception_t |
|
SWIGTYPE_p_std__vectorT_rw__core__Extension__Descriptor_t |
|
SWIGTYPE_p_std__vectorT_rw__core__Extension__Descriptor_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__common__ThreadTask_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__core__Plugin_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__Curve_const_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__Curve_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__ImplicitSurface_const_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__Model3D__Texture_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__Object3DGeneric__MaterialPolys_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__Object3DGeneric_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__ParametricCurve_const_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__ParametricCurve_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__QuadraticCurve_const_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__QuadraticCurve_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__geometry__QuadraticFace_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__graphics__DrawableNode_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rw__graphics__SceneViewer__View_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rwlibs__simulation__SimulatedController_t_t |
|
SWIGTYPE_p_std__vectorT_rw__core__PtrT_rwlibs__simulation__SimulatedSensor_t_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__Contour2D__Point_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__IndexedFaceArray__IndexedFace_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__IndexedPolygonNT_uint16_t_t_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__IndexedQuadraticFaceArray__IndexedFace_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__Model3D__Material_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__Object3DGeneric__MaterialMapData_t |
|
SWIGTYPE_p_std__vectorT_rw__geometry__PolygonT_rw__math__Vector2DT_double_t_t_t |
|
SWIGTYPE_p_std__vectorT_rw__graspplanning__ContactValidateFilter_p_t |
|
SWIGTYPE_p_std__vectorT_rw__graspplanning__Grasp3D_t |
|
SWIGTYPE_p_std__vectorT_rw__graspplanning__GraspTable__GraspData_t |
|
SWIGTYPE_p_std__vectorT_rw__graspplanning__GraspValidateFilter_p_t |
|
SWIGTYPE_p_std__vectorT_rw__invkin__ParallelIKSolver__Target_t |
|
SWIGTYPE_p_std__vectorT_rw__math__QuaternionT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Rotation3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Transform3DVectorT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector2DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_double_t_t__const_iterator |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__math__Vector3DT_float_t_t |
|
SWIGTYPE_p_std__vectorT_rw__proximity__CollisionStrategy__Contact_t |
|
SWIGTYPE_p_std__vectorT_rw__sensor__Contact2D_p_t |
|
SWIGTYPE_p_std__vectorT_rw__sensor__Contact2D_t |
|
SWIGTYPE_p_std__vectorT_std__pairT_rw__core__PtrT_rw__proximity__ProximityModel_t_int_t_t |
|
SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t |
|
SWIGTYPE_p_std__vectorT_std__vectorT_rw__sensor__Contact3D_t_t |
|
SWIGTYPE_p_std__vectorT_unsigned_int_t |
|
SWIGTYPE_p_std__vectorT_unsigned_int_t |
|
SWIGTYPE_p_std__vectorT_unsigned_short_t |
|
SWIGTYPE_p_uint64_t |
|
SWIGTYPE_p_unsigned_char |
|
SWIGTYPE_p_unsigned_int |
|
SWIGTYPE_p_unsigned_short |
|
SWIGTYPE_p_void |
|
SWIGTYPE_p_void |
|
SyncVelocityRamp |
Provides generation of synchronized velocity ramps for a device
The synchronized velocity ramp calculates a profile for moving linearly
between two configurations a quick as possible without violating the
dynamic limitations specified.
|
SyncVelocityRampCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
SyncVelocityRampPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TactileArray |
|
TactileArrayCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TactileArrayModel |
the TactileArrayModel describes tactile sensor consisting of
arrays of tactile cells that can be placed on a defined shape.
|
TactileArrayModelCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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
|
TactileArrayUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TactileArrayUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TactileVertexMatrix |
|
TaskSE3 |
|
TaskSE3Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TextureCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TextureData |
container for storing texture data.
|
TextureDataCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TextureDataPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TexturePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
ThreadPoolCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ThreadPoolPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ThreadSimulator |
|
ThreadSimulatorPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ThreadSimulatorPtrVector |
|
ThreadSimulatorStepCallback |
|
ThreadSimulatorStepCallbackEnv |
|
ThreadSimulatorStepCallbackHandler |
|
ThreadSimulatorStepEvent |
This class allows an event based callback implementation for ThreadSimulator .
|
ThreadSimulatorStepEventDispatcher |
|
ThreadSimulatorStepEventListener |
Interface for listeners that wants to receive step events from ThreadSimulator .
|
ThreadTask |
A task that facilitates the use of a hierarchic tree of tasks and subtasks.
Often parallel processing can be done at multiple levels.
|
ThreadTask.TaskState |
The different execution states of a task.
|
ThreadTaskCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
ThreadTaskPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Timed_d |
A tuple of (time, value).
|
Timed_d_f |
A tuple of (time, value).
|
Timed_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Timed_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Timed_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Timed_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedAssemblyState |
A tuple of (time, value).
|
TimedAssemblyStateVector |
|
TimedQ |
A tuple of (time, value).
|
TimedQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedRotation3D |
A tuple of (time, value).
|
TimedRotation3D_f |
A tuple of (time, value).
|
TimedRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedState |
A tuple of (time, value).
|
TimedStateVector |
|
TimedTransform3D |
A tuple of (time, value).
|
TimedTransform3D_f |
A tuple of (time, value).
|
TimedTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedUtil |
Construction of paths of Timed values.
|
TimedVector2D |
A tuple of (time, value).
|
TimedVector2D_f |
A tuple of (time, value).
|
TimedVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector3D |
A tuple of (time, value).
|
TimedVector3D_f |
A tuple of (time, value).
|
TimedVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimedVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TimeMetricUtil |
methods for analyzing time distance of various paths
|
Timer |
The timer class provides an easy to use platform independent timer
In Windows the expected resolution is approx.
|
TimerUtil |
Access of the system clock so called wall time.
|
Trajectory_d |
Interface for Trajectories in RobWork
|
Trajectory_d_f |
Interface for Trajectories in RobWork
|
Trajectory_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Trajectory_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Trajectory_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Trajectory_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryFactory |
Trajectory constructors
|
TrajectoryIterator_d |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIterator_d_f |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIterator_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIterator_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIterator_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIterator_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorQ |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorRotation3D |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorRotation3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorTransform3D |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorTransform3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector2D |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorVector2D_f |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector3D |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorVector3D_f |
Bi-directional iterator for running efficiently through a trajectory
|
TrajectoryIteratorVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryIteratorVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryQ |
Interface for Trajectories in RobWork
|
TrajectoryQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryQuaternion |
Interface for Trajectories in RobWork
|
TrajectoryQuaternion_f |
Interface for Trajectories in RobWork
|
TrajectoryRotation3D |
Interface for Trajectories in RobWork
|
TrajectoryRotation3D_f |
Interface for Trajectories in RobWork
|
TrajectoryRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequence_d |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequence_d_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequence_d_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequence_d_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequence_dCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequence_dPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceQ |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceQCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceQPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceRotation3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceRotation3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceRotation3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceRotation3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceRotation3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceRotation3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceTransform3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceTransform3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector2D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceVector2D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector3D |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceVector3D_f |
Combines a number of trajectories.
Takes an arbitrary number of trajectories and combines them.
|
TrajectorySequenceVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectorySequenceVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryState |
Interface for Trajectories in RobWork
|
TrajectoryStatePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryTransform3D |
Interface for Trajectories in RobWork
|
TrajectoryTransform3D_f |
Interface for Trajectories in RobWork
|
TrajectoryTransform3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryTransform3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryTransform3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryTransform3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryTransform3DVector |
Interface for Trajectories in RobWork
|
TrajectoryTransform3DVector_f |
Interface for Trajectories in RobWork
|
TrajectoryVector2D |
Interface for Trajectories in RobWork
|
TrajectoryVector2D_f |
Interface for Trajectories in RobWork
|
TrajectoryVector2D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector2D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector2DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector2DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector3D |
Interface for Trajectories in RobWork
|
TrajectoryVector3D_f |
Interface for Trajectories in RobWork
|
TrajectoryVector3D_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector3D_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector3DCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrajectoryVector3DPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Transform3D |
|
Transform3DAngleMetric_d |
distance metrics between points in SE3.
|
Transform3DAngleMetric_f |
distance metrics between points in SE3.
|
Transform3Df |
|
Transform3DVector |
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.
|
Transform3DVector_f |
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 tree-structured, with multiple end effectors.
Typical for dexterous hands, and multi-armed 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.
|
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.
|
TreeStateCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TreeStatePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Triangle |
plain triangle class.
|
Triangle_f |
plain triangle class.
|
TriangleCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleN1 |
Triangle facet.
|
TriangleN1_f |
Triangle facet.
|
TriangleN1CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleN1Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleN3 |
Triangle facet.
|
TriangleN3_f |
Triangle facet.
|
TriangleN3CPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleN3Ptr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TrianglePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleUtil |
utility for triangle manipulation
|
TriangleUtilCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriangleUtilPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriMesh |
interface of a triangle mesh.
|
TriMesh.TriCenterIterator |
struct for iterating over the centers of triangles in a mesh
|
TriMesh.VerticeIterator |
struct for iterating over the centers of triangles in a mesh
|
TriMeshCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriMeshPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriMeshSurfaceSampler |
random sampling of points and orientations close to the surface of a geometry.
A point p on the surface is randomly choosen.
A rotation rot is randomly generated.
A random distance d in the interval [minD, maxD] is generated
The position pos is calculated as pos = p - rot*(0,0,d)^T
The random pose X is thus X = (pos, rot)
Optionally a random rotation of X can be generated such that z-axis of rot is
not allways pointing toward the surface.
|
TriMeshSurfaceSamplerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriMeshSurfaceSamplerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectDeviller |
tests if two triangles are intersecting using devillers method.
- very robust triangle intersection test
- uses no divisions
- works on coplanar triangles
|
TriTriIntersectDeviller_f |
tests if two triangles are intersecting using devillers method.
- very robust triangle intersection test
- uses no divisions
- works on coplanar triangles
|
TriTriIntersectDeviller_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectDeviller_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectDevillerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectDevillerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectMoller |
tests if two triangles are intersecting using Thomas Mollers, 1997, no div method.
|
TriTriIntersectMoller_f |
tests if two triangles are intersecting using Thomas Mollers, 1997, no div method.
|
TriTriIntersectMoller_fCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectMoller_fPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectMollerCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TriTriIntersectMollerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
Tube |
a tube primitive.
|
TubeCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
TubePtr |
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.
|
UniversalJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
UniversalJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
VecotrVecotrULong |
|
Vector |
Configuration vector
|
vector_b |
|
vector_c |
|
vector_d |
|
vector_f |
|
vector_i |
|
vector_l |
|
vector_s |
|
vector_ui |
|
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;
|
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;
Vector2D<> v1(1.0, 2.0);
Vector2D<> v2(6.0, 7.0);
Vector2D<> v3 = cross( v1, v2 );
Vector2D<> v4 = v2 - v1;
|
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;
|
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 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;
|
Vector4Dd |
A N-Dimensional Vector
|
Vector4Df |
A N-Dimensional Vector
|
Vector5Dd |
A N-Dimensional Vector
|
Vector5Df |
A N-Dimensional Vector
|
Vector6Dd |
A N-Dimensional Vector
|
Vector6Df |
A N-Dimensional Vector
|
VectorComplexDouble |
|
VectorContact3D |
|
VectorEigenMatrix3d |
|
VectorEigenMatrix3f |
|
VectorEigenMatrix3id |
|
VectorEigenRowVector3d |
|
VectorEigenRowVector3f |
|
VectorEigenVector3d |
|
VectorEigenVector3f |
|
VectorEigenVector3id |
|
VectorExtensionPtr |
|
Vectorf |
Configuration vector
|
VectorFixedFrame |
|
VectorFramePtr |
|
VectorGeometryPtr |
|
VectorIndexedTriangle |
|
VectorJoint_p |
|
VectorLine |
|
VectorPair_d_d |
|
VectorPair_i_i |
|
VectorPair_s_s |
|
VectorParallelDeviceLeg |
|
VectorParallelDevicePtr |
|
VectorParallelLeg_p |
|
VectorParallelLegPtr |
|
VectorPathQ |
|
VectorPropertyValueBasePtr |
|
VectorProximityStrategyData |
|
VectorProximityStrategyDataPtr |
|
VectorQ |
|
VectorQConstraintPtr |
|
VectorQEdgeConstraintPtr |
|
VectorQuadraticCurve |
|
VectorQuaternion |
|
VectorRigidObjectPtr |
|
VectorRotation3D |
|
VectorRotation3D_f |
|
VectorSensorModelPtr |
|
VectorSerialDevicePtr |
|
VectorState |
|
VectorStateConstraintPtr |
|
VectorStateDataPtr |
|
VectorStopCriteriaPtr |
|
VectorThreadTaskPtr |
|
VectorTimedQ |
|
VectorTimedTransform3D |
|
VectorTrajectoryQPtr |
|
VectorTransform3D |
|
VectorTransform3D_f |
|
VectorTransform3dVector |
|
VectorTreeDevicePtr |
|
VectorTriangle |
|
VectorTriangle_f |
|
VectorTriangleN1 |
|
VectorTriangleN1_f |
|
VectorTriangleN3 |
|
VectorTriangleN3_f |
|
VectorVector2D |
|
VectorVector2D_f |
|
VectorVector3D |
|
VectorVector3D_f |
|
VectorVectorFrame |
|
VelocityScrew6D |
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.
|
VertexIdx |
vertice indexes of triangle
|
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.
|
VirtualJointCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
VirtualJointPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
WeightedEuclideanMetricQ |
Weighted Euclidean metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(\omega_i * (p_i - q_i))^2} .
|
WeightedEuclideanMetricVector2D |
Weighted Euclidean metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(\omega_i * (p_i - q_i))^2} .
|
WeightedEuclideanMetricVector3D |
Weighted Euclidean metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sqrt{\sum_{i=1}^{n}(\omega_i * (p_i - q_i))^2} .
|
WeightedInfinityMetricQ |
Weighted infinity norm metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n, the
distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
max_i |\omega_i * (p_i - q_i)|
|
WeightedInfinityMetricVector2D |
Weighted infinity norm metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n, the
distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
max_i |\omega_i * (p_i - q_i)|
|
WeightedInfinityMetricVector3D |
Weighted infinity norm metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n, the
distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
max_i |\omega_i * (p_i - q_i)|
|
WeightedManhattenMetricQ |
Weighted Manhattan distance metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sum_{i=1}^{n} |\omega_i * (p_i - q_i)| .
|
WeightedManhattenMetricVector2D |
Weighted Manhattan distance metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sum_{i=1}^{n} |\omega_i * (p_i - q_i)| .
|
WeightedManhattenMetricVector3D |
Weighted Manhattan distance metric for vector types.
Given a vector of weights \mathbf{\omega}\in\mathbb{R}^n ,
the distance between two points
P = (p_1, p_2, ..., p_n)
and
Q = (q_1, q_2, ..., q_n)
is defined as
\sum_{i=1}^{n} |\omega_i * (p_i - q_i)| .
|
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.WorkCellEventType |
WorkCell Event Types.
|
WorkCellCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
WorkCellDimension |
the WorkCellDimension describe a center and the box halflengths of
the space that the WorkCell expands.
|
WorkCellPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
WorkCellSceneCPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
WorkCellScenePtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
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.
|
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.
|
Z3Planner |
Z3 based planners
See "The Z3-Method for Fast Path Planning in Dynamic Environments", Boris
Baginski, 1996.
|
Z3PlannerPtr |
Ptr stores a pointer and optionally takes ownership of the value.
|
_n1 |
|
_n2 |
|
_n3 |
|
_n4 |
|
_n5 |
|
_n6 |
|
_n7 |
|
_n8 |
|