C_n1 | |
C_n2 | |
C_n3 | |
C_n4 | |
C_n5 | |
C_n6 | |
C_n7 | |
C_n8 | |
CActionType | Specification of Action Type |
CAddConfigToDevice | |
CAddDeviceToWorkcell | |
CAddFrameToDevice | |
CAddFrameToWorkcell | |
CAddJunctionToDevice | |
CAlignment | |
CAnyPtr | Smart pointer that can point to any type, and optionally takes ownership of the object pointer |
CAppendToOutput | |
CAppendToOutputFromMap | |
►CArchive | Archive interface for serializaion classes |
►CInputArchive | Archive interface for reading from a serialized class |
CBINArchive | Archive for loading and saving serializable classes |
CINIArchive | Archive for loading and saving serializable classes to an ini-file format |
►COutputArchive | Serializable objects can be written to an output archive |
CBINArchive | Archive for loading and saving serializable classes |
CINIArchive | Archive for loading and saving serializable classes to an ini-file format |
CARWExpand | ARWExpand expands a random walk in the configuration space by one step |
CARWPlanner | Adaptive Random Walk planners |
CAsciiPathSaver | Provides a set of methods for saving Path to ascii files |
CAssemblyControlResponse | The output from a AssemblyControlStrategy |
►CAssemblyControlStrategy | The interface for control strategies for assembly |
CCircularPiHControlStrategy | A AssemblyControlStrategy that can be used specifically for cylindric peg in hole operations |
CPiHStrategy | Control strategy for a Peg in Hole operation |
CSpiralStrategy | Control strategy for a Peg in Hole operation using a spiral search |
►CAssemblyParameterization | Interface for a parameterization that can be used by a AssemblyControlStrategy |
CCircularPiHParameterization | The parameterization used for the CircularPiHControlStrategy |
CPiHParameterization | Parameterization of a Peg in Hole action, used by the PiHStrategy |
CSpiralParameterization | Parameterization of a strategy that searches for a hole using a spiral strategy |
CAssemblyResult | A specification of the result from an execution of an AssemblyTask |
CAssemblySimulator | A simulator for execution of AssemblyTasks |
CAssemblyState | Information about the trajectory of the objects and sensor information during execution |
CAssemblyTask | Specification of a AssemblyTask |
►CATaskVisPlugin | |
CATaskVisPlugin | Plugin for visualization of assembly operations |
CMathematica::AutoExpression | Convenience class for automatic Expression deduction |
CBasicGPM | Implements a Gradient Projection Method (GPM) |
CBasicGPMM | Implements a Gradient Projection Method (GPM) |
►CBeamGeometry | Base class for discrete beam geometries |
CBeamGeometryCuboid | A cuboid beam |
CBeamObstaclePlane | A plane obstacle for a beam |
CBeamStartGuess | Utility functions for setting starting guesses for a beam model |
CBFGS | BFGS is a class including the BFGS minimization algorithm |
CBFGS::BFGS_function_struct | Minimisation function struct |
►CBinInputStream | |
CXMLInputStream | BinInputStream for wrappuing a std::istream |
►CBlend< T > | Interface for blending |
CParabolicBlend< rw::math::Vector3D< T > > | |
CLloydHaywardBlend< T > | Implements LloydHayward blending |
CParabolicBlend< T > | Forward declaration for parabolic blend to make the LinearInterpolator<rw::math::Transform3D<T> > a friend |
►CBlend< rw::math::Rotation3D< T > > | |
CLloydHaywardBlend< rw::math::Rotation3D< T > > | Template specialization of LloydHaywardBlend for using a rw::math::Rotation3D<T> |
CParabolicBlend< rw::math::Rotation3D< T > > | Template specialization of ParabolicBlend for using a rw::math::Rotation3D<T> |
►CBlend< rw::math::Transform3D< T > > | |
CLloydHaywardBlend< rw::math::Transform3D< T > > | Template specialization of LloydHaywardBlend for using a rw::math::Transform3D<T> |
CParabolicBlend< rw::math::Transform3D< T > > | Template specialization of ParabolicBlend for using a rw::math::Transform3D<T> |
►CBlend< V > | |
CLloydHaywardBlend< V > | |
CBMPLoader | |
►CBodyController | The body controller is a pure interface through which bodies are controlled |
CConstantForceManipulator | Class for adding a constant force to any body it controls |
CBodyInfo | Body info holds the values that determine the dynamic behavior of the body, such as mass and inertia |
►CBodyIntegrator | Abstract class for describing how the motion of a body behaves during a timestep |
CEulerIntegrator | Body motion integrator that use an implicit Euler formulation to calculate the motion of a body |
CRK4Integrator | |
CBtBody::BodyMetaData | Data structure to attach to bullet bodies, allowing friction and restitution to be specified separately for each pair of bodies |
CBodyUtil | Utility functions related to dynamic bodies |
CBoostXMLParser::BoostInitializer | Utility class which initializes Boost local static variables |
CLinearAlgebra::BoostMatrix< T > | Type for Boost matrices used to reduce namespace cluttering |
CBoxConstraint | A box constraint model |
CBtBody | Wrapper class for a bullet btRigidBody, that bridges between RobWork and Bullet |
►CbtCollisionAlgorithm | |
CBtRWCollisionAlgorithm | The RobWork implementation of a Bullet collision algorithm, using the standard ContactDetector |
►CbtCollisionAlgorithmCreateFunc | |
CBtRWCollisionAlgorithm::CreateFunc | Function for creating a BtRWCollisionAlgorithm |
►CbtCollisionConfiguration | |
CBtRWCollisionConfiguration | A collision configuration that uses the btCompoundCompoundCollisionAlgorithm and BtRWCollisionAlgorithm to handle contacts |
CBtConstraint | Allows constraining the motion between two bodies in Bullet simulation |
►CBtDevice | An interface for Bullet devices |
CBtPositionDevice | A position device |
CBtVelocityDevice | A velocity device |
CBtMaterial | Used as body userdata to be able to determine friction and restitution on contact pairs |
CBTPNode< BV, PRIM > | This node class stores the bv implicitly and use explicit pointers to its child nodes. This is an inefficient storage method and for general usage the other types should be used. However, there is only a small overhead for adding and deleting nodes so for very dynamic uses this might still be applicable |
CBtTactileSensor | Class for updating SimulatedTactileSensor from Bullet simulation |
CBtUtil | Utility functions that allows easy conversion between Bullet and RobWork types |
CProximityStrategyBullet::BulletModel | |
CBV< DERIVED > | General bounding volume class for template inheritance. This class defines methods that a deriving class must implement |
►CBV< AABB< T > > | |
CAABB< T > | Axis Aligned Bounding Box class |
►CBV< BSphere< T > > | |
CBSphere< T > | Class representing an Oriented Bounding Box (OBB) |
CBVCollider< COLLIDER, BVTYPE > | Abstract class describing interface of a bounding volume collision detector. The inheritance is template based to reduce virtual method overhead |
►CBVCollider< OBBCollider< T >, rw::geometry::OBB< T > > | |
COBBCollider< T > | Class for testing if two Oriented Bounding Boxes (OBBs) are overlapping. The method used is based on the seperating axis theorem. Please see the article "OBBTree: A Hierarchical Structure for Rapid Interference Detection" |
►CBVCollider< OBBToleranceCollider< T >, rw::geometry::OBB< T > > | |
COBBToleranceCollider< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
►CBVCollider< TriTriToleranceIntersect< T >, rw::geometry::Triangle< T > > | |
CTriTriToleranceIntersect< T > | Tests if two swept sphere triangles are intersecting. This corresponds to testing if two triangles are within a certain distqance (tolerance) of each other |
CBVTreeColliderFactory::BVDescentStrategy< DERIVED > | Template base class to deside which node to descent into |
►CBVTreeColliderFactory::BVDescentStrategy< BalancedDescentStrategy< BVTREE > > | |
CBVTreeColliderFactory::BalancedDescentStrategy< BVTREE > | Balanced descent strategy. The previous descent choice is saved and the oposite is choosen if |
►CBVTreeColliderFactory::BVDescentStrategy< MaxAreaDescentStrategy< BVTREE > > | |
CBVTreeColliderFactory::MaxAreaDescentStrategy< BVTREE > | |
CBVDistanceCalc< COLLIDER, BVTYPE > | |
►CBVDistanceCalc< RectDistanceCalc< T >, rw::geometry::OBRectangle< T > > | |
CRectDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
►CBVDistanceCalc< RSSDistanceCalc< T >, rw::geometry::OBB< T > > | |
CRSSDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
►CBVDistanceCalc< SphereDistanceCalc< T >, rw::geometry::BSphere< T > > | |
CSphereDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
►CBVDistanceCalc< TriDistanceCalc< T >, rw::geometry::Triangle< T > > | |
CTriDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
CBVFactory< BV > | Interface of bounding volume factory |
►CBVFactory< OBB< T > > | |
COBBFactory< T > | Factory for computing tight fitting Oriented Bounding Boxes |
►CBVTreeFactory::BVSplitterStrategy< BV > | Interface of bounding volume splitting strategy |
CBVTreeFactory::OBVMeanSplitter< BV > | Spatial Median splitting strategy. The median of the bounding volume projection extends are used as splitting point |
CBVTreeFactory::OBVMedianSplitter< BV > | Object median splitting strategy using axis of largest variance. Splits the mesh in the median on the axis with largest variance |
CBVTreeFactory::OBVSpatialMedianSplitter< BV > | Spatial Median splitting strategy. The median of the bounding volume projection extends are used as splitting point |
CBVTree< DERIVED > | This implementation defines a BVTree structure that use an indexed based storage representation. The implementation does not include functionality for building a BVTree. It is a data structure for accessing nodes in a bounding volume tree |
►CBVTree< BinaryBVTree< BV, PRIM > > | |
CBinaryBVTree< BV, PRIM > | Generic pointer based tree structure. This is not the most efficient structure for bounding volume trees. though it is quite generic and easy to work with because of its pointer based structure |
►CBVTree< BVTYPE > | |
CBVTree< DERIVED >::BVNode | |
►CBVTreeCollider< BVTREE > | This class encapsulates the methods for iterating through two hierachical OBV trees while testing if the BV's are disjoint |
COBVTreeDFSCollider< BVTREE, BVCOLLIDER, DESCENTSTRATEGY, PRIMCOLLIDER > | This tree collider is used for oriented bounding volumes. The collider traverse the trees in a depth first manner. The DESCENTSTRATEGY is used to choose which node the traversal should pick first. The collider only works on trees of the same type. The BVCOLLIDER and PRIMCOLLIDER is used to check is bounding volumes or primitives are colliding |
CBVTreeCollider< rw::proximity::rw::proximity::BinaryBVTree > | |
CBVTreeColliderFactory | Factory for creating tree colliders |
CBVTreeFactory | Factory for creating bounding volume trees |
CBVTreeIterator< DERIVED, BV > | |
►CBVTreeIterator< BTPNode< BV, PRIM >::NodeIterator, BV > | |
CBTPNode< BV, PRIM >::NodeIterator | Iterator for the PtrNode |
CBVTreeToleranceCollider< BVTREE > | This class encapsulates the methods for iterating through two hierachical OBV trees while testing if the OBV's are disjoint by more than a specified tolerance |
CCache< KEY, VAL > | This class is a template for caching |
CCache< CacheKey, btCollisionShape > | |
CCache< CacheKey, PQP::PQP_Model > | |
CCache< CacheKey, rw::proximity::ProximityStrategyRW::Model > | |
CCache< std::string, yaobi::CollModel > | |
►CCalibration | Calibration represents a kinematic correction |
CFixedFrameCalibration | Represents the calibration of a fixed frame |
CWorkCellCalibration | Calibration for a workcell which consists of a set of calibrations for different frames |
CCameraAttribute | |
►CCameraController | Interface for controlling the camera using a mouse |
CArcBallController | Use the ArcBallController method to control the camera view point in a scene |
CFixedAxisController | FixedAxis Camera Controller is used to control the camera position and orientation in relation to a pivot point where the rotations generated are around the fixed axis of the world |
CCameraGroup | A group of cameras |
CCameraListener | Interface used for listening for camera events |
CCameraMatrix< T > | The PerspectiveTransform2D is a perspective transform in 2D. The homographic transform can be used to map one arbitrary 2D quadrilateral into another |
CPathAnalyzer::CartesianAnalysis | Result struct for Cartesian analysis |
CCG3Grasp2DGen | Generates good grasp contacts for a 3 finger schunk hand |
CCG3IKSolver2D | Solves the inverse kinematics problem for a SDH |
CContactDataMap::ChatterjeeData | Data required for the Chatterjee collision model |
CModel3DS::ChunkHeader | |
CCircleModel | Model of a circle, represented as a normal, a center and a radius |
CPathAnalyzer::ClearanceAnalysis | Result struct for CleracenAnalysis |
►CClearanceCalculator | Interface for ClearanceCalculator |
CMinimumClearanceCalculator | Implements a MinimumClearanceCalculator |
CClearanceOptimizer | The ClearanceOptimizer implements the C-Retraction algorithms from [1] |
►Cclosure | |
Cresult_closure< ResultT > | |
CCNodePair | |
CCNodePairMap< T > | This implementation creates an efficient mapping between CNodePair and some user defined type. Lookup and insertion is O(1) |
CCNodePairMap< rwsim::simulator::ConstraintEdge * > | |
CCNodePool | Interface for creating and deleting constraintEdges and ConstraintNodes |
CColladaCore | |
CCollisionDetector | The CollisionDetector implements an efficient way of checking a complete frame tree for collisions |
CCollisionStrategy::Result::CollisionPair | Collision pair of |
CCollisionSetup | Setup for the collision checker |
CCollisionSetupLoader | Loader of collision setups from files |
CModel3DS::Color4i | |
►CDynamicWorkCellBuilder::ColorScheme | Color scheme specification |
CDynamicWorkCellBuilder::PaHColors | Default color scheme |
►CBREP::CommonCurveSet | Convenience type for a set of curves in a BREP |
CQuadraticBREP::CommonQuadraticCurveSet | Convenience type for a set of curves in a QuadraticBREP |
CSerialDeviceController::CompiledTarget | |
CConcatVectorIterator< T > | Forward iterator for the concatenation of a pair of vectors of pointers to T |
►CRWPEBody::Configuration | The configuration of a body. Bodies can inherit and extend this to use other representations internally. The basic Configuration of a body is the position as a Transform3D. If other representations are used, they must be able to convert back and forth between the Transform3D |
CRWPEBodyDynamic::RigidConfiguration | The configuration of a rigid body that extends the normal RWPEBody::Configuration with velocities |
CConstConcatVectorIterator< T > | Forward iterator for the concatenation of a pair of vectors of pointers to T |
CLogConstraints::Constraint | Information for a constraint |
CXQPController::Constraint | Constraint for the XQPController |
CConstraintEdge | |
CConstraintFactory | The ContactModelFactory functions as a mediator to the functionallity that is required by the contact graph |
CConstraintGenerator | Generates a set of constraints deduced from provided samples |
CConstraintNode | The ConstraintNode describes a specific object that can be constrained in some way. It is an interface that enables inheriting classes to be used by the ConstraintGraph class. The specific constraints between ConstraintNode's are described by the ConstraintEdge |
CConstraintSandbox | A class for testing out constraint generation methods |
►CConstraintSolver | Abstraction over a constraint solver for dynamics simulations |
CSequintialImpulseSolver | Constraint solver that use the sequential impulse algorithm for solving constraints. this algorithm is supposed to be equal to the Projected Gauss Seidel (PGS) algorithm |
CConstVectorIterator< T > | Forward iterator for vectors of pointers to const T |
CContact | |
CCollisionStrategy::Contact | Describes a simple collision contact data structure |
CContact2D | Data structure for describing a contact in 2D |
CContact3D | Data structure for describing a contact in 3D |
CContactCluster | Calculates contact clusters |
CContactDataMap | This class is a storage component for storing collision/contact data information |
CContactDetector | The ContactDetector allows detailed control of the strategies used for contact detection between specific frames and geometry types |
CContactDetectorData | Container for data that is stored by a contact detector between contact detection calls |
CContactDetectorTracking | Container for meta-data that can be used to track contact across multiple calls to contact detector, and allows attaching user specified data to the contact |
CContactGenerator | |
CContactGenerator | Generates candidate contact point sets for grasping a given object |
CContactGraph | Creates a graph where nodes can be physical, logical and compound entities and the edges between nodes are constraints of some sort |
CContactDetectorTracking::ContactInfo | Meta-data for a contact that allows it to be recalculated |
CContactManifold | A contact manifold is an area of contact between two objects, that exists for several timesteps in a simulated environment. For each timestep the manifold is updated with new contact points such that the manifold is dynamic |
CContactModel | The ContactModel describe how impulses between two bodies are calculated and added to the bodies. The contact model is supposed to be used for iterative solving impulses between two bodies |
►CContactModel | |
CGuendelContactModel | |
CContactModelFactory | The ContactModelFactory functions as a mediator to the functionallity that is required by the contact graph |
CContactPoint | Representation of a contact point |
CContactPointFilter | |
CContactPolygonQuality | A quality measure for contact between two objects. The measure use the area of the contact polygon as quality. For objects in 3d the contact polygon is the projection of all points onto some surface (normal) |
CContactStrategyData | Container for data that is stored by contact strategies between contact detection calls |
CContactStrategyTracking | Interface for a container of meta-data that can be used to track contact across multiple calls to a contact strategy, and allows attaching user specified data to the contact |
►CContactValidateFilter | Tests if a contact is valid in respect to some criterias implemented by a sub class |
CCompositeContactFilter | 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 |
CCurvatureThresFilter | Tests if a grasp is valid in respect to the curvature of the object surface in and around the contact points |
CPlaneClearanceFilter | Tests if a grasp is valid in respect to the distance of each contact point to some plane |
CContour2D | Class representing a 2d contour |
CContour2DGraspGen | Generates N good contact points on the 2D contour |
CContour2DInfoMap | Class for analysing 2d contours |
CContributor | |
►CController | Interface that defines functionality for control of devices and actuators |
►CJointController | Joint controller interface describe how to input to a joint controller. The output Force, Vel, Pos... must be available in the class implementing JointController interface |
CBeamJointController | The beamjoint controller controls a joint device composed of coupled beam joints. The coupling of beamjoints is somewhat special since its not an configuration space coupling (position) but rather a coupling of the forces acting on the joints |
CPDController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached |
CSpringJointController | |
CSyncPDController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached at the same time. The PD controls the joint position and velocity from a generated synchronous ramp profile |
CTrajectoryController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached at the same time. The PD controls the joint position and velocity from a generated synchronous ramp profile |
CVelRampController | JointController that use a velocityramp profile of a device to set acceleration, velocity and position of a dynamic device |
CBodyController | A Controller that use a PD loop to follow a trajectory generated from different target types. If the body is a Kinematic body then the velocities of the body is directly controlled, else wrenches are used to control the body |
CPoseController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached |
CAssemblyControlStrategy::ControlState | Derive from the ControlState class to implement state that is specific to a AssemblyControlStrategy |
CConvexHull2D | Interface for convexhull calculators on 2d point sets |
►CConvexHull3D | Interface for convexhull calculators on 3d point sets |
CQHull3D | Calculates the convex hull of a set of 3d points |
►CConvexHullND< N > | Interface for convexhull calculators on 3d point sets |
CQHullND< 6 > | |
CClarkHullND< N > | Calculates the convex hull of a set of 3d points |
CQHullND< N > | Calculates the convex hull of a set of 3d points |
CConvexHullTriangleInterface | |
CConvexHullVertex | |
CCovariance< T > | Class for estimating the covariance of different data |
CCSGConvert | |
CCSGConvert | |
CCSGModel | A CSG (Constructive Solid Geometry) model representation |
CCSGModel | A frontend class for doing CSG |
CCSGModelFactory | Factory class that allows construction of CSG model primitives |
CCSGUtil | A CSG utility class |
CCubicSplineFactory | Factory for creating cubic splines |
►CCurve | Curve is an abstract representation of a smooth curve geometry in 3D |
►CParametricCurve | Interface for parametric curves. A parametric curve, , has its points given as a function of a single parameter, |
CQuadraticCurve | A quadratic curve |
CDae | |
CDae::Data | |
CDelaunay | Utility functions for doing Delaunay triangulations |
CDependencyGraph | This class is used to create a dependency graph between string nodes and to check if any cycles exist in the dependency graph |
CExtension::Descriptor | An extension descriptor |
CDHParam | |
CDHParameterSet | Simple class to help represent a set of Denavit-Hartenberg parameters |
CDiceContactG3D | Generates candidate contact point sets (contact grasps) for grasping a given object. The nr of contacts per grasp is given by the user and a set of possibly good contact grasps are generated |
CPhysicsEngine::Dispatcher | Each engine implements a dispatcher that creates instances of the engine |
►CSimulatorLogEntryWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget |
CBodyMotionWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CCollisionResultWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CConstraintWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CContactSetWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CContactVelocitiesWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CEquationSystemWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CForceTorqueWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CLogMessageWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
CLogValuesWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
►CDispatcher | |
CRWPELogContactTrackingWidget::Dispatcher | |
CDistanceCalculator | The DistanceCalculator implements an efficient way of calculating different distances between two objects, each represented by a frame |
CDistanceUtil | Class for performing distance calculations between different geometric primitives |
CDistModel | |
CTactileArraySensor::DistPoint | |
CDOMBasisTypes | Utility class to help read in the content of a XML-files parsed with Xerces |
►CDOMElem | Wrapper interface for easy access to XML DOM parser. This require an active back-end that does the actual parsing and validation |
CBoostDOMElem | DOMElem based on Boost PropertyTree xml parser |
►CDOMErrorHandler | |
CXercesErrorHandler | Error handler for the Xerces parser |
CDOMParser | |
►CDOMParser | Interface for parsing documents in a DOM fasion |
CBoostXMLParser | DOMParser implementation based on the Boost xml parser in propertytree |
CDOMPathLoader | Enables loading in path file specified in the RobWork Path XML format |
CDOMPathSaver | Class used for saving a Path using the RobWork XML Path Format |
CDOMPropertyMapFormat | Class storing the identifiers used for properties |
CDOMPropertyMapLoader | Class for loading rw::common::PropertyMap from XML |
CDOMPropertyMapSaver | Class for saving rw::common::PropertyMap to XML |
CDOMProximitySetupLoader | Loader for the XML PropertySetup format |
CDOMProximitySetupSaver | Class for saving rw::proximity::ProximitySetup to XML |
CDOMTaskFormat | Definition of the identifier used in the task format |
CDOMTrajectoryLoader | Enables loading in trajectories file specified in the RobWork Trajectory XML format |
CDOMTrajectorySaver | Class for saving trajectories to file |
CDOMWorkCellSaver | Class for saving a WorkCell to a file |
CDrawableFactory | Factory for construction of drawables based on their type |
CSceneDescriptor::DrawableProxy | Proxy class to represent some type of loadable and drawable entity |
CDrawableUtil | Utility class for drawable stuff |
CRWPEFrictionModel::DryFriction | Specification of the dry friction |
CDummyCalibration | |
CDummyCollisionSetup | |
CDummyDevice | |
CDummyFrame | |
CDummyGeometry | |
CDummyLimit | |
CDummyModel | |
CDummyNode | |
CDummyProperty | |
CDummyProximitySetup | |
CDummyRigidBody | |
CDummyWorkcell | |
►CDynamicLibraryLoaderBase | Base for DynamicLibraryLoader |
CDynamicLibraryLoader< T > | Loader for dynamic/shared libraries |
CDynamicUtil | Utility functions for calculating dynamic properties |
CDynamicWorkCell | 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 |
CDynamicWorkCellBuilder | Helper for building Dynamic Workcells |
CDynamicWorkCellLoader | Class for loading of dynamic owrkcells |
CEBBeam | Class for calculating the analytical solution to the Euler-Bernoulli beam model in fixed-free configuration |
CEigenDecomposition< T > | Type representing a set of eigen values and eigen vectors |
CLinearAlgebra::EigenMatrix< T > | Type for Eigen matrices used to reduce namespace cluttering |
CLinearAlgebra::EigenVector< T > | Type for Eigen vectors, used to reduce namespace cluttering |
CEncoderDecentralization | Functions to compensate for encoder decentralization errors |
CEngineTest::EngineLoopInfo | The info passed in a callback function |
►CEngineTest | Generic test type for physics engines, which provides a factory for standard tests along with an extension point for user defined tests |
►CIntegratorTest | Common parent class for all integrator tests |
CIntegratorGravityTest | Test for linear free-falling motion |
CIntegratorRotationTest | Test for rotational motion |
CIntegratorSpringTest | Test for the motion when an undamped linear spring is used |
CEnterScope | |
►CEntity | Base class of object inserted into a Task |
CAction | Specification of an action in a task |
►CMotionBase | Base class for motions providing common interface |
►CMotion< T > | Specified the template based interface of a motion |
CCircularMotion< T > | Class describing circular motions |
CLinearMotion< T > | Class describing linear motions |
CP2PMotion< T > | Class describing point to point motions |
►CTargetBase | Base class for targets |
CTarget< T > | Template class implementing Target |
►CTaskBase | Base class for tasks |
►CGenericTask< Task< T >, Target< T >, Motion< T > > | |
CTask< T > | Template based implementation of Task |
CGenericTask< TASK, TARGET, MOTION > | Implements a template based and generic version of a task |
CEntityType | Type of an Entity |
►CErrorHandler | |
CXercesErrorHandler | Error handler for the Xerces parser |
CEvent< CallBackMethod, T1, T2, T3, T4 > | Event is used for managing subscribtions and firing of events |
CEvent< BodyChangedListener > | |
CEvent< BodyChangedListener, BodyEventType > | |
CEvent< CallBackMethod > | |
CEvent< DWCChangedListener > | |
CEvent< DWCChangedListener, DWCEventType, boost::any > | |
CEvent< FrameSelectedListener > | |
CEvent< FrameSelectedListener, rw::kinematics::Frame * > | |
CEvent< GenericAnyEventListener > | |
CEvent< GenericAnyEventListener, const std::string &, boost::any > | |
CEvent< GenericEventListener > | |
CEvent< GenericEventListener, const std::string & > | |
CEvent< KeyEventListener > | |
CEvent< KeyEventListener, int, Qt::KeyboardModifiers > | |
CEvent< MousePressedEventListener > | |
CEvent< MousePressedEventListener, QMouseEvent * > | |
CEvent< PositionSelectedListener > | |
CEvent< PositionSelectedListener, const rw::math::Vector3D<> & > | |
CEvent< PropertyListener > | |
CEvent< PropertyListener, PropertyBase * > | |
CEvent< StateChangedListener > | |
CEvent< StateChangedListener, const rw::kinematics::State & > | |
CEvent< StateDataAddedListener > | |
CEvent< StateDataAddedListener, const kinematics::StateData * > | |
CEvent< StateDataRemovedListener > | |
CEvent< StateDataRemovedListener, const kinematics::StateData * > | |
CEvent< StateTrajectoryChangedListener > | |
CEvent< StateTrajectoryChangedListener, const rw::trajectory::TimedStatePath & > | |
CEvent< WorkCellChangedListener > | |
CEvent< WorkCellChangedListener, int > | |
►Cexception | |
CException | Standard exception type of RobWork |
CExperiment | |
CExperiments | |
►CMathematica::Expression | A representation of a Mathematica expression |
►CMathematica::Array< T > | An Array primitive |
CRawArray< T, Dim > | Representation of a N-dimensional Mathematica array with fixed depth |
CRawArray< T, Dynamic > | Representation of a N-dimensional Mathematica array with dynamic depth |
►CMathematica::FunctionBase | A base interface for function expressions |
CFactorInteger | Representation of the Mathematica FactorInteger function |
CImage | Representation of the Mathematica Image function |
CList | Representation of the Mathematica List function |
CListPlot | Representation of the Mathematica ListPlot function |
CMathematica::Function | A user definable function expression |
►CMathematica::Packet | A Packet expression |
CEnterExpressionPacket | A Mathematica WSTP EnterExpressionPacket |
CEnterTextPacket | A Mathematica WSTP EnterTextPacket |
CEvaluatePacket | A Mathematica WSTP EvaluatePacket |
CInputNamePacket | A Mathematica WSTP InputNamePacket |
CMessagePacket | A Mathematica WSTP MessagePacket |
COutputNamePacket | A Mathematica WSTP OutputNamePacket |
CReturnExpressionPacket | A Mathematica WSTP ReturnExpressionPacket |
CReturnPacket | A Mathematica WSTP ReturnPacket |
CReturnTextPacket | A Mathematica WSTP ReturnTextPacket |
CTextPacket | A Mathematica WSTP TextPacket |
CRule | Representation of a Mathematica Rule |
CToExpression | Representation of the Mathematica ToExpression function |
CMathematica::Integer | An integer primitive |
CMathematica::Real | A real primitive |
CMathematica::String | A string primitive |
CMathematica::Symbol | A symbol primitive |
CExtension | Used to provide additonal functionality from a Plugin to other extension points of either the system or other plugins |
CExtensionPoint< ExtensionInterface > | 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 |
►CExtensionPoint< AssemblyControlStrategy > | |
CAssemblyRegistry | A registry of control strategies. The registry defines an extension point |
►CExtensionPoint< CollisionStrategy > | |
CCollisionStrategy::Factory | A factory for a CollisionStrategy. This factory also defines an ExtensionPoint |
►CExtensionPoint< CollisionToleranceStrategy > | |
CCollisionToleranceStrategy::Factory | A factory for a CollisionToleranceStrategy. This factory also defines an ExtensionPoint |
►CExtensionPoint< Dispatcher > | |
CPhysicsEngine::Factory | Factory for PhysicsEngine. This factory defines an extension point for PhysicsEngines |
►CExtensionPoint< DistanceMultiStrategy > | |
CDistanceMultiStrategy::Factory | A factory for a DistanceMultiStrategy. This factory also defines an ExtensionPoint |
►CExtensionPoint< DistanceStrategy > | |
CDistanceStrategy::Factory | A factory for a DistanceStrategy. This factory also defines an ExtensionPoint |
►CExtensionPoint< DOMParser > | |
CDOMParser::Factory | Factory for DOMParsers. This factory defines an extension point for DOMParsers. Typically this is for parsing xml files, however, anything that parses from some stream or file into a DOM structure can be a DOMParser |
►CExtensionPoint< EngineTest > | |
CEngineTest::Factory | A factory for engine tests. This factory also defines an ExtensionPoint |
►CExtensionPoint< ImageLoader > | |
CImageLoader::Factory | Factory for ImageLoader. This factory also defines an extension point for image loaders |
►CExtensionPoint< LuaLibrary > | |
CLuaState::Factory | Factory for LuaLibrary. This factory also defines an extension point for LuaLibraries. This permit users to define extensions to the lua interfaces through RobWork extension |
►CExtensionPoint< Model3DLoader > | |
CModel3DLoader::Factory | Factory for Model3DLoaders. This factory defines an extension point for Model3DLoaders |
►CExtensionPoint< ProximityStrategy > | |
CProximityStrategy::Factory | A factory for a ProximityStrategy. This factory also defines an ExtensionPoint |
►CExtensionPoint< QToTPlanner > | |
CQToTrajPlanner::Factory | Factory for QToTPlanner. This factory also defines an extension point for QToTPlanner. This permit users to add QToQPlanners that will be available through this factory |
►CExtensionPoint< rw::geometry::Primitive > | |
CGeometryFactory | Factory for geometric primitive |
►CExtensionPoint< RWPECollisionSolver > | |
CRWPECollisionSolver::Factory | A factory for a RWPECollisionSolver. This factory also defines an ExtensionPoint |
►CExtensionPoint< RWPEConstraintSolver > | |
CRWPEConstraintSolver::Factory | A factory for a RWPEConstraintSolver. This factory also defines an extension point for RWPEConstraintSolver |
►CExtensionPoint< RWPEContactResolver > | |
CRWPEContactResolver::Factory | A factory for a RWPEContactResolver. This factory also defines an extension point for RWPEContactResolver |
►CExtensionPoint< RWPEFrictionModel > | |
CRWPEFrictionModel::Factory | A factory for a RWPEFrictionModel. This factory also defines an ExtensionPoint |
►CExtensionPoint< RWPEIntegrator > | |
CRWPEIntegrator::Factory | A factory for a RWPEIntegrator. This factory also defines an extension point for RWPEIntegrator |
►CExtensionPoint< RWPERestitutionModel > | |
CRWPERestitutionModel::Factory | A factory for a RWPERestitutionModel. This factory also defines an ExtensionPoint |
►CExtensionPoint< RWPERollbackMethod > | |
CRWPERollbackMethod::Factory | A factory for a RWPERollbackMethod. This factory also defines an ExtensionPoint |
►CExtensionPoint< SimulatorLogEntry > | |
CSimulatorLogEntry::Factory | A factory for a SimulatorLogEntry. This factory also defines an extension point for SimulatorLogEntry |
►CExtensionPoint< SimulatorLogEntryWidget::Dispatcher > | |
CSimulatorLogEntryWidget::Factory | A factory for a SimulatorLogEntryWidget. This factory also defines an extension point for SimulatorLogEntryWidget::Dispatcher |
►CExtensionPoint< TaskLoader > | |
CTaskLoader::Factory | A factory for TaskLoader. This factory also defines an extension point for task loaders |
►CExtensionPoint< TaskSaver > | |
CTaskSaver::Factory | A factory for TaskSaver. This factory also defines an extension point for task savers |
►CExtensionPoint< WorkCellLoader > | |
CWorkCellLoader::Factory | Factory for WorkCellLoader. This factory also defines an extension point for workcell loaders |
CExtensionRegistry | 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 |
CBREP::Face | Face concept in the half-edge structure |
►CFace | Abstract interface for geometric faces |
CGenericFace | The GenericFace implementation is a type of Face that consist of abstract Surfaces and Curves |
CQuadraticFace | A Quadratic surface patch bounded by Quadratic curves |
CEngineTest::Failure | Format for a failure to an engine test |
CProximityStrategyFCL::FCLModel | Datatype to hold the FCL bounding volume and related geometrical data |
CFdUtil | Various numerical methods using finite-differences |
CFileCache< KEY, VAL, STAMP_T > | Cache that use a timestamp in combination with a key to determine the uniqueness of an item in the cache |
CFilteredPoint | |
CFireFunctor< CallBackMethod, T1, T2, T3, T4, T5 > | FireFunctor with 0 arguments |
CFireFunctor< BodyChangedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< BodyChangedListener, BodyEventType, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< CallBackMethod, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< CallBackMethod, T1, _n1, _n1, _n1, _n1 > | FireFunctor with 1 arguments |
CFireFunctor< CallBackMethod, T1, T2, _n1, _n1, _n1 > | FireFunctor with 2 arguments |
CFireFunctor< CallBackMethod, T1, T2, T3, _n1, _n1 > | FireFunctor with 3 arguments |
CFireFunctor< CallBackMethod, T1, T2, T3, T4, _n1 > | FireFunctor with 4 arguments |
CFireFunctor< CallBackMethod, T1, T2, T3, T4, rw::common::_n1 > | |
CFireFunctor< DWCChangedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< DWCChangedListener, DWCEventType, boost::any, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< FrameSelectedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< FrameSelectedListener, rw::kinematics::Frame *, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< GenericAnyEventListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< GenericAnyEventListener, const std::string &, boost::any, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< GenericEventListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< GenericEventListener, const std::string &, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< KeyEventListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< KeyEventListener, int, Qt::KeyboardModifiers, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< MousePressedEventListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< MousePressedEventListener, QMouseEvent *, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< PositionSelectedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< PositionSelectedListener, const rw::math::Vector3D<> &, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< PropertyListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< PropertyListener, PropertyBase *, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateChangedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateChangedListener, const rw::kinematics::State &, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateDataAddedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateDataAddedListener, const kinematics::StateData *, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateDataRemovedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateDataRemovedListener, const kinematics::StateData *, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateTrajectoryChangedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< StateTrajectoryChangedListener, const rw::trajectory::TimedStatePath &, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< WorkCellChangedListener, _n1, _n1, _n1, _n1, rw::common::_n1 > | |
CFireFunctor< WorkCellChangedListener, int, _n1, _n1, _n1, rw::common::_n1 > | |
CFixtureConstraint | A fixture constraint model |
CFKRange | Forward kinematics between a pair of frames |
CFKTable | Forward kinematics for a set of frames |
CAsciiPathSaver::Format | Specifies the format to use when saving |
CFunctionFactory::FPtr< RES_T, ARG_T > | |
►CFrameGrabber | The FrameGrabber abstract interface, can be used to grab images from a specialized source |
CGLFrameGrabber | An implementation of the FrameGrabber interface. The GLFrameGrabber grabs images from a OpenGL scene using a simple pinhole camera model |
►CFrameGrabber25D | The FrameGrabber25D abstract interface, can be used to grab images from a specialized source |
CGLFrameGrabber25D | An implementation of the FrameGrabber interface. The GLFrameGrabber25D grabs images from a OpenGL scene using a simple pinhole camera model |
CFrameMap< T > | Specialized mapping implementation for frames. It uses the internal structure of Frames to provide fast O(1) lookup for mappings from Frame to anything |
CFrameMap< dynamics::RigidBody * > | |
CFrameMap< Eigen::MatrixXd::Index > | |
CFrameMap< int > | |
CFrameMap< math::Transform3D<> > | |
CFrameMap< rw::common::rw::common::Ptr< rw::proximity::ProximityModel > > | |
CFrameMap< rw::proximity::ProximityModel::Ptr< CollisionDetector > > | |
CFrameMap< rw::proximity::ProximityModel::rw::common::Ptr > | |
CFrameMap< rwsim::dynamics::RigidBody * > | |
CFrameMap< rwsim::dynamics::RigidBody::Ptr > | |
CFrameMap< rwsim::simulator::ConstraintNode * > | |
CFrameMap< rwsim::simulator::RWBody * > | |
CFrameMap< std::list< rw::proximity::ProximitySetupRule > > | |
CFrameMap< std::map< rw::common::Ptr< rw::geometry::Geometry >, rw::common::Ptr< rw::proximity::ProximityModel > > > | |
CFrameMap< std::map< std::string, rw::common::rw::common::Ptr< rwsim::contacts::ContactModel > > > | |
CFrameMap< std::vector< rw::common::rw::common::Ptr< rw::geometry::Geometry > > > | |
CFrameMap< std::vector< std::string > > | |
CFrameType | Enumeration of all concrete frame types of RobWork |
CFrictionData | Definition of a friction model |
►CFunction< RES_T, ARG_T > | Interface for functions |
►CFunction1Diff< RES_T, ARG_T, GRAD_T > | Interface for functions which are 1 time differentiable |
CFunction1DiffWrapper< RES_T, ARG_T, GRAD_T > | |
CFunctionWithNumericalDerivative< RES_T, ARG_T, GRAD_T > | |
►CFunctionWrapper< RES_T, ARG_T > | |
CFunction1DiffWrapper< RES_T, ARG_T, GRAD_T > | |
CFunctionFactory | |
CGeometry | |
CGeometry | Class for representing a geometry that is scaled and transformed, and which is attached to a frame |
►CGeometryData | Interface for geometry data |
►CBREP | Boundary representation (or B-Rep) of a geometric shape, using a collection of connected surfaces, edges and vertices |
CQuadraticBREP | A boundary representation where the geometry of a face is a QuadraticSurface, and an edge curve is a QuadraticCurve |
CPointCloud | A simple point cloud data structure. Points may be ordered or not. An ordered set is kept as a single array in row major order and with a width and a height. An unordered array must have height==1 and width equal to the number of points |
►CPrimitive | Defines an interface for a geometric shape that is defined by a set of parameters |
CBox | Box primitive, origin is in center of box |
CCone | Cone primitive. Like a cylinder though where a radius can be specified for both ends |
CCylinder | Cylinder primitive. radius is in x-y plane and height is in z-axis |
CJawPrimitive | Parametrized jaw geometry primitive |
►CLine | A line in 3D, described by a two points |
CRay | A ray - an infinitely extending half-line described by a starting position and a direction |
CPlane | Plane primitive represented in Hessian normal-form: a*nx+b*ny+c*nz+d=0 |
CPyramid | Pyrimidal geometric primitive. The pyramid has a rectangular base in the xy-plane and its end pointed lie in the z-axis with a distance from the xy-plane |
CSphere | Sphere primitive. centr in (0,0,0) and a radius |
CTube | Tube primitive. radius is in xy-plane and height is in z-axis |
CSimpleFinger | |
►CShell | A shell represents the geometry of an object as a collection of non-connected faces |
CIndexedFaceArray | 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 |
►CQuadraticShell | A collection of Quadratic surface patches, that together form a shell |
CIndexedQuadraticFaceArray | Proxy class for a QuadraticShell, that allows sorting of faces without modifying the original object |
CPlainQuadraticShell | A collection of concrete Quadratic surface patches, that together form a shell |
►CTriMesh | Interface of a triangle mesh. The interface defines a way to get triangles from a triangle array/mesh |
►CIndexedTriMesh< float > | |
CIndexedTriMeshN0< float > | |
CPlainTriMesh< rw::geometry::Triangle<> > | |
CIndexedTriArray< T > | This class is a proxy to a triangle mesh where the triangles can be indirectly copied in an efficient manner |
►CIndexedTriMesh< T > | Interface for indexed triangle meshes |
CIndexedTriMeshN0< T, S > | Indexed Triangle mesh with zero normals |
CPlainTriMesh< TRI > | Triangle mesh representation that maintains a list of simple triangles |
CTriMesh | Interface of a triangle mesh. The interface defines a way to get triangles from a triangle array/mesh |
CBtBody::GeometryMetaData | Data structure to attch to bullet collision shapes |
CContactModelGeometry< A, B >::GeometryModel< T > | Model for each geometry |
CGeometryUtil | Utility functions for calculating properties of geometry |
CGrasp2D | Grasp is a set of contacts between the object to be grasped and the robot gripper |
CGrasp3D | Grasp is a set of contacts between the object to be grasped and the robot gripper |
CGraspTable::GraspData | Data for describing a single grasp |
CGraspDB | |
CGraspTaskSimulator::GraspedObject | |
►CGraspPolicy | Grasp policy defines how a grasp is executed from some initial configuration |
CTargetConfigGraspPolicy | This grasp policy will close the fingers of a device to a randomly choosen target position which is generated either from a predefined set of target configurations or from one of the selected hueristics |
CGraspPolicyFactory | |
CGraspQualityFactory | |
►CGraspQualityMeasure3D | Interface for methods evaluating the quality of a specific grasp |
CApproachMeasure3D | Computes the quality as a function of the angle between the approach angle and some planar surface |
CCMDistCCPMeasure3D | Computes the quality as a function of the distance between the center of mass (COM) and the Center of the Contact Polygon (CCP) |
CGWSMeasure3D | Represents the grasp wrench space as a 3D force space and a 3D torque space |
CWrenchMeasure3D | Represents the grasp wrench space as a 3D force space and a 3D torque space |
►CGraspRestingPoseDialog | |
CGraspRestingPoseDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CGraspResult | Describes the result of a single grasp |
CSBGraspPlanner3D::GraspResult | Configuration of pregrasp and actual grasp |
CGraspStrategy | GraspStrategy define how the initial configuration of a grasping system is generated |
CGraspStrategyFactory | |
CGraspSubTask | Describes a sub task of overall grasp task |
CGraspTable | A table of grasp configurations that has been generated using a robot hand, a number of preshapes, and some grasp policy |
CGraspTarget | Represents a single target for grasping (described as a pose), and its result |
CGraspTask | A container for describing one or multiple grasping tasks. It is based on the rwlibs::tasks library |
►CGraspTaskSimulator | A class for simulating multiple grasping tasks |
CGripperTaskSimulator | Used to simulate tasks for a specific gripper and evaluate gripper |
►CGraspValidateFilter | Tests if a grasp is valid in respect to some criterias implemented by a sub class |
CCompositeGraspFilter | 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 |
CContactDistThresFilter | Tests if contact points in a grasp is too close or too far from each other |
CCurvatureThresFilter | Tests if a grasp is valid in respect to the curvature of the object surface in and around the contact points |
CPlaneClearanceFilter | Tests if a grasp is valid in respect to the distance of each contact point to some plane |
CSemiForceClosureFilter | A conservative estimate of the force closure properties of the grasp are used to indicate weather a grasp is valid or not |
CGripper | Gripper device (parallel jaw gripper) with parametrized geometry and kinematic and dynamic parameters |
CGripperQuality | |
CGripperXMLLoader | Class for loading grippers from xml files |
►CGTaskVisPlugin | |
CGTaskVisPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
CBREP::HalfEdge | Half-edge structure |
CHelpAssistant | Help assistant for RobWorkStudio |
CHGraspPlanner3D | Grasp planner for 3D objects |
CHughLineExtractor | |
CHullDesc | |
CHullLibrary | |
CHullResult | |
CHyperSphere | A hyper-sphere of K dimensions |
CImage | The image class is a simple wrapper around a char data array. This Image wrapper contain information of width, height and encoding |
►CImageLoader | Image loader interface |
CPGMLoader | Loads images in Portable Gray Map (PGM) format |
CPPMLoader | Loads images in Portable Pixel Map (PPM) format |
CRGBLoader | Loads images in Silicon Graphics RGB format |
CImageUtil | Collection of simple image utility functions |
CImageUtil | |
CImportInterface | Defines an interface for importing user defined functionality into RobWork. Objects that can be imported will can be of arbitrary type. There is two usage patterns of this interface: |
CIndexedArray< OBJ, T > | |
CIndexedFaceArray::IndexedFace | Structure that holds information for each face |
CIndexedQuadraticFaceArray::IndexedFace | Structure that holds information for each face |
►CIndexedPolygon< T > | Indexed polygon class that saves N indices to the N vertices of the polygon |
CIndexedPolygonN< T > | Polygon with N vertice indices and 0 normals |
CIndexedPolygonNN< T > | Polygon with N vertices and N normals |
CIndexedTriangle< T > | 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 |
CIndexedTriangleN1< T > | Indexed triangle class with an additional index for an face normal |
CIndexedTriangleN3< T > | Indexed triangle class with an additional index for 3 normals one for each vertice in the triangle |
CInertiaMatrix< T > | A 3x3 inertia matrix |
CDOMPathSaver::Initializer | Utility class which initializes local static variables |
CDOMPropertyMapFormat::Initializer | Utility class which initializes local static variables |
CDOMPropertyMapLoader::Initializer | Utility class which initializes local static variables |
CDOMPropertyMapSaver::Initializer | Utility class which initializes local static variables |
CDOMProximitySetupSaver::Initializer | Utility class which initializes local static variables |
CDOMTrajectoryLoader::Initializer | Utility class which initializes local static variables |
CDOMTrajectorySaver::Initializer | Utility class which initializes local static variables |
CXMLBasisTypes::Initializer | Utility class which initializes local static variables |
CXMLPathFormat::Initializer | Utility class which initializes local static variables |
CXMLPathLoader::Initializer | Utility class which initializes local static variables |
CXMLPathSaver::Initializer | Utility class which initializes local static variables |
CXMLPropertyFormat::Initializer | Utility class which initializes local static variables |
CXMLPropertyLoader::Initializer | Utility class which initializes local static variables |
CXMLPropertySaver::Initializer | Utility class which initializes local static variables |
CXMLProximitySetupFormat::Initializer | Utility class which initializes local static variables |
CXMLProximitySetupLoader::Initializer | Utility class which initializes local static variables |
CXMLTrajectoryLoader::Initializer | Utility class which initializes local static variables |
CXMLTrajectoryFormat::Initializer | Utility class which initializes local static variables |
CXMLTrajectorySaver::Initializer | Utility class which initializes local static variables |
CDOMTaskFormat::Initializer | Utility class which initializes local static variables |
CDOMTaskSaver::Initializer | Utility class which initializes local static variables |
CXMLTaskFormat::Initializer | Utility class which initializes local static variables |
CXMLTaskLoader::Initializer | Utility class which initializes local static variables |
CXMLTaskSaver::Initializer | Utility class which initializes local static variables |
CDOMBasisTypes::Initializer | Utility class which initializes local static variables |
CDOMPathLoader::Initializer | Utility class which initializes local static variables |
►CInputSource | |
CInputStreamSource | Xerces input source for using std::istream |
CInsertInMap | |
CInsertLimitInMap | |
CInsertModelInMap | |
CInsertPropertyInMap | |
CInteriorPointOptimizer | |
►CInterpolator< T > | Interface for interpolators |
CCircularInterpolator< T > | Circular interpolator |
CCubicSplineInterpolator< T > | This class represents a 3-degree polynomial function, used in Cubic Splines hence the name CubicSegment |
CFixedInterpolator< T > | Implements a fixed value interpolator |
CLinearInterpolator< T > | Make a linear interpolation between to position |
CRampInterpolator< T > | Make a ramp interpolation between two position |
►CInterpolator< double > | |
CRampInterpolator< double > | |
►CInterpolator< rw::math::Q > | |
CRampInterpolator< rw::math::Q > | |
►CInterpolator< rw::math::Rotation3D< T > > | |
CCubicSplineInterpolator< rw::math::Rotation3D< T > > | |
CLinearInterpolator< rw::math::Rotation3D< T > > | Implements LinearInterpolator for rw::math::Rotation3D<T> |
CRampInterpolator< rw::math::Rotation3D< T > > | Implements RampInterpolator for rw::math::Rotation3D<T> |
►CInterpolator< rw::math::Rotation3D<> > | |
CLinearInterpolator< rw::math::Rotation3D<> > | |
CRampInterpolator< rw::math::Rotation3D<> > | |
►CInterpolator< rw::math::Transform3D< T > > | |
CCubicSplineInterpolator< rw::math::Transform3D< T > > | |
CLinearInterpolator< rw::math::Transform3D< T > > | Implements LinearInterpolator for rw::math::Transform3D<T> |
CRampInterpolator< rw::math::Transform3D< T > > | Implements RampInterpolator for rw::math::Transform3D<T> |
►CInterpolator< rw::math::Vector3D< T > > | |
CCircularInterpolator< rw::math::Vector3D< T > > | Makes circular interpolation based on rw::math::Vector3D |
CRampInterpolator< rw::math::Vector3D< T > > | Implements RampInterpolator for rw::math::Vector3D<T> |
►CInterpolator< rw::math::Vector3D<> > | |
CLinearInterpolator< rw::math::Vector3D<> > | |
CRampInterpolator< rw::math::Vector3D<> > | |
►CInterpolator< V > | |
CInterpolatorUtil::Transform2VectorWrapper< V, T > | Wraps an interpolator using rw::math::Transform3D<T> to interpolator with a vector with 7 elements |
CInterpolatorUtil | Utilities used in the implementation of various interpolators and blends |
CIntersectUtil | Utility class for calculating intersection points between geometry primitives |
►CInvKinSolver | Interface for inverse kinematics algorithms |
CAmbiguityResolver | Wraps a InvKinSolver and searches for ambiguities due to joint able to rotate or more |
►CClosedFormIK | Interface for closed form inverse kinematics algorithms |
CClosedFormIKSolverKukaIIWA | Analytical inverse solver for the Kuka LBR IIWA 7 R800 robot |
CClosedFormIKSolverUR | Analytical inverse kinematics solver to the kinematics of a Universal Robots |
CPieperSolver | Calculates the closed form inverse kinematics of a device using Piepers method |
►CIterativeIK | Interface for iterative inverse kinematics algorithms |
CCCDSolver | This inverse kinematics method is a heuristic search technique called the Cyclic-Coordinate Descent method. The method attempts to minimize position and orientation errors by varying individual joints at a time |
CIKMetaSolver | Solve the inverse kinematics problem with respect to joint limits and collisions |
CJacobianIKSolver | A Jacobian based iterative inverse kinematics algorithm for devices with a single end effector |
CParallelIKSolver | Inverse kinematics method for parallel devices |
CIKQPSolver | Iterative inverse kinematics solved based on the QPController |
CIOUtil | Collection of IO related utilities |
►CIterativeMultiIK | Interface for iterative inverse kinematics algorithms for problems or devices that utilize more than one end-effector |
CJacobianIKSolverM | A Jacobian based iterative inverse kinematics algorithm for devices with multiple end effectors |
CIKGPMMSolver | Iterative inverse kinematics solved based on the QPController |
CDOMElem::Iterator | DOMElem iterator based on concrete ItImpl implementations |
►Citerator | |
CMultipleFileIterator | This class is used to iterate over multiple files, keeping track of the current file and current line number at all times |
CDOMElem::ItImpl | The DOMElem Iterator is initialized with a specific implementation of this interface |
CJacobian | A Jacobian class. A jacobian with m rows and n columns |
►CJacobianCalculator | JacobianCalculator provides an interface for obtaining a Jacobian |
CDeviceJacobianCalculator | Calculator for Jacobians of one or several Devices |
CJointDeviceJacobianCalculator | Calculator for Jacobians of a JointDevice |
CJacobianUtil | Primitive utilities for computing jacobians for joints of various types |
CPathAnalyzer::JointSpaceAnalysis | Result struct for joint space analysis |
CKDTree< KEY, DIM >::KDNode | Struct for the node in the tree |
CKDTreeQ< VALUE_TYPE >::KDNode | Struct for the node in the tree |
CKDTree< KEY, DIM >::KDResult | |
CKDTreeQ< VALUE_TYPE >::KDResult | |
CKDTree< KEY, DIM > | Space partitioning structure for organizing points in k-dimensional space. Used for searches involving multi.dimensional search keys, including nearest neighbor and range search |
CKinematicBody::KinematicBodyState | State data for a kinematic body |
CKinematics | Utility functions for the rw::kinematics module |
CLeaveScope | |
CLightAttribute | |
CConstraint::Limit | Definition of a limit for one single degree of freedom |
CLine2D | Describes a line segment in 2D |
CLine2DPolar | Describes a line in 2D in polar coordinates |
CLinearAlgebra | Collection of Linear Algebra functions |
CLinePolar | |
CMathematica::Link | Representation of a link |
CEvent< CallBackMethod, T1, T2, T3, T4 >::Listener | Structure for data associated to a listener |
CLog | Provides basic log functionality |
►CLogWriter | Write interface for Logs |
CLogBufferedChar | Buffers characters before writing them to the output stream |
CLogBufferedMsg | Buffers messages before writing them to the output stream |
CLogFileWriter | Writes log output to a file |
CLogMultiWriter | Writes log output to multiple LogWriters |
CLogStreamWriter | Writes log output to a std::ostream |
►CLuaEditorWindow | |
CLuaEditorWindow | |
CLuaState::LuaLibrary | |
CLuaState | Robwork wrapper for the lua_State struct. The standard robwork lua libs will be initialized automatically. Also this provides an extension point for adding user defined lua enabled libraries |
CEigenDecomposition< T >::MapSort | Sort function for ordering of eigen values and vectors |
CModel3DS::Material | |
CModel3D::Material | Describes material properties. A material can be either simple or "advanced" and in both cases it can be textured. A simple material is described by a 4-tuple of RGBA values. The advanced material defines multiple properties: diffuse, ambient, emissive, specular, shininess and transparency |
CMaterialDataMap | A map of materials and friction models defined between materials |
CModel3DS::MaterialFaces | |
CModel3D::MaterialFaces | Ordering triangles by material consumes more memmory but reduce switches between textures. All indices _subFaces share material _matIndex |
CModel3D::Object3D::MaterialMapData | Mapping from triangles to materials |
CModel3D::MaterialPolys | Ordering polygons by material consumes more memmory but reduce switches between textures. All indices _subFaces share material _matIndex |
CMath | Utility functions for the rw::math module |
CMathematica | Implementation of the Wolfram Symbolic Transfer Protocol (WSTP) to allow communication with Mathematica |
CMessage | Standard type for user messages of robwork |
►CMetric< T > | Template interface for metrics on type T |
CEuclideanMetric< T > | Euclidean distance metric for vector types |
CInfinityMetric< T > | Infinity norm distance metric for vector types |
CMahalanobisMetric< T > | Mahalanobis distance metric for vector types |
CManhattanMetric< T > | Manhattan distance metric for vector types |
CWeightedEuclideanMetric< T > | Weighted Euclidean metric for vector types |
CWeightedInfinityMetric< T > | Weighted infinity norm metric for vector types |
CWeightedManhattanMetric< T > | Weighted Manhattan distance metric for vector types |
CMetric< KEY > | |
►CMetric< Line > | |
CLineMetric | A metric for calculating line-to-line distance |
►CMetric< Plane > | |
CPlaneMetric | A metric for calculating plane-to-plane distance |
CMetric< rw::math::Q > | |
►CMetric< rw::math::Rotation3D< T > > | |
CRotation3DAngleMetric< T > | Distance metric over rotations. The distance between two rotations is the smalles angle that rotates the one into the other |
►CMetric< rw::math::Transform3D< T > > | |
CTransform3DAngleMetric< T > | Distance metrics between points in SE3 |
CMetricFactory | Metric constructor functions |
CMetricUtil | Various metrics and other distance measures |
CProximityStrategyRW::Model | |
CModel3D | 3d model that has geometry but also material, color and texture information. the model can be composed of multiple objects that are connected in a hierarchical manner. The model is designed for efficient drawing and as such special structures are used to order the indexes such that efficient drawing is possible |
CModel3DFactory | Factory for construction of drawables based on their type |
►CModel3DLoader | Interface for classes that are able to load 3d models |
CLoader3DS | This class loads 3DS geometry into a Model3D object |
CLoaderAC3D | This class loads AC3D geometry into a Model3D object |
CLoaderAssimp | Load 3D models using the Open Asset Import Library (Assimp) |
CLoaderOBJ | Class for loading in IVG files. TODO: add documentation on IVG format |
CLoaderTRI | Loader for a simple ASCI based triangle format. The format is NOT a standard. There are two elements in the format each is defined in a line |
►CModel3DLoader | |
CLoaderIVG | Class for loading in IVG files |
CModel3DS | |
CModels | Utility functions for the rw::models module |
►CModRusselBeamBase | Base class for implementing Modified Russel beam problems |
CModRusselBeamIpopt | Implementation of the Modified Russel Beam Problem using IPOPT |
CMoment | |
CRecursiveNewtonEuler::Motion | Motion of a body defined as velocity and acceleration |
CMotionType | Specification of Action Type |
CMovingAverage | |
CMovingAverage | Calculates the moving average over a continues input of samples |
CContactDataMap::NewtonData | Data required for the Newton collision model |
CNewtonEulerDynamics | This class calculates the newton euler dynamics of a serial robot with external forces on individual joints |
CBVTree< DERIVED >::nodeiterator | |
CNullSpaceProjection | Performs a projection in the null space of the device Jacobian to move joints away from singularities |
►CNumericalDerivative< RES_T, ARG_T, GRAD_T > | |
CFirstDifferences< RES_T, ARG_T, GRAD_T > | |
COBB< F > | |
CModel3DS::Object | |
CModel3D::Object3D | A 3d object consisting of geometry information, material and texture |
COBRManifold | Contact manifold based on Oriented Bounding Rectangle, so in 2D |
COBV< DERIVED > | General oriented bounding volume class |
►COBV< OBB< T > > | |
COBB< T > | Class representing an Oriented Bounding Box (OBB) |
►COBV< OBLSS< T > > | |
COBLSS< T > | Class representing an Oriented Bounding Box (OBLSS) |
►COBV< OBRSS< T > > | |
COBRSS< T > | Class representing an Oriented Bounding Box (OBRSS) |
COBVDistanceCalc< COLLIDER, BVTYPE > | |
CODEBody | Convienience class for bridging RWSim body states with ode body states. Properties of the objects such as MaterialID, collision reduction threshold is kept per instance |
CODEConstraint | Allows constraining the motion between two bodies in ODE simulation |
►CODEDevice | Interface for classes (ODEDevices) that control a set of ode bodies that map to a RWSim dynamic device type |
CODEKinematicDevice | A bridge between the RW KinematicDevice and kinematicly controlled ODE dBodies |
CODESuctionCupDevice | Interface for classes (ODEDevices) that control a set of ode bodies that map to a RWSim dynamic device type |
CODEVelocityDevice | A bridge between the RW RigidDevice and a set of connected joints and rigid bodies |
CODEJoint | This class bridges ODE's joints with RobWork joints. The joint is a pure constraint type and hence does not have any geometry. It does however constraint two geometrical bodies together |
CODEMaterialMap | The ODE material map is responsible for the modelling of contact dynamics, such as friction and restitution phenomena |
CODESimulator::ODEStateStuff | |
CODETactileSensor | |
CODEThreading | Utility functions related to the use of Open Dynamics Engine from multiple threads |
CODEUtil | |
►COptimizer | Base class for function optimizers |
►CDirectionSetOptimizer | |
CPowellOptimizer | |
CTaxiCabOptimizer | |
CDownhillOptimizer | |
►CGradientOptimizer | |
CBFGSOptimizer | |
CGradientDescentOptimizer | Implements simple gradient descent algorithm |
►CLineSearch | |
CGoldenSectionLineSearch | |
CSimulatedAnnealingOptimizer | |
COptimizerFactory | |
COS | Encapsulates os dependent functionality |
CPairMap< T1, T2 > | Specialized mapping implementation for pairs. It uses the internal structure of template T1 to provide fast O(1) lookup for mappings from a Pair to anything. The order of the Pairs does not matter |
►CPairMap< const Frame *, double > | |
CFramePairMap< double > | |
►CPairMap< const Frame *, int > | |
CFramePairMap< int > | |
►CPairMap< const Frame *, std::vector< dynamics::ContactManifold > > | |
CFramePairMap< std::vector< dynamics::ContactManifold > > | |
►CPairMap< const Frame *, T > | |
CFramePairMap< T > | A map from an unordered pair of frames to some value |
CParallelGraspPlanner | This |
CParallelLeg | Class representing a single leg in a ParallelDevice |
CDownhillOptimizer::Parameters | Downhill optimizer parameters |
►Cparser | |
CXMLAttElemParser< ParsableAttrT, ParsableElemT > | Parser for xml elements with both attributes and child elements |
CXMLAttParser< ParsableAttT > | |
CColladaLoader::ParserState | |
CPartialIndexTable< T, Cell > | Provides an Partial Index Table to be used for nearest neighbor search |
CPathAnalyzer | The PathAnalyzer provides a set a basic tools for analyzing a path |
CPathLengthOptimizer | The PathLengthOptimizer implements the 3 different path length optimizers presented in [1] |
CPathLoader | Load and store for various types of paths |
CPathLoaderCSV | Loader for .csv files |
CPathPlanner< From, To, Path > | Path planner interface |
►CPathPlanner< rw::math::Q, const rw::math::Q > | |
►CQToQPlanner | Path planner interface |
CARWQToQPlanner | Adaptive Random Walk Planner |
CPRMPlanner | Implements a probabilistic roadmap (PRM) planner |
CZ3QToQPlanner | Z3 based point-to-point planner |
►CPathPlanner< rw::math::Q, const rw::math::Transform3D<> > | |
CQToTPlanner | Approach planner interface |
►CPathPlanner< rw::math::Q, QSampler > | |
CQToQSamplerPlanner | Sampled region planner interface |
►CPathPlanner< rw::math::Q, rw::trajectory::Transform3DTrajectory::Ptr > | |
CQToTrajPlanner | Interface for planning robot trajectories with tool path trajectory constraints |
CPDParam | Struct for holding PD parameters |
CPerspectiveTransform2D< T > | The PerspectiveTransform2D is a perspective transform in 2D |
►CPhysicsEngine | A general physics engine interface for simulating dynamics of objects and robot devices |
CODESimulator | Implementation that use the physics engine ODE to implement the Simulator interface of RWSim. All information into the simulator is derived through RWSim classes |
CRWSimulator | |
CBtSimulator | A physics engine that uses Bullet Physics as the underlying engine |
CRWPEIsland | The RWPEIsland engine |
CRWPEPhysics | The RWPEPhysics engine |
CRWPEWorld | The RWPEWorld engine |
CPickingUtil | Utility class for performing varius types of picking in the RobWrok studio opengl scene |
CPixel4f | |
CImage::Pixel4i | |
CPlanarSupportPoseGenerator | Calculates the stable poses of an object when the support structure is planar |
CPlaneModel | |
CPlannerConstraint | A tuple of (QConstraintPtr, QEdgeConstraintPtr) |
CPlannerUtil | PlannerUtil provides various utilities useful in path planning |
CPlanning | |
►CPlugin | Interface for defining dynamically loadable plugins that define extensions and extension points |
CSimpleFingerPlugin | |
CProximityStrategyPlugin | A plugin providing proximity strategies for RobWork |
CRWSImageLoaderPlugin | A RobWork image loader factory plugin. It adds additional image loader functionality to the rw::loaders::ImageFactory through RobWork plugin structure |
CODEPlugin | A ODE plugin that define extensions for rwsim.simulator.PhysicsEngine |
CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
CBtPlugin | A Bullet plugin that provides additional functionality to the rwsim::simulator::PhysicsEngine::Factory through the plugin structure |
CRWPEPlugin | A loader plugin for RWPE physics engines. It provides additional functionality to the rwsim::simulator::PhysicsEngine::Factory through the plugin structure |
CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
CPluginConstructor | |
►CPluginFactoryBase | Base class for PluginFactory |
►CPluginFactory< rw::loaders::WorkCellLoader > | |
CColladaLoaderPlugin | |
CPluginFactory< T > | Template class form which to inherit when creating a factory for a plugin |
CPluginRepository | The PluginRepository provides a container load methods for plugins |
CPluginServer | All plugins are registered in the plugin server |
CContour2D::Point | Point description of the contour |
CPointPairsRegistration | |
CPointRANSACFitting | |
CPolygon< T > | Indexed polygon class that saves N indices to the N vertices of the polygon |
CPolygonUtil | Utility functions for operations on polygons, such as convex partitioning |
►CPolynomialND< Coef, Scalar > | Representation of a polynomial that can have non-scalar coefficients (polynomial matrix) |
CPolynomial< std::complex< double > > | |
►CPolynomialND< T, T > | |
CPolynomial< T > | Representation of an ordinary polynomial with scalar coefficients (that can be both real and complex) |
CPolynomialSolver | Find solutions for roots of real and complex polynomial equations |
CPose2D< T > | A Pose3D describes a position and orientation in 3-dimensions |
CPose6D< T > | A Pose6D describes a position and orientation in 3-dimensions |
CPoseGenerator | Generates poses for grasping some object |
►CPoseSampler | |
CBoxPoseSampler | |
CSurfacePoseSampler | Random sampling of points and orientations close to the surface of a geometry |
CPreshapeGraspStrategy | This strategy samples |
►CPrimArrayAccessor< PRIM > | |
CIndexedPrimArray< PRIM, T > | This class is a proxy to a triangle mesh where the triangles can be indirectly copied in an efficient manner |
CPrimArrayAccessor< PRIMType > | |
►CPrimArrayAccessor< rw::geometry::Triangle< T > > | |
CBVTreeFactory::TriMeshAccessor< T > | |
CProgramOptions | Class for parsing program command line into a PropertyMap |
CProjectionMatrix | Projection matrix |
►CPropertyBase | Base class for Property handling |
CProperty< bool > | |
CProperty< rw::common::PropertyMap > | |
CProperty< rw::math::Vector3D<> > | |
CProperty< T > | Property class The Property class is a template to support properties of any type. A Property is characterized by a string identifier, string description and a value of the template specified type |
CPropertyMap | Container for a collection of Property Objects |
CPropertyType | Represents type of a property |
►CProximityCache | Interface for cache used by ProximityStrategy |
CProximityStrategyRW::PCache | Cache for any of the queries possible on this strategy |
CPQPCollisionCache | Cache for the PQP proximity strategy |
CProximityStrategyBullet::ProximityCacheBullet | Cache for any of the queries possible on this BulletStrategy |
CProximityStrategyPQP::PQPProximityCache | Cache for any of the queries possible on this PQPStrategy |
CProximityData | |
CProximityFilter | This class is used for fetching frame pairs using some proximity filtering strategy |
►CProximityFilterStrategy | Describe the interface of a broad phase proximity strategy or proximity culler |
CBasicFilterStrategy | Simple rule based broadphase filter strategy. A static frame pair list of frame pairs that is to be checked for collision is maintained. The list is static in the sense that it is not optimized to be changed. However the user can both add and remove new geometries and rules |
CSAPFilterStrategy | This is a Sweep-And-Prune based filter strategy (broadphase strategy) |
►CProximityModel | Class for managing the collision geometries associated to a frame |
CProximityStrategyRW::RWProximityModel | |
CProximityStrategyBullet::ProximityModelBullet | |
CProximityStrategyFCL::FCLProximityModel | Datatype to hold the proximity models |
CProximityStrategyPQP::PQPProximityModel | |
►CContactModel | The ContactModel is an interface for the contact models implemented by different contact strategies |
CContactModelGeometry< A, B > | Generic contact model for strategies that find contacts between two different types of geometry |
CProximitySetup | Setup for the collision checker |
CProximitySetupRule | Rule specifying include/exclude of frame pairs |
►CProximityStrategy | The ProximityStrategy interface is a clean interface for defining methods that are common for different proximity strategy classes. Specifically adding of geometric models and relating them to frames |
►CCollisionStrategy | An interface that defines methods to test collision between two objects |
CProximityStrategyRW | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
CProximityStrategyBullet | This is a strategy wrapper for the distance and collision library Gimpact from the Bullet physicsengine |
CProximityStrategyFCL | This is a strategy wrapper for the Flexible Collision Library (FCL) |
CProximityStrategyPQP | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
CProximityStrategyYaobi | This is a strategy wrapper for the collision library Yaobi |
►CCollisionToleranceStrategy | This is a collision strategy that detects collisions between objects that are closer than a specified tolerance |
CProximityStrategyBullet | This is a strategy wrapper for the distance and collision library Gimpact from the Bullet physicsengine |
CProximityStrategyPQP | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
►CDistanceMultiStrategy | This interface allows the definition of computing all points between two geometric objects that are closer than a specified tolerance. See ProxmityStrategy on how to add geometry to the strategy |
CProximityStrategyBullet | This is a strategy wrapper for the distance and collision library Gimpact from the Bullet physicsengine |
CProximityStrategyPQP | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
►CDistanceStrategy | This is an interface that defines methods for computing the minimum distance between geometric objects. If geometry objects has been related to frames (see ProximityStrategy) then distance functions computing the distance between the geometry attached to frames can also be used |
CProximityStrategyBullet | This is a strategy wrapper for the distance and collision library Gimpact from the Bullet physicsengine |
CProximityStrategyFCL | This is a strategy wrapper for the Flexible Collision Library (FCL) |
CProximityStrategyPQP | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
►CContactStrategy | The ContactStrategy is a common interface for different contact strategies |
CBallBallStrategy | Detection of contacts between balls. Each model can consist of multiple balls |
CContactStrategyGeometry< A, B > | Generic contact strategy that find contacts between two different types of geometry |
CContactStrategyPQP | Detection of contacts between triangle meshes |
CODEContactStrategy | Detection of contacts using the internal ODE collision detector |
CBtContactStrategy | Detection of contacts using the internal Bullet collision detector |
CProximityStrategyData | |
CProximityStrategyFactory | Factory class that enables constructing collision strategies |
CPtr< T > | Ptr stores a pointer and optionally takes ownership of the value |
CPtr< ARWExpand > | |
CPtr< Body > | |
CPtr< BodyController > | |
CPtr< boost::property_tree::ptree > | |
CPtr< btCollisionObject > | |
CPtr< Camera > | |
CPtr< CameraController > | |
CPtr< CameraGroup > | |
CPtr< CameraModel > | |
CPtr< class rw::geometry::Geometry > | |
CPtr< class rw::graphics::WorkCellScene > | |
CPtr< class rw::models::Device > | |
CPtr< class rw::models::JacobianCalculator > | |
CPtr< CollisionDetector > | |
CPtr< CollisionStrategy > | |
CPtr< const LinkImpl > | |
CPtr< const rw::geometry::Geometry > | |
CPtr< const rw::geometry::QuadraticShell > | |
CPtr< const rw::geometry::QuadraticSurface > | |
CPtr< const rw::geometry::Shell > | |
CPtr< const rw::geometry::Surface > | |
CPtr< const rw::models::Joint > | |
CPtr< const rw::models::SerialDevice > | |
CPtr< const rw::models::WorkCell > | |
CPtr< const rwlibs::mathematica::Mathematica::Expression > | |
CPtr< const rwsim::contacts::ContactDetector > | |
CPtr< const rwsim::dynamics::Constraint > | |
CPtr< const rwsim::dynamics::DynamicWorkCell > | |
CPtr< const rwsim::log::LogCollisionResult > | |
CPtr< const rwsim::log::LogConstraints > | |
CPtr< const rwsim::log::LogContactSet > | |
CPtr< const rwsim::log::LogContactVelocities > | |
CPtr< const rwsim::log::LogEquationSystem > | |
CPtr< const rwsim::log::LogForceTorque > | |
CPtr< const rwsim::log::LogMessage > | |
CPtr< const rwsim::log::LogPositions > | |
CPtr< const rwsim::log::LogValues > | |
CPtr< const rwsim::log::LogVelocities > | |
CPtr< const rwsim::log::SimulatorLog > | |
CPtr< const rwsim::log::SimulatorStatistics > | |
CPtr< const rwsimlibs::rwpe::RWPELogContactTracking > | |
CPtr< ControllerModel > | |
CPtr< csgjs_model > | |
CPtr< Device > | |
CPtr< DistanceStrategy > | |
CPtr< DOMElem > | |
CPtr< DrawableGeometryNode > | |
CPtr< DrawableNode > | |
CPtr< DynamicDevice > | |
CPtr< DynamicSimulator > | |
CPtr< DynamicWorkCell > | |
CPtr< EngineTest > | |
CPtr< Expression > | |
CPtr< fcl::CollisionGeometry > | |
CPtr< FixedFrame > | |
CPtr< FrameGrabber25D > | |
CPtr< Function1Diff > | |
CPtr< Geometry > | |
CPtr< GeometryData > | |
CPtr< GraspDB > | |
CPtr< GraspResult > | |
CPtr< GraspTask > | |
CPtr< Gripper > | |
CPtr< GripperTaskSimulator > | |
CPtr< GroupNode > | |
CPtr< Image > | |
CPtr< IndexedTriMesh< T > > | |
CPtr< InvKinSolver > | |
CPtr< IterativeIK > | |
CPtr< JacobianCalculator > | |
CPtr< JointDevice > | |
CPtr< LineSearch > | |
CPtr< Log > | |
CPtr< LogWriter > | |
CPtr< Model3D > | |
CPtr< models::JacobianCalculator > | |
CPtr< Object > | |
CPtr< Plane > | |
CPtr< Player > | |
CPtr< PointCloud > | |
CPtr< PQP::PQP_Model > | |
CPtr< PropertyMap > | |
CPtr< ProximityCache > | |
CPtr< ProximityFilterStrategy > | |
CPtr< ProximityModel > | |
CPtr< QConstraint > | |
CPtr< QEdgeConstraint > | |
CPtr< QEdgeConstraintIncremental > | |
CPtr< QToQPlanner > | |
CPtr< Render > | |
CPtr< RigidBody > | |
CPtr< RigidDevice > | |
CPtr< RobWork > | |
CPtr< rw::common::Log > | |
CPtr< rw::common::LogWriter > | |
CPtr< rw::common::PropertyMap > | |
CPtr< rw::common::ThreadPool > | |
CPtr< rw::common::ThreadTask > | |
CPtr< rw::geometry::ConvexHull3D > | |
CPtr< rw::geometry::Geometry > | |
CPtr< rw::geometry::IndexedTriMeshN0< float > > | |
CPtr< rw::geometry::PlainTriMesh< rw::geometry::Triangle<> > > | |
CPtr< rw::geometry::QHullND< 6 > > | |
CPtr< rw::geometry::TriMesh > | |
CPtr< rw::graphics::DrawableGeometryNode > | |
CPtr< rw::graphics::DrawableNode > | |
CPtr< rw::graphics::GroupNode > | |
CPtr< rw::graphics::Model3D > | |
CPtr< rw::graphics::Render > | |
CPtr< rw::graphics::RenderFrame > | |
CPtr< rw::graphics::SceneDescriptor > | |
CPtr< rw::graphics::SceneGraph > | |
CPtr< rw::graphics::TextureData > | |
CPtr< rw::graphics::WorkCellScene > | |
CPtr< rw::graspplanning::GraspTable > | |
CPtr< rw::invkin::IterativeIK > | |
CPtr< rw::invkin::JacobianIKSolver > | |
CPtr< rw::kinematics::State > | |
CPtr< rw::kinematics::StateCache > | |
CPtr< rw::math::Metric< KEY > > | |
CPtr< rw::models::Device > | |
CPtr< rw::models::JacobianCalculator > | |
CPtr< rw::models::JointDevice > | |
CPtr< rw::models::WorkCell > | |
CPtr< rw::pathplanning::QConstraint > | |
CPtr< rw::pathplanning::QEdgeConstraint > | |
CPtr< rw::pathplanning::QSampler > | |
CPtr< rw::proximity::BasicFilterStrategy > | |
CPtr< rw::proximity::CollisionDetector > | |
CPtr< rw::proximity::DistanceCalculator > | |
CPtr< rw::proximity::ProximityModel > | |
CPtr< rw::proximity::rw::proximity::BVTreeCollider< rw::proximity::rw::proximity::BinaryBVTree > > | |
CPtr< rw::proximity::rw::proximity::CollisionStrategy > | |
CPtr< rw::RobWork > | |
CPtr< rw::sensor::Camera > | |
CPtr< rw::sensor::FTSensorModel > | |
CPtr< rw::sensor::rw::sensor::Image > | |
CPtr< rw::sensor::Scanner25D > | |
CPtr< rw::sensor::TactileArrayModel > | |
CPtr< rw::trajectory::Trajectory< rw::math::Q > > | |
CPtr< rw::trajectory::Trajectory< rw::math::Rotation3D<> > > | |
CPtr< rw::trajectory::Trajectory< rw::math::Transform3D<> > > | |
CPtr< rw::trajectory::Trajectory< rw::math::Vector3D<> > > | |
CPtr< rwlibs::algorithms::XQPController > | |
CPtr< rwlibs::assembly::AssemblyControlStrategy > | |
CPtr< rwlibs::assembly::AssemblyParameterization > | |
CPtr< rwlibs::assembly::AssemblyRegistry > | |
CPtr< rwlibs::assembly::AssemblyResult > | |
CPtr< rwlibs::assembly::AssemblyTask > | |
CPtr< rwlibs::control::JointController > | |
CPtr< rwlibs::mathematica::Mathematica::String > | |
CPtr< rwlibs::opengl::Drawable > | |
CPtr< rwlibs::opengl::RenderForceTorque > | |
CPtr< rwlibs::opengl::RenderFrame > | |
CPtr< rwlibs::opengl::RenderLines > | |
CPtr< rwlibs::opengl::RenderPointCloud > | |
CPtr< rwlibs::opengl::RenderScan > | |
CPtr< rwlibs::opengl::RWGLTexture > | |
CPtr< rwlibs::pathoptimization::ClearanceCalculator > | |
CPtr< rwlibs::proximitystrategies::ProximityStrategyPQP > | |
CPtr< rwlibs::simulation::FrameGrabber > | |
CPtr< rwlibs::simulation::FrameGrabber25D > | |
CPtr< rwlibs::simulation::SimulatedScanner25D > | |
CPtr< rwlibs::simulation::SimulatedScanner2D > | |
CPtr< rwlibs::simulation::SimulatedSensor > | |
CPtr< rwlibs::swig::LuaState > | |
CPtr< rwlibs::task::GraspTask > | |
CPtr< RWPEPhysicsDebugRender > | |
CPtr< rws::SensorView > | |
CPtr< rwsim::contacts::ContactDetector > | |
CPtr< rwsim::contacts::ContactDetectorData > | |
CPtr< rwsim::contacts::ContactModel > | |
CPtr< rwsim::contacts::ContactStrategy > | |
CPtr< rwsim::control::BodyController > | |
CPtr< rwsim::drawable::RenderCircles > | |
CPtr< rwsim::drawable::RenderPoints > | |
CPtr< rwsim::drawable::SimulatorDebugRender > | |
CPtr< rwsim::dynamics::Body > | |
CPtr< rwsim::dynamics::DynamicDevice > | |
CPtr< rwsim::dynamics::DynamicWorkCell > | |
CPtr< rwsim::dynamics::FixedBody > | |
CPtr< rwsim::dynamics::KinematicBody > | |
CPtr< rwsim::dynamics::KinematicDevice > | |
CPtr< rwsim::dynamics::RigidBody > | |
CPtr< rwsim::dynamics::RigidDevice > | |
CPtr< rwsim::dynamics::SuctionCup > | |
CPtr< rwsim::log::LogConstraints > | |
CPtr< rwsim::log::LogContactSet > | |
CPtr< rwsim::log::LogPositions > | |
CPtr< rwsim::log::SimulatorLogScope > | |
CPtr< rwsim::log::SimulatorStatistics > | |
CPtr< rwsim::sensor::BodyContactSensor > | |
CPtr< rwsim::sensor::SimulatedTactileSensor > | |
CPtr< rwsim::simulator::DynamicSimulator > | |
CPtr< rwsim::simulator::GraspTaskSimulator > | |
CPtr< rwsim::simulator::ODEDebugRender > | |
CPtr< rwsim::simulator::PhysicsEngine > | |
CPtr< rwsim::simulator::ThreadSimulator > | |
CPtr< rwsim::util::GraspPolicy > | |
CPtr< rwsim::util::GraspStrategy > | |
CPtr< rwsim::util::SimStateConstraint > | |
CPtr< rwsim::util::StateSampler > | |
CPtr< SBLExpand > | |
CPtr< Scanner25DModel > | |
CPtr< Scanner2DModel > | |
CPtr< SceneCamera > | |
CPtr< SceneGraph > | |
CPtr< SceneNode > | |
CPtr< SceneOpenGL > | |
CPtr< SceneViewer > | |
CPtr< SensorModel > | |
CPtr< SimulatedController > | |
CPtr< Simulator > | |
CPtr< SimulatorDebugRender > | |
CPtr< StateDraw > | |
CPtr< StateSampler > | |
CPtr< StateStructure > | |
CPtr< std::vector< float > > | |
CPtr< std::vector< rw::math::Vector3D< float > > > | |
CPtr< std::vector< T > > | |
CPtr< std::vector< ValueType > > | |
CPtr< StopCondition > | |
CPtr< String > | |
CPtr< Symbol > | |
CPtr< TactileArrayModel > | |
CPtr< Target< T > > | |
CPtr< TaskBase > | |
CPtr< TaskDescription > | |
CPtr< TaskGenerator > | |
CPtr< TestHandle > | |
CPtr< TreeDevice > | |
CPtr< TriangleArray > | |
CPtr< TriMesh > | |
CPtr< TriMeshData > | |
CPtr< ValueMatrix > | |
CPtr< ValueType > | |
CPtr< VertexArray > | |
CPtr< View > | |
CPtr< WorkCell > | |
CPtr< WorkCellScene > | |
CQ | Configuration vector |
►CQAbstractItemModel | |
CSimulatorLogModel | Model of a simulator log for Qt Tree view |
►CQCompleter | |
CTreeModelCompleter | |
CTreeModelCompleter | |
CQConfig | |
CQConstraint | Interface for the checking for collisions for work cell states |
►CQDialog | |
CBodyControlDialog | Dialog used to control dynamic bodies in the scene |
CCreateEngineDialog | |
CDesignDialog | Dialog for gripper design in the plugin |
CGraspRestingPoseDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CGraspRestingPoseDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CGraspSelectionDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CJointControlDialog | |
CODESimCfgDialog | |
CPlayBackSettings | Dialog for changing the settings of playback and recordings |
CPropertyViewDialog | Qt dialog for showing properties in a PropertyMap |
CRestingPoseDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CAboutBox | AboutBox in RobWorkStudio |
CStrategyLibraryDialog | Dialog showing examples of the available assembly strategies |
CTaskSetupDialog | Dialog for configuration of an assembly task |
CSimCfgDialog | |
CSimulatorDialog | |
CSupportPoseAnalyserDialog | Gaphical user interface for calculating support pose and related statistics of multiple objects on some support structure |
CSupportPoseAnalyserDialog | Gaphical user interface for calculating support pose and related statistics of multiple objects on some support structure |
CSupportPoseAnalyserDialog | Gaphical user interface for calculating support pose and related statistics of multiple objects on some support structure |
CTactileSensorDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CTaskDialog | Dialog for editing TaskDescription in gripper evaluation plugin. |
►CQDockWidget | |
►CRobWorkStudioPlugin | Abstract interface for RobWork Studio plugins |
CGraspPlugin | A plugin for testing grippers |
CGraspTableGeneratorPlugin | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
CGTaskVisPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
CJog | The Jog plugin enables cartesean and joint level jogging of MovableFrames and Devices. Reference frame can freely be choosen and the devices are jogged using general inverse kinematic solvers |
CLua | This plugin provides access to editing and executing lua commands |
CPlanning | Planning plugin for basic pathplanning |
CPlayBack | Playback plugin for animation of a rw::trajectory::TimedStatePath |
CPropertyView | Plugin for editing properties |
CSensors | Sensor plugin for RobWorkStudio |
CShowLog | This plugin registers a number of LogWriters at the Log component such that any output written to info, warning or error logs will be routed to the window of this plugin |
CTreeView | The TreeView plugin display the kinematic structure of a workcell in a treeview fashion and enables the user to select and do simple manipulation of frames, devices, drawables and so on |
CEngineTestPlugin | A plugin for interactive testing of physics engines |
CRWSimPlugin | A plugin for loading dynamic workcells and for doing simple dynamics simulation using different physics engines |
CRWSimulatorPlugin | |
CATaskVisPlugin | Plugin for visualization of assembly operations |
CSimTaskPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
CSimTaskVisPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
CSimUtilityPlugin | This plugin defines a set of utilities that are useful for analysis and simulation purposes, that are based on some form of dynamic simulation |
CQEdgeConstraint | Edge constraint interface |
CQEdgeConstraintIncremental | Edge constraint interface for incremental testing of an edge |
►CQGLWidget | |
CGLViewRW | Class representing an OpenGL based QT Widget for 3D visualization of Drawables |
CSceneOpenGLViewer | Class representing an OpenGL based QT Widget for 3D visualization of the SceneGraph SceneOpenGL |
CQIKSampler | Interface for the sampling a configuration that solves an IK problem |
CQJunction | |
►CQLabel | |
CImageView | GUI Element for showing RobWork images |
CMathematicaPlotWidget | Widget for Mathematica plots |
►CQMainWindow | |
CLuaEditorWindow | |
CLuaEditorWindow | A lua editor and programming pad designed to resemble a teach pendent for devices in robworkstudio |
CRobWorkStudio | Main robwork studio class |
CSimulatorLogViewer | Stand-alone application for visualization of internal data from a Physics Engine |
CQNormalizer | Normalization of configurations |
►CQObject | |
CPlayer | This is the core functionality of the playback plugin. The controls in PlayBack is forwarded to this utility |
CQPController | |
►CQPlainTextEdit | |
CCodeEditor | |
CCodeEditor | |
CQPSolver | Class providing an algorithms for solving the quadratic optimization problem associated with the QPController |
►CQSampler | Interface for the sampling a configuration |
CRandomSampler | |
CQState | The configuration state of a work cell |
►CQSyntaxHighlighter | |
CLuaHighlighter | |
CLuaHighlighter | |
►CQTableWidget | |
CContactTableWidget | A table widget customised for rwsim::contacts::Contact types |
►CQTextEdit | |
CLuaConsoleWidget | Widget that mimics console functionality for executing lua commands in a RobWorkStudio framework |
►CQThread | |
CLuaExecutionThread | This class handles the execution of lua commands such that they are executed in a seperate thread |
►CQtTreePropertyBrowser | |
CPropertyViewEditor | Qt widget for editing a PropertyMap |
CQuadraticUtil | Utility functions for operations on quadratic surfaces and curves |
CTaskDescription::Qualities | Used for storing baseline and weights for quality measurements |
►CQualityMeasure2D | |
CSimpleMeasure | |
CRaycaster::QueryResult | Result of a Raycast query. All contact information are described in ray coordinate frame |
CCollisionDetector::QueryResult | Result of a collision query |
►CQWidget | |
CCartesianDeviceTab | Widget for moving devices in Cartesian space. For inverse kinematics, the rw::invkin::JacobianIKSolver is used |
CCartesianDeviceTab | Widget for moving devices in Cartesian space. For inverse kinematics, the rw::invkin::JacobianIKSolver is used |
CCurTab | |
CCurTab | |
CJogGroup | |
CJogWidget | |
CJointLine | |
CJointSliderWidget | Widget for a set of joint sliders |
CJointSliderWidget | Widget for a set of joint sliders |
CLineNumberArea | |
CLineNumberArea | |
CMovableFrameTab | Widget for a adjusting a MovableFrame |
CMovableFrameTab | Widget for a adjusting a MovableFrame |
CPosTab | |
CPosTab | |
CRWStudioView3D | This class adds RobWorkStudio specific functionality to a WorkCellViewer |
►CSensorView | A Qt widget for visualization of sensors |
CCameraView | View to visualize output of a camera |
CScan25DView | View to visualize the output of 2.5D scanners |
CScan2DView | View to visualize the output of 2D scanners |
►CSimulatorLogEntryWidget | A widget that is a graphical representation of a rwsim::log::SimulatorLogEntry |
CBodyMotionWidget | Graphical representation of the log entries rwsim::log::LogPositions and rwsim::log::LogVelocities |
CCollisionResultWidget | Graphical representation of the log entry rwsim::log::LogCollisionResult |
CConstraintWidget | Graphical representation of the log entry rwsim::log::LogConstraints |
CContactSetWidget | Graphical representation of the log entry rwsim::log::LogContactSet |
CContactVelocitiesWidget | Graphical representation of the log entry rwsim::log::LogContactVelocities |
CEquationSystemWidget | Graphical representation of the log entry rwsim::log::LogEquationSystem |
CForceTorqueWidget | Graphical representation of the log entry rwsim::log::LogForceTorque |
CLogMessageWidget | Graphical representation of the rwsim::log::LogMessage log entry |
CLogValuesWidget | Graphical representation of the rwsim::log::LogValues log entry |
CRWPELogContactTrackingWidget | INSERT_SHORT_DESCRIPTION |
CSimulatorLogWidget | Widget for visualization of a simulation log |
CSimulatorStatisticsWidget | Widget for visualisation of rwsim::log::SimulatorStatistics |
CSlider | Widget for jogging a single value, such as the joint of a device or a Cartesian translation/rotation |
CSlider | Widget for jogging a single value, such as the joint of a device or a Cartesian translation/rotation |
CSyncTab | |
CSyncTab | |
CTransformSliderWidget | Widget for a setting a 6D pose |
CTransformSliderWidget | Widget for a setting a 6D pose |
CVelTab | |
CVelTab | |
CRandom | Generation of random numbers |
CRANSACFitting | |
CRANSACModel< MODEL, DATA > | An interface for RANSAC model fitting |
►CRANSACModel< ConstraintModel, rw::math::Transform3D<> > | |
►CConstraintModel | An interface for constraint models |
CLineConstraint | A line constraint model |
CPlaneConstraint | A plane constraint model |
CPointConstraint | A point constraint model |
CStablePoseConstraint | A stable pose constraint model |
►CRANSACModel< LineModel, rw::math::Vector3D<> > | |
CLineModel | A line model |
►CRANSACModel< PlaneModel, rw::math::Vector3D<> > | |
CPlaneModel | A plane model |
►CRANSACModel< PointModel, rw::math::Vector3D<> > | |
CPointModel | A point model |
►CRANSACModel< StablePose0DModel, rw::math::Rotation3D<> > | |
CStablePose0DModel | A stable pose with 0 DoF model. o Models a stable pose with 0 DoF, i.e. essentially a single orientation in SE3 |
►CRANSACModel< StablePose1DModel, rw::math::Rotation3D<> > | |
CStablePose1DModel | A stable pose with 1 DoF model |
►CRANSACModel< StructuredLineModel, rw::math::Vector3D<> > | |
CStructuredLineModel | A model for points placed along a line with regular intervals |
CRawArrayUtil | Utility for the RawArray type |
CRaycaster | Raycast implementation that relies on a collision strategy for finding the collision between the ray and the scene |
CRecursiveNewtonEuler | The recursive Newton-Euler method is used for calculating inverse dynamics of a kinematic tree |
►CRender | Abstract base class for all renderable classes |
CRenderTargets | |
CRenderArrow | RenderFrame makes a visualization of a frame |
CRenderCameraFrustum | Render drawing a collection of lines |
CRenderForceTorque | RenderForceTorque makes a visualization of forces and torques |
CRenderFrame | RenderFrame makes a visualization of a frame |
CRenderGeometry | RenderGeometry provide a class for visualizing Geometry objects |
CRenderImage | RenderImage renders a image in a plane defined by [-w/2;h/2][w/2;-h/2]. The image need to be scaled into metric units. This can be done using a scaling parameter |
CRenderLines | Render drawing a collection of lines |
CRenderMatrix | RenderMatrix, visualization of a matrix of values |
CRenderModel3D | Render for the Model3D class |
CRenderPointCloud | Render a point cloud |
CRenderScan | Renders Image25D, Scan2D or a simple distance |
CRenderSmoothSkin | Renders skin using vertice weights in relation to the bone structure |
CRenderVelocity | Render for linear and angular velocity |
CTactileArrayRender | Renders a TactileArray |
CRenderContacts | Render for contacts |
CRenderCircles | Render a set of circles |
CRenderContacts | Renderer for contacts |
CRenderGhost | This render implementation will render a set of previous configurations/states (ghosts) of a set of specific frames |
CRenderPlanes | Renderer for rendering planes |
CRenderPoints | Renderer for rendering points |
►CSimulatorDebugRender | Render for debugging dynamic simulators |
CODEDebugRender | |
CRWDebugRender | |
CBtDebugRender | Debug render for the Bullet engine |
CRWPEDebugRender | The debug render for RWPE engines |
►CDrawableNode::RenderInfo | Information for rendering |
CSceneGraph::RenderInfo | All general render information is located in this struct |
CRenderUtil | Collection of utillities for rendering |
CRestingConfig | |
CRestingPoseGenerator | Finds resting poses of a dynamic scene |
CDistanceStrategy::Result | DistanceResult contains basic information about the distance result between two sets of geometries. These geometry sets |
CEngineTest::Result | A result of an engine test. Each test can return multiple results |
CCollisionStrategy::Result | Result of a single collision pair |
CDistanceMultiStrategy::Result | DistanceResult contains basic information about the distance result between two frames |
CLogCollisionResult::ResultInfo | The result including info about the ProximityModels |
CRigidBodyInfo | A class to wrap rigid body information |
CRigidBody::RigidBodyState | The state of a rigid body |
CRobWork | RobWork instance which holds objects to be shared among multiple plugins |
CRobWorkStudioApp | RobWorkStudio main application which may be instantiated in its own thread |
►CRobWorkStudioPlugin | |
CLua | Initial Lua plugig for RobWorkStudio. This class is marked for removal - please use rws::Lua instead! |
CSupportPosePlugin | |
CRWPERollbackMethod::RollbackData | Data type for methods that need to store internal data during rollback |
CRotation2D< T > | A 2x2 rotation matrix |
CRotation2DVector< T > | |
CRotation3D< T > | A 3x3 rotation matrix |
CRotation3D< double > | |
CRotation3D< float > | |
CRotation3D<> | |
►CRotation3DVector< T > | An abstract base class for Rotation3D parameterisations |
CEAA< T > | A class for representing an equivalent angle-axis rotation |
CQuaternion< T > | A Quaternion a complex number used to describe rotations in 3-dimensional space. |
CRPY< T > | A class for representing Roll-Pitch-Yaw Euler angle rotations |
CRRTGraspPlanner | Explores freespace in the vicinity of |
CRRTNode< X > | Node type for trees of RRT based planners |
CRRTPlanner | RRT based planners |
CRRTQToQPlanner | Rapidly Expanding Random Tree based planners for the QToQPlanner type of planning problem |
CRRTTree< X > | Tree data type for RRT based planners |
►CRusselIntegrand | Implementation of the Modified Russel energy density functions |
CRusselIntegrandEonly | Implementation of the Modified Russel elastic energy density function |
CRWBody | |
CRWBodyPool | Interface for creating and deleting constraintEdges and ConstraintNodes. ConstraintEdges are frequently created and deleted so efficient data structures are here needed |
CRWGLFrameBuffer | Class for off-screen GL rendering |
CRWGLTexture | Texture class that wraps the construction of opengl textures |
►CRWPEBody | The RWPEBody is a wrapper for a rwsim::dynamics::Body, which allows storing data in a RWPEIslandState instead of rw::kinematics::State |
CRWPEBodyDynamic | The RWPEBodyDynamic is a wrapper for a rwsim::dynamics::Body of dynamic type and is used for bodies that is influences by forces acting on them |
CRWPEBodyFixed | The RWPEBodyFixed is a wrapper for a rwsim::dynamics::FixedBody and is used for bodies that do not move |
CRWPEBodyKinematic | The RWPEBodyKinematic is a wrapper for a rwsim::dynamics::KinematicBody and is used for bodies that moves with a dictated velocity |
CRWPEBodyConstraintGraph | Manager that maintains lists of all bodies and constraints in the system, as well as maps of how the bodies are connected by constraints |
CRWPEBroadPhase | Maintains a broad-phase filter where bodies can be easily added and removed |
►CRWPECollisionSolver | Interface for collision solvers that handle bouncing contacts |
CRWPECollisionSolverChain | A collision solver that can handle impulse chains |
CRWPECollisionSolverHybrid | A collision solver that handles collisions as sequential as much as possible, but reverts to simultaneous handling if sequential handling is not possible |
CRWPECollisionSolverSimultaneous | A collision solver that handles all collisions simultaneously |
CRWPECollisionSolverSingle | The most simple implementation of a RWPECollisionSolver |
►CRWPEConstraint | A generic interface that makes implementation of constraints simple |
CRWPEConstraintGear | The gear implementation constrains how two existing constraints can move relative to eachother |
CRWPEContact | A special form of constraint that changes continuously during simulation |
CRWPERWConstraint | Implementation of a rwsim::dynamics::Constraint for use in the RWPE physics engine |
CRWPEConstraintCorrection | Correction of the position and orientation of bodies such that positional errors in constraints and contacts are reduced or eliminated |
►CRWPEConstraintSolver | Sets up the equation system for constraint forces and solves it |
CRWPEConstraintSolverDirect | The default constraint solver using SVD |
CRWPEConstraintSolverIterative | Solver for constraint forces that uses a iterative approach based on a SVD decomposition of the problem |
►CRWPEContactResolver | The contact resolver is responsible for determining which contacts that are leaving, sliding or rolling. To determine this it uses a RWPEConstraintSolver to try to solve for different choices of contact types |
CRWPEContactResolverFull | Simple contact resolver that gives the solver a complete LCP problem |
CRWPEContactResolverHeuristic | A contact resolver that uses a heuristic approach for determining which contacts that are leaving, sliding or rolling. This method is not guaranteed to converge, but is expected to do so under normal circumstances |
CRWPEContactResolverNonPenetration | The simplest form of contact resolver possible. The resolver only enforces non-penetration by resolving contacts as either leaving or sliding without friction. In other words, Forces are only applied in the normal direction of the contacts to make sure that objects do not penetrate |
CRWPEDevice | The RWPE representation of a DynamicDevice |
►CRWPEFrictionModel | A friction model calculates friction coefficients based on the relative velocities |
CRWPEFrictionModelCoulomb | A simple friction model with only tangential friction that is the same and constant with respect to relative velocity |
CRWPEFrictionModelMicroSlip | A micro-slip friction model that models friction with hysteresis for small velocities, and uses Stribeck friction for large velocities |
CRWPEFrictionModelNone | Friction model for modelling no friction at all |
CRWPEFrictionModelStribeck | Stribeck friction model with tangential friction that is larger for small velocities and then decrease and becomes constant as velocity increase |
CRWPEFrictionModelData | Interface for data structures used by RWPEFrictionModel |
►CRWPEIntegrator | Interface for different motion integrators for rigid bodies |
CRWPEIntegratorEuler | Integration of body motion using the Euler scheme |
CRWPEIntegratorHeun | Integration of body motion using the Heun scheme |
CRWPEIslandState | Stores the complete internal state of a RWPEIsland |
CRWPELinearOptimizer | Optimisation method for solving dynamics |
CRWPELogUtil | INSERT_SHORT_DESCRIPTION |
CRWPEMaterialMap | The material map keeps a map of friction and restitution models for each pair of bodies |
►CRWPERestitutionModel | A restitution model calculates restitution coefficients based on the relative incomming velocity |
CRWPERestitutionModelNewton | A simple restitution model with only linear restitution that is the same and constant in both normal and tangent direction |
►CRWPERollbackMethod | The rollback method calculates new guesses for the correct step size based on previous samples of the distance or penetration between objects |
CRWPERollbackMethodRidder | Ridders Method for doing rollback |
CRWPEUtil | Utility functions for the RWPE physics engine |
CProximityStrategyPQP::RWPQPModel | |
►CRWSimPlugin | |
CRWSimPlugin | A plugin for loading dynamic workcells and for doing simple dynamics simulation using different physics engines |
CRWXMLFile | Define methods for loading and saving workcells from and to the xml file format |
CRWPERollbackMethod::Sample | A sample defines distances for all contact pairs for a specific time |
CRWPERollbackMethod::SampleCompare | Comparison of samples that allows ordering by time |
CSBGraspPlanner3D | Grasp planner for 3D objects |
CSBLExpand | Interface for sampling a configuration in the vicinity of some other configuration |
CSBLInternal | Internal algorithms used by the SBLPlanner |
CSBLOptions | SBL planner setup |
CSBLPlanner | SBL based planners |
CSBLPlannerConstraint | A SBL planner constraint |
CSBLSetup | Common parameters for SBL based planners |
CScapePoseFormat | Saving object poses in Scape format |
CSceneDescriptor | The scene descriptor describe any visualization related details of a workcell. This is typically models, visual state, highlighted state and lighting details. All information is related to frames and objects |
►CSceneGraph | 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 |
CSceneOpenGL | Helps with Visualizing a Workcell. SceneOpenGL is OpenGL specific |
►CSceneGraph | |
CSceneOSG | Helps with Visualizing a Workcell. SceneOSG is OpenGL specific |
►CSceneNode | Node that can have leafs (DrawableNode) or other nodes as children |
►CDrawableNode | Abstract base class for all drawable classes |
►CDrawableGeometryNode | A specific type of DrawableNode that is able to draw a rw::geometry::Geometry |
CDrawableGeometry | Abstract base class for all drawable classes |
CDrawableNodeClone | Abstract base class for all drawable classes |
CDrawable | Abstract base class for all drawable classes |
CGroupNode | SceneNode that has a transformation and 0 to many children |
CSceneCamera | Node representing a camera in the scene. A SceneCamera sets up everything from rendering buffer to perspective transform |
►CSceneViewer | Interface for viewing a scene graph |
►CSceneViewerWidget | Class representing a Qt widget for 3D visualization of a scene |
CSceneOpenGLViewer | Class representing an OpenGL based QT Widget for 3D visualization of the SceneGraph SceneOpenGL |
CScopedTimer | Times what is executed in a scope |
CSDHGraspPlanner2D | Grasp planner for the 3 finger SDH (Schunk Dextreous Hand). The grasp planner use 2d contour information to plan good grasp configurations for both hand and robot |
►CSensor | Generel hardware sensor interface. The sensor should interface to a statefull instance of either a real world sensor or a simulated sensor. The sensor interface acts as a realistic handle to controlling some specific instance of a sensor |
►CCamera | 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 |
CCameraFirewire | 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 |
CFTSensor | Interface of a N-axis Force Torque sensor |
►CScanner | This interface describe a generic range scanning class |
►CScanner1D | One dimensional range scanner |
CSimulatedScanner1D | A simulated line scanner |
CScanner25D | Interface describing a 3D scanner sensor. The scanner takes pictures in the oposite direction of the z-axis of the frame that it is attached to. The x-y plane forms the image plane such that the xy-origin is located in the bottom left corner of the image |
CScanner2D | The Scanner2D sensor encapsulate the basic interface of a 2 dimensional range scanning device such as SICK or Hokyuo laser range scanners |
CTactileArray | |
CSensorData | Toplevel class for sensor data. Basicly describes interface for setting and getting timestamps |
►CSerializable | Interface for defining serialization of classes. If a class cannot inherit the Serializable because of non-access to code then one can instead provide overloaded read/write methods to perform the serialization |
CKDTreeQ< Node > | |
►CState | The state of a work cell (or kinematics tree) |
CStateMsg | The state of a work cell (or kinematics tree) |
CVectorND< N, T > | A N-Dimensional Vector |
CKDTreeQ< VALUE_TYPE > | Space partitioning structure for organizing points in k-dimensional space. Used for searches involving multi.dimensional search keys, including nearest neighbor and range search |
CContact | A common interface for the most important data for a contact |
►CSimulatorLog | Base class for a hierarchical simulator log |
►CSimulatorLogEntry | A leaf log item with no children |
CLogCollisionResult | Log detailed info from a collision detection |
CLogConstraints | Log type for constraints |
CLogContactSet | Log a set of contacts |
CLogContactVelocities | Log a set of contact velocities |
CLogEquationSystem | Log entry for a linear equation system |
►CLogForceTorque | Logging for forces and torques |
CLogConstraintForceTorque | Log wrench for constraints |
CLogContactForceTorque | Log a set of contact forces and torques |
CLogMessage | Logging of a generic message |
CLogPositions | Logging of body positions |
CLogValues | Logging of numeric values. These values will also be used for SimulatorStatistics |
CLogVelocities | Logging of body velocities |
CRWPELogContactTracking | INSERT_SHORT_DESCRIPTION |
►CSimulatorLogScope | A scope can have children, and the type allows hierarchical logging |
CLogStep | A special type of scope that is also a simulation step |
CVectorND< 6, bool > | |
CSetDevScope | |
CSetDHParam | |
CSetTransform3D | |
CGraspTaskSimulator::SimState | |
CSimStateConstraint | |
►CSimTaskPlugin | |
CSimTaskPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
►CSimTaskVisPlugin | |
CSimTaskVisPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
►CSimulator | Interface of a general simulator |
CKinematicSimulator | Interface of a kinematic simulator |
CDynamicSimulator | A general physics engine interface for simulating dynamics of objects and robot devices |
CSimulatorStatistics | Statistics utility for automatic generation of data set based on a SimulatorLogScope |
CSolverInfo | Parameters for the constraint solver |
CContactStrategyData::SpecificData | Base class that can be extended to implement strategy-specific data |
CSuctionCupController::Spring | |
CSpringJointController::SpringParam | Parameters of a 1 dof spring |
CConstraint::SpringParams | Parameters for a spring |
CStablePlanePose | Calculate the stable poses of an object lying on a planar support structure |
COptimizer::State | Optimizer state data structure for logging |
►CStateCache | Basic building block for the stateless desing using the StateStructure class. A StateCache represents a size, a unique id, and a unique name, when inserted into the StateStructure. The size will allocate "size"-doubles in State objects originating from the StateStructure |
CDeformableObject::DeformableObjectCache | |
CCameraModel::CameraModelCache | CameraModelCache that define data to store in the State |
CScanner25DModel::Scanner25DModelCache | Cache object for storing relevant state information |
CScanner2DModel::Scanner2DModelCache | Cache to allow storing state information |
CTactileArrayModel::TactileModelCache | Cache to store state information |
CBodyContactSensor::ClassState | The state of the sensor |
CTactileArraySensor::ClassState | Class for keeping statefull information |
CStateConstraint | Interface for the checking for collisions for work cell states |
►CStateData | Basic building block for the stateless design using the StateStructure class. A StateData represents a size, a unique id, and a unique name, when inserted into the StateStructure. The size will allocate "size"-doubles in State objects originating from the StateStructure |
►CFrame | The type of node of forward kinematic trees |
CFixedFrame | FixedFrame is a frame for which the transform relative to the parent is constant |
CMovableFrame | MovableFrame is a frame for which it is possible to freely change the transform relative to the parent |
►CJoint | A Joint is a Frame with assignable values for position, velocity limits and acceleration limits |
►CDependentJoint | Dependent joints are 0-dof joints for which the actual joints transformation depends on one of more other joints |
CDependentPrismaticJoint | Dependent prismatic joint |
CDependentRevoluteJoint | Dependent revolute joints |
CPrismaticJoint | Prismatic joints |
CPrismaticSphericalJoint | A prismatic spherical joint that allows rotations in all directions and translation along one direction |
CPrismaticUniversalJoint | A prismatic universal joint that allows rotations in two directions and translation along the third |
CRevoluteJoint | Revolute joints |
CSphericalJoint | A spherical joint that allows rotations in all directions |
CUniversalJoint | A universal joint that allows rotations in two directions |
CVirtualJoint | Virtuals joints |
CConstraint | A constraint is a mathematical model that constrain the movement between two arbitrary bodies in a dynamic simulation |
CStateDraw | Interface for the drawing of the work cell for a given state |
►CStateless | Interface for a stateless or typically a part stateless class |
CControllerModel | 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. As such controllers vary greatly and have only little in common |
►CDevice | An abstract device class |
►CJointDevice | A device for a sequence of joints |
CCompositeDevice | A device constructed from a sequence of devices |
CCompositeJointDevice | A device constructed from a sequence of devices |
CParallelDevice | This class defines the interface for Parallel devices |
CSerialDevice | The device for a serial chain |
►CTreeDevice | A tree structured device |
CParallelJawGripper | |
CMobileDevice | Provides a differential controlled mobile device |
CSE3Device | A Cartesian 6-Dof device |
►CObject | 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 |
CDeformableObject | The deformable object is an object that contain a deformable mesh. Deformations are part of the state object and they are modeled/controlled through control nodes. each control node correspond to a vertice in the mesh. All vertices are described relative to the base frame of the object |
CRigidObject | RigidObject defines a physical object in the workcell that is rigid in the sence that the geometry does not change. The rigid object also have basic properties such as Inertia and mass. These are default 1.0 kg and inertia of solid sphere with mass 1.0kg and radius of 10cm. The center of mass defaults to origin of the base frame |
►CSensorModel | General sensormodel interface. The sensormodel describe the model of a sensor and define the data that are part of the State. Much like Device, which describe the kinematic model of a robot. A sensormodel should have a name id and be associated, referenced to some frame in the workcell |
CCameraModel | Defines a generel pinhole camera model where camera parameters and state values are stored |
CFTSensorModel | N-axis Force Torque sensor model |
CRGBDCameraModel | |
CScanner25DModel | Model of a 25D (2D with depth information) scanner. The images are essentially point clouds |
CScanner2DModel | The Scanner2DModel encapsulate the basic model of a 2 dimensional range scanning device such as SICK or Hokyuo laser range scanners |
CStereoCameraModel | 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 |
CTactileArrayModel | TactileArrayModel describes tactile sensor consisting of arrays of tactile cells that can be placed on a defined shape. The shape is described with a matrix of 3d vertices. Such that tactil (0,0) maps to the quad defined by the four vertices {(0,0),(0,1),(1,1),(1,0)}. Notice that the normal is defined by sequence of the vertices and that the normal defines the direction of tactile sensing |
►CSimulatedController | Interface of a simulated controller |
CSuctionCupController | Controlls the forces and the internal states of the bodies that makes a suction cup. The controller depends on the contacts of the elastic suctioncup geometry with other bodies and the class gets this feedback from a SuctionCupSensor |
CBeamJointController | The beamjoint controller controls a joint device composed of coupled beam joints. The coupling of beamjoints is somewhat special since its not an configuration space coupling (position) but rather a coupling of the forces acting on the joints |
CBodyController | A Controller that use a PD loop to follow a trajectory generated from different target types. If the body is a Kinematic body then the velocities of the body is directly controlled, else wrenches are used to control the body |
CPDController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached |
CPoseController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached |
CRigidBodyGenerator | Generator of rigid bodies |
CSerialDeviceController | SerialDeviceController that enables control of the robot in both position, velocity and force modes. Also both joint and cartesean control is available |
CSpringJointController | |
CSyncPDController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached at the same time. The PD controls the joint position and velocity from a generated synchronous ramp profile |
CTrajectoryController | JointController that use a PD loop on each joint to control the velocity such that the position target is reached at the same time. The PD controls the joint position and velocity from a generated synchronous ramp profile |
CVelRampController | JointController that use a velocityramp profile of a device to set acceleration, velocity and position of a dynamic device |
►CSimulatedSensor | Simulated sensor interface |
CSimulatedCamera | Makes it posible to use virtual camera sensors by using different framegrapper implementations |
CSimulatedKinect | Simulates a Kinnect grabbing RGBD images |
CSimulatedScanner1D | A simulated line scanner |
CSimulatedScanner25D | Simulated range scanner for 2.5D images, that is basically pointclouds without color information |
CSimulatedScanner2D | Simulated scanner in 2D |
►CSimulatedTactileSensor | Interface for simulated tactile sensors |
CBodyContactSensor | This sensor attaches to a body and records all forces and the corresponding positions where the forces act |
CSimulatedFTSensor | A sensor that measures force and torque between two bodies around some reference frame |
CTactileArraySensor | TactileMatrixSensor class combines a TactileMatrix data type with the actual shape of a tactile sensor. The shape is described with a matrix of 3d vertices. Such that tactil (0,0) maps to the quad defined by the four vertices {(0,0),(0,1),(1,1),(1,0)}. Notice that the normal is defined by sequence of the vertices and that the normal defines the direction of tactile sensing |
►CBody | The body interface describe the basic interface of some physical entity in the virtual world. That is as a minimum the body has a geometric description, and a material identity |
CBeamBody | A deformable body composed of a sequence of connected rigid bodies |
CFixedBody | Body with a fixed position, zero velocity and zero force |
CFixedLink | |
CKinematicBody | Kinematic body is a body that effects the motion of other objects but it is not directly affected itself |
CLink | The Link is a body that is part of a dynamic device where joints are used to constrain the movement of links |
CRigidBody | A body is an abstraction over some physical object in the scene. The body class is an abstract class that allows interaction by adding gravity, forces and impulses. The integration scheme used to update the velocity and position of the body is defined by the class that inherit the body interface |
►CDynamicDevice | Base class for dynamic devices that has dynamic state values such as velocity and acceleration |
CKinematicDevice | Kinematic device is able to influence the simulated environment but the device is not influenced by any external force as is the RigidDevice |
CRigidDevice | Rigid device is composed of a set of links where one or multiple constraints (joints) connect the links. The RigidDevice has motors on all active joints. These motors can be operated in either velocity control mode or force control mode |
CSuctionCup | Suction cup with circular end effector |
CStatelessData< DATA > | Class for enabling statelessness in classes that are data containers |
CStatelessData< char > | |
CStatelessData< double > | |
CStatelessData< FTStateData > | |
CStatelessData< int > | |
CStatelessData< rw::math::Wrench6D<> > | |
CStatelessData< rwsim::dynamics::KinematicBody::KinematicBodyState > | |
CStatelessData< rwsim::dynamics::RigidBody::RigidBodyState > | |
►CStateSampler | Interface for generating states |
CCollisionFreeSampler | Samples another state sampler until it returns a collision free state |
CFiniteStateSampler | State sampler that will sample a finite set of states. The nr of samples is not necesdarilly finite since states are allowed to be sampled multiple times |
CPreshapeSampler | This StateSampler will never become empty |
CSpherePoseSampler | Samples poses of a movable frame, such that the frame is always positioned on a sphere around some specified center. Random deviations to the position of the frame can be added |
CStateSetup | Utility class to help construct a State |
CStateStructure | StateStructure is responsible for handling a structure of StateData and Frames |
CStatistics< T > | Class for collecting data and calculating simple statistics |
►CStepCallback | |
CThreadSimulatorStepCallbackEnv | An extension to the StepCallback function defined in ThreadSimulator that allows saving additional environment/user data |
CSTLFile | Static methods for reading and writing geometry to and from STL files |
CStopCondition | |
CStopCriteria | StopCriteria is a class for specifying an instant a compution should be aborted |
CContactStrategyTracking::StrategyData | Base struct that can be extended for strategy specific data |
CContactDetector::StrategyTableRow | One row in the strategy table, with a priority, match-rules, a strategy and associated ContactModels |
CStringUtil | Collection of string manipulation utilities |
CSupportPose | |
►CSupportPoseAnalyserDialog | |
CSupportPoseAnalyserDialog | Gaphical user interface for calculating support pose and related statistics of multiple objects on some support structure |
CSupportPoseAnalyserDialog | Gaphical user interface for calculating support pose and related statistics of multiple objects on some support structure |
►CSurface | Surface is an abstract representation of a smooth surface geometry |
►CImplicitSurface | Interface for implicit surfaces. An implicit surface is given by an expression of the form |
CQuadraticSurface | A quadratic surface |
CSurfaceSample | |
CSyncVelocityRamp | Provides generation of synchronized velocity ramps for a device |
CTactileAreaSwitch | |
CTactileArrayUtil | Utillity class for general computations on a tactile array |
CTactilePadItem | |
CTag | Tags of setup files |
CRenderTargets::Target | |
CSerialDeviceController::Target | |
CParallelIKSolver::Target | A target definition used in the multi-target solve function |
CTaskDescription | Contains description of a task |
CTaskDescriptionLoader | Loads & saves task description from/to XML file |
CTaskGenerator | Provides interface for basic task generator |
►CTaskLoader | Interface for loaders of the task format |
CDOMTaskLoader | Loader for the RobWork task format, using the DOMParser |
CXMLTaskLoader | Loader for the XML task format, based on Xerces |
►CTaskSaver | Interface for savers of the task format |
CDOMTaskSaver | Saver for the RobWork task format, using the DOMParser |
CXMLTaskSaver | Saver for the XML task format, based on Xerces |
CTaskUtils | Collection of utility function associated to tasks |
CEngineTest::TestHandle | Handle for a concrete test run, which makes it possible to interact with the test during simulation |
CTextureData | Container for storing texture data |
CThreadPool | A thread pool that can be assigned work |
CThreadSafeQueue< T > | Queue class which is thread safe, eg. multiple threads may use it at the same time |
CThreadSafeStack< T > | Concurrent queue of WorkPiles |
CThreadSafeStack< T > | Concurrent queue of WorkPiles |
CThreadSafeStack< RestingConfig > | |
CThreadSafeVariable< T > | A thread safe protected variable |
CThreadSafeVariable< bool > | |
CThreadSafeVariable< ParentCallback > | |
CThreadSafeVariable< rw::common::rw::common::Ptr< rw::common::ThreadPool > > | |
CThreadSafeVariable< std::list< rw::common::Exception > > | |
CThreadSafeVariable< std::vector< rw::common::rw::common::Ptr< rw::common::ThreadTask > > > | |
CThreadSafeVariable< TaskState > | |
CThreadSafeVariable< unsigned int > | |
CThreadSimulator | Wraps a simulator in a thread safe interface, and creates a separate thread for the simulator to run in |
CThreadTask | A task that facilitates the use of a hierarchic tree of tasks and subtasks |
CPathAnalyzer::TimeAnalysis | Result struct for Time analysis |
CTimed< T > | A tuple of (time, value) |
CTimedUtil | Construction of paths of Timed values |
CTimeMetricUtil | Methods for analyzing time distance of various paths |
CTimer | The timer class provides an easy to use platform independent timer |
CTimerUtil | Access of the system clock so called wall time |
►CTNLP | |
CModRussel_NLP | Implementation of the Modified Russel beam problem, using the IPOPT TNLP structure |
CTraits< T > | This is a forward declaration of the traits class |
CTraits< BVTREE > | |
CTraits< DESCENTSTRATEGY > | |
CTraits< geometry::BSphere< T > > | Define traits of the OBB |
CTraits< geometry::OBB< T > > | Define traits of the OBB |
CTraits< geometry::OBLSS< T > > | Define traits of the OBLSS |
CTraits< geometry::OBRSS< T > > | Define traits of the OBRSS |
CTraits< proximity::BinaryBVTree< BV, PRIM > > | Define traits of the BinaryBVTree |
CTraits< proximity::BVTreeColliderFactory::BalancedDescentStrategy< BVTREE > > | |
CTraits< proximity::BVTreeColliderFactory::MaxAreaDescentStrategy< BVTREE > > | |
CTraits< rw::geometry::AABB< T > > | Define traits of the AABB |
►CTrajectory< T > | Interface for Trajectories in RobWork |
CBlendedTrajectory< T > | Implements a trajectory with blends between segments. TODO: Briefly describe how |
CInterpolatorTrajectory< T > | Sequence of interpolators and blends giving a trajectory |
CTrajectorySequence< T > | Combines a number of trajectories |
►CTrajectory< rw::math::Q > | |
CInterpolatorTrajectory< rw::math::Q > | |
CDeviceTrajectory | Implements a trajectory with blends between segments. TODO: Briefly describe how |
CTrajectory< rw::math::Rotation3D<> > | |
CTrajectory< rw::math::Transform3D<> > | |
CTrajectory< rw::math::Vector3D<> > | |
►CTrajectory< U > | |
CBlendedTrajectory< U > | |
CInterpolatorTrajectory< U > | |
CTrajectorySequence< U > | |
CTrajectoryFactory | Trajectory constructors |
►CTrajectoryIterator< T > | Forward declaration of Trajectory Iterator (needed for friend declaration) |
CInterpolatorTrajectoryIterator< T > | Bi-directional iterator for running efficiently through a trajectory |
CTrajectoryIterator< U > | |
CTransform2D< T > | A 4x4 homogeneous transform matrix |
CTransform3D< T > | A 4x4 homogeneous transform matrix |
CTransform3D< double > | |
CTransform3D< float > | |
CTrapMethod | Implementation of the trapezoidal rule for integration |
CTreeDistanceCalc | This class encapsulates the methods for iterating through two hierachical BV trees and finding the smallest distance between any triangle in the trees |
CTreeDistanceCalc | This class encapsulates the methods for iterating through two hierachical BV trees and finding the smallest distance between any triangle in the trees |
CTreeState | The tree structure state of a work cell |
CTriangle< T > | Plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise |
CTriangleN1< T > | Triangle facet. triangle class of type N1, which means that beside the plain triangle the face normal of the triangle is saved with the facenormal |
CTriangleN3< T > | Triangle facet. triangle class that stores one normal for each vertex in the triangle |
CTriangleUtil | Utility for triangle manipulation |
CTriangulate | Class for triangulating a polygon |
CTriMesh::TriCenterIterator | Struct for iterating over the centers of triangles in a mesh |
CODEUtil::TriGeomData | |
CODEUtil::TriMeshData | |
CTriMeshSurfaceSampler | Random sampling of points and orientations close to the surface of a geometry |
CTriTriIntersectDeviller< T > | Tests if two triangles are intersecting using devillers method |
CTriTriIntersectMoller< T > | Tests if two triangles are intersecting using Thomas Mollers, 1997, no div method. The code is strongly inspired (read converted to use RobWork types) from Opcode 1.3 Pierre Terdiman 2001 |
CType | Class defining general types |
CTypeRepository | The TypeRepository provides a repository in which types can be mapped to Type objects |
CUnit | |
CSimulator::UpdateInfo | Step info is used when updating controllers, devices and bodies |
CUserContext | |
►CContactStrategyTracking::UserData | Base struct that can be extended for user specific data |
CRWPEUtil::RWPEUserData | Tracking structure that utilizes the features of the contact detector with tracking |
CRWPERestitutionModel::Values | The possible restitution values |
CVector< T > | Configuration vector |
CModel3DS::Vector | |
►Cvector | |
CPath< rw::math::Q > | |
CPath< rw::math::Transform3D<> > | |
CPath< rw::trajectory::Timed< rwlibs::assembly::AssemblyState > > | |
CPath< T > | |
CVector< F > | |
CVector2D< T > | A 2D vector |
CVector2D< float > | |
CVector3D< T > | A 3D vector |
CVector3D< double > | |
CVector3D< float > | |
CVector3D<> | |
CVectorIterator< T > | Forward iterator for vectors of pointers to T |
CVelocityScrew6D< T > | Class for representing 6 degrees of freedom velocity screws |
CBREP::Vertex | Vertex for the half-edge structure |
CModel3DS::Vertex | |
CTriMesh::VerticeIterator | Struct for iterating over the centers of triangles in a mesh |
CSceneViewer::View | view |
CSceneDescriptor::VisualState | Struct for keeping track of the visual state of each frame |
CWorkCell | WorkCell keeps track of devices, obstacles and objects in the scene |
CWorkCellDimension | WorkCellDimension describe a center and the box halflengths of the space that the WorkCell expands |
►CWorkCellLoader | Defines an interface |
CColladaLoader | Enables loading Collada as a WorkCell |
CTULLoader | Loader for the AMROSE TUL format |
CXMLRWLoader | This class loads a workcell in xml format from a filename |
CWorkCellScene | Class for wrapping the SceneGraph interface such that it extends the scene-graph functionality to work on frames and workcells |
CWrench6D< T > | Class for representing 6 degrees of freedom wrenches |
CXercesDocumentReader | Utility class for reading in XML to a DOMDocument |
CXercesDocumentWriter | Utility class for writing a DOMDocument to file |
CXercesInitializer | Utility class which initializes Xerces upon creation |
CXML | XML is a collection of procedures for reading RobWork data structures stored in an XML format |
CXMLBasisTypes | Utility class to help read in the content of a XML-files parsed with Xerces |
CXmlCalibrationLoader | Loads a calibration file for a workcell |
CXmlCalibrationSaver | Save function for writing a work cell calibration in an XML format |
CXMLErrorHandler::XMLError | XML error object |
CXMLErrorHandler | Error handler for XML parsing using boost spirit |
►CXMLFormatTarget | |
COutStreamFormatTarget | XMLFormatTarget for writing to a std::ostream |
CXMLHelpers | Contains assorted methods for parsing XML files |
CXMLPathFormat | Class storing the identifiers used for paths in the XML Path Format |
CXMLPathLoader | Enables loading in path file specified in the RobWork Path XML format |
CXMLPathSaver | Class used for saving a Path using the RobWork XML Path Format |
CXMLPropertyFormat | Class storing the identifiers used for properties in the XML Path Format |
CXMLPropertyLoader | Class for loading rw::common::PropertyMap from XML |
CXMLPropertySaver | Class for saving rw::common::PropertyMap to XML |
CXMLProximitySetupFormat | Format specification for the XML PropertySetup format |
CXMLProximitySetupLoader | Loader for the XML PropertySetup format |
CXMLRWParser | Parses a workcell from the xml fileformat into a dummmy workcell representation |
CXMLRWPreParser | Pre-parser for the XML RW format. All include, define, comments and use elements are handled |
CXMLStr | Utility class to help convert between Xerces unicode XMLCh* and ordinary C/C++ strings |
CXMLTaskFormat | Class storing the identifiers used for paths in the XML Task Format |
CXMLTrajectoryFormat | Class containing the definitions for the XML Trajectory Format |
CXMLTrajectoryLoader | Enables loading in trajectories file specified in the RobWork Trajectory XML format |
CXMLTrajectorySaver | Class for saving trajectories to file |
CXQPController | An extended version of the QPController |
CZ3Planner | Z3 based planners |