| 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 | |
| CAnalyticUtil | Utility functions for functions dealing with analytic geometry |
| 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 |
| 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 |
| ►CBaseContactDetector | |
| CContactDetector | The ContactDetector allows detailed control of the strategies used for contact detection between specific frames and geometry types |
| CThreadedContactDetector | |
| CBasicGPM | 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 |
| CLloydHaywardBlend< V > | |
| 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> |
| Cblocks< T1, T2, T > | A helper class to divide a range into blocks. Used by parallelize_loop() and push_loop() |
| ►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 |
| 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< rw::geometry::BSphere< double > > | |
| CBSphere< T > | Class representing an Bounding sphere |
| 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< double >, rw::geometry::OBB< double > > | |
| 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< double >, rw::geometry::OBB< double > > | |
| COBBToleranceCollider< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
| ►CBVCollider< TriTriToleranceIntersect< double >, rw::geometry::Triangle< double > > | |
| 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< SphereDistanceCalc< double >, rw::geometry::BSphere< double > > | |
| CSphereDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
| ►CBVDistanceCalc< TriDistanceCalc< double >, rw::geometry::Triangle< double > > | |
| CTriDistanceCalc< double > | |
| CTriDistanceCalc< T > | Class for testing if two Oriented Bounding Boxes are overlapping |
| CBVFactory< BV > | Interface of bounding volume factory |
| ►CBVFactory< OBB< double > > | |
| COBBFactory< T > | Factory for computing tight fitting Oriented Bounding Boxes |
| ►CBVTreeFactory::BVShellSplitterStrategy< BV > | Interface for bounding volume splitting strategy for objects with analytical surfaces |
| CBVTreeFactory::OBVShellMedianSplitter< BV > | Spatial Median splitting strategy for shell of analytical surfaces |
| ►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 |
| ►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::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 |
| ►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 |
| 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 |
| CCodeTimer | This class can be used to test how much time is used when executing a part of the code |
| CCollisionResult::CollisionPair | Collision pair of |
| CCollisionResult | Result of a single collision pair |
| CCollisionSetup | Setup for the collision checker |
| CCollisionSetupLoader | |
| 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 |
| CImplicitBREP::CommonParametricCurveSet | Convenience type for a set of curves in a BREP |
| CSerialDeviceController::CompiledTarget | |
| CConcatVectorIterator< T > | Forward iterator for the concatenation of a pair of vectors of pointers to T |
| CConstConcatVectorIterator< T > | Forward iterator for the concatenation of a pair of vectors of pointers to T |
| CXQPController::Constraint | Constraint for the XQPController |
| CLogConstraints::Constraint | Information for a constraint |
| CConstraintEdge | |
| CConstraintFactory | The ContactModelFactory functions as a mediator to the functionallity that is required by the contact graph |
| 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 |
| ►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 |
| CCollisionStrategy::Contact | Describes a simple collision contact data structure |
| CContact | |
| 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 |
| 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 |
| 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 | |
| CGuendelContactModel | |
| 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 |
| CContactModelFactory | The ContactModelFactory functions as a mediator to the functionallity that is required by the contact graph |
| CContactPoint | Representation of a contact point |
| 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 |
| CContour2DInfoMap | Class for analysing 2d contours |
| ►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< N > | Calculates the convex hull of a set of 3d points |
| CCovariance< T > | Class for estimating the covariance of different data |
| CCSGConvert | |
| ►CCSGEngine | An abstact class of the nessesary CSG operations. This is intended to be used in conjuction with SimpleTriMesh |
| CCSGJSEngine | |
| CCSGModel | A CSG (Constructive Solid Geometry) model representation |
| 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, \( \mathbf{p}(t) \in \mathbb{R}^3 \), has its points given as a function of a single parameter, \( t \in \mathbb{R}\) |
| CQuadraticCurve | A quadratic curve |
| 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 |
| ►CPlotView::Dispatcher | Dispatcher for plots |
| CChartView::Dispatcher | Dispatcher for plots |
| 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. |
| CDistanceResultWidget::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 | |
| CDistanceMultiResultWidget::Dispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| 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 |
| CDOMCoreBasisTypes | Utility class to help read in the content of a XML-files parsed with Xerces The Class is part of the core Library in a limited edition. Use DOMBasisTypes for a full implementation |
| CDOMCorePropertyMapLoader | Class for loading rw::core::PropertyMap from XML |
| CDOMCorePropertyMapSaver | Class for saving rw::core::PropertyMap to XML |
| ►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 |
| CDOMPropertyMapFormat | Class storing the identifiers used for properties |
| CDOMPropertyMapLoader | Class for loading rw::core::PropertyMap from XML |
| CDOMPropertyMapSaver | Class for saving rw::core::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 |
| 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 |
| CDynamicWorkCellSaver | Class for saving a WorkCell to a file |
| 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 |
| 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, BodyEventType > | |
| CEvent< DWCChangedListener, DWCEventType, boost::any > | |
| CEvent< FrameSelectedListener, rw::kinematics::Frame * > | |
| CEvent< GenericAnyEventListener, const std::string &, boost::any > | |
| CEvent< GenericEventListener, const std::string & > | |
| CEvent< KeyEventListener, int, Qt::KeyboardModifiers > | |
| CEvent< MousePressedEventListener, QMouseEvent * > | |
| CEvent< PositionSelectedListener, const rw::math::Vector3D<> & > | |
| CEvent< PropertyListener, PropertyBase * > | |
| CEvent< PropertyListener, PropertyValueBase * > | |
| CEvent< StateChangedListener, const rw::kinematics::State & > | |
| CEvent< StateDataAddedListener, const kinematics::StateData * > | |
| CEvent< StateDataRemovedListener, const kinematics::StateData * > | |
| CEvent< StateTrajectoryChangedListener, const rw::trajectory::TimedStatePath & > | |
| CEvent< StateTrajectoryPtrChangedListener, const rw::trajectory::TimedStatePath::Ptr > | |
| CEvent< WorkCellChangedListener, int > | |
| CEventListener< CallBackMethod > | Structure for data associated to a listener |
| ►Cexception | |
| CException | Standard exception type of RobWork |
| ►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< CSGEngine > | |
| CCSGEngine::Factory | Factory for CSGEngine. This factory defines an extension point for CSGEngine |
| ►CExtensionPoint< Dispatcher > | |
| CPlotView::Factory | A factory for PlotView::Dispatcher objects. This factory defines an extension point for PointView::Dispatcher (rws.PlotView). Typically this is for plugins that provide widgets capable of showing and interacting with plots. The extensions registered at this extension point must have an extension descriptor with a property called "identifier" giving a unique identifier for that particular type of PlotView |
| 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< PlotGenerator > | |
| CPlotGenerator::Factory | A factory for PlotGenerators. This factory defines an extension point for PlotGenerators (rw.graphics.PlotGenerator). Typically this is for generation of plots in the form of images. The extensions registered at this extension point must have an extension descriptor with a property called "generator" giving a unique identifier for that particular generator |
| ►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::GeometryData > | |
| CGeometryFactory | Factory for geometric primitive |
| ►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 | A factory for WorkCellLoader. This factory also defines the "rw.loaders.WorkCellLoader" extension point where new loaders can be registered |
| 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 |
| CImplicitFace | Type of Face, where the surface is an ImplicitSurface and the edges are of type ParametricCurve |
| 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< CallBackMethod, _n1, _n1, _n1, _n1, rw::core::_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 |
| CFKRange | Forward kinematics between a pair of frames |
| CFKTable | Forward kinematics for a set of frames |
| CFormData | |
| CFormOptions | |
| ►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< Ptr< ProximityModel > > | |
| CFrameMap< rw::core::Ptr > | |
| CFrameMap< rw::core::Ptr< rw::proximity::ProximityModel > > | |
| CFrameMap< rwsim::dynamics::RigidBody * > | |
| CFrameMap< rwsim::simulator::ConstraintNode * > | |
| CFrameMap< rwsim::simulator::RWBody * > | |
| CFrameMap< std::map< std::string, rw::core::Ptr< rwsim::contacts::ContactModel > > > | |
| CFrameMap< std::vector< rw::core::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 |
| ►CFunction< double, double > | |
| CFunction1Diff< RES_T, ARG_T, GRAD_T > | Interface for functions which are 1 time differentiable |
| 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 |
| CImplicitBREP | Type of BREP where all surfaces are of type ImplicitSurface, and edges are of type ParametricCurve |
| 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. By default the radius is in the x-y plane and height is along the z-axis |
| ►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 |
| CImplicitShell | Type of Shell where all surfaces are of type ImplicitSurface and all curves are of type ParametricCurve |
| 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< double > | |
| CIndexedTriMeshN0< T, S > | Indexed Triangle mesh with zero normals |
| 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 |
| ►CObject3DGeneric | An abstract 3d object consisting of geometry information, material and texture |
| CObject3D< T > | A concrete 3d object consisting of geometry information, material and texture |
| CPlainTriMesh< TRI > | Triangle mesh representation that maintains a list of simple triangles |
| CSimpleTriMesh | A TriMesh with better interactions with the underlying data, and more capabilities |
| 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 |
| 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 |
| ►CGraspRestingPoseDialog | |
| CGraspRestingPoseDialog | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
| CGraspResult | Describes the result of a single 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 |
| ►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 |
| ►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 |
| CHughLineExtractor | |
| 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 | |
| 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 |
| ►CIndexedPolygon< uint16_t > | |
| CIndexedPolygonN< uint16_t > | |
| 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 |
| CIndexedTriangle< T > | |
| 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 |
| CDOMCoreBasisTypes::Initializer | Utility class which initializes local static variables |
| CDOMCorePropertyMapLoader::Initializer | Utility class which initializes local static variables |
| CDOMCorePropertyMapSaver::Initializer | Utility class which initializes local static variables |
| CDOMPropertyMapFormat::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 |
| 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 |
| CXMLTrajectoryFormat::Initializer | Utility class which initializes local static variables |
| CXMLTrajectoryLoader::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 |
| ►CInputSource | |
| CInputStreamSource | Xerces input source for using std::istream |
| CInsertInMap | |
| CInsertLimitInMap | |
| CInsertModelInMap | |
| CInsertPropertyInMap | |
| ►CInterpolator< T > | Interface for interpolators |
| CRampInterpolator< rw::math::Q > | |
| 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::Quaternion< T > > | |
| CCubicSplineInterpolator< rw::math::Quaternion< T > > | |
| CSQUADInterpolator< T > | |
| ►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::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::Transform3DVector< T > > | |
| CCubicSplineInterpolator< rw::math::Transform3DVector< T > > | |
| ►CInterpolator< rw::math::Vector3D< T > > | |
| CCubicSplineInterpolator< rw::math::Vector3D< T > > | |
| CLinearInterpolator< 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< 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 \( 2 \ pi \) 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 |
| 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 | |
| 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 |
| 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 |
| 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 |
| 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 |
| CModel3DS::Material | |
| CMaterialDataMap | A map of materials and friction models defined between materials |
| CModel3DS::MaterialFaces | |
| CObject3DGeneric::MaterialMapData | Mapping from triangles to materials |
| CObject3DGeneric::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< rw::geometry::Line > | |
| CLineMetric | A metric for calculating line-to-line distance |
| ►CMetric< rw::geometry::Plane > | |
| CPlaneMetric | A metric for calculating plane-to-plane distance |
| ►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 and color. he 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 |
| CLoaderPCD | Static methods for reading and writing geometry to and from STL files |
| CLoaderSTEP | Class for loading in IVG files. TODO: add documentation on IVG format |
| CLoaderSTL | Static methods for reading and writing geometry to and from STL files |
| 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 |
| 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 | Calculates the moving average over a continues input of samples |
| CMovingAverage | |
| Cmulti_future< T > | A helper class to facilitate waiting for and/or getting the results of multiple futures at once |
| CContactDataMap::NewtonData | Data required for the Newton collision model |
| CNullSpaceProjection | Performs a projection in the null space of the device Jacobian to move joints away from singularities |
| CModel3DS::Object | |
| COBRManifold | Contact manifold based on Oriented Bounding Rectangle, so in 2D |
| COBV< DERIVED > | General oriented bounding volume class |
| ►COBV< OBB< double > > | |
| COBB< T > | Class representing an Oriented Bounding Box (OBB) |
| 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 | |
| COS | Encapsulates os dependent functionality |
| ►Cpair | |
| Citer_pair< I > | This is a conversion class to make for that c++ 11 ranged for loops can't iterate over a pair of iterators like BOOST_FOREACH could. use case: for (auto item&: getIter_par()) do_somthingg(); |
| ►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 |
| CFramePairMap< int > | |
| CFramePairMap< std::vector< rwsim::dynamics::ContactManifold > > | |
| ►CPairMap< rw::core::Ptr< const Frame >, T > | |
| CFramePairMap< T > | A map from an unordered pair of frames to some value |
| CParallelLeg | Class representing a single leg in a ParallelDevice |
| ►Cparser | |
| CXMLAttElemParser< ParsableAttrT, ParsableElemT > | Parser for xml elements with both attributes and child elements |
| CXMLAttParser< ParsableAttT > | |
| 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< double > > | |
| 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 |
| 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 |
| ►CPlot | Interface for generation of plot images |
| CMathGLPlot | MathGL based implementation of a plot |
| CPlotGenerator | |
| ►CPlotGenerator | Interface for for plot generators |
| CMathGLPlotGenerator | MathGL based implementation of a plot generator |
| CChartViewGenerator | |
| ►CPlotView | GUI Element for showing RobWork plots |
| CChartView | |
| CPlotSimpleView | |
| CPlotViewPlugin | |
| ►CPlugin | Interface for defining dynamically loadable plugins that define extensions and extension points |
| CCSGEJSEnginePlugin | A plugin providing CSGJSEngine for RobWork |
| CAnalyticGeometryPlugin | Plugin adding new analytic geometry types to the rw.loaders.GeometryFactory extension point |
| CSimpleFingerPlugin | |
| CMathGLPlugin | Plugin providing MathGL plots |
| CProximityStrategyPlugin | A plugin providing proximity strategies for RobWork |
| CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
| CChartViewPlugin | Plugin providing plots based on QChartView |
| 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 |
| CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
| ►CPluginFactoryBase | Base class for PluginFactory |
| 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 |
| 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< double, double > | |
| 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 \( \mathbf{x}\in \mathbb{R}^6 \) describes a position and orientation in 3-dimensions |
| CPose6D< T > | A Pose6D \( \mathbf{x}\in \mathbb{R}^6 \) describes a position and orientation in 3-dimensions |
| ►CPoseSampler | |
| CBoxPoseSampler | |
| CSurfacePoseSampler | Random sampling of points and orientations close to the surface of a geometry |
| CPreshapeGraspStrategy | This strategy samples |
| CPrimArrayAccessor< PRIM > | Interface for accessing primitives |
| CPrimArrayAccessor< PRIMType > | |
| ►CPrimArrayAccessor< rw::geometry::GenericFace > | |
| CBVTreeFactory::ShellAccessor< T > | Access GenericFace primitive of Shell |
| ►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< rw::math::Vector3D<> > | |
| CProperty< rw::core::PropertyMap > | |
| CProperty< bool > | |
| 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 |
| ►CPropertyValueBase | Base class for Property handling |
| CPropertyValue< T > | PropertyValue class |
| ►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 |
| CProximityCalculator< T > | The Proximity calculator implements an efficient and standardized way of using the following proximity strategies: |
| ►CProximityCalculator< rw::proximity::CollisionStrategy > | |
| CCollisionDetector | The CollisionDetector implements an efficient way of checking a complete frame tree for collisions |
| CProximityData | Holds settings and cached data for collision detectors |
| 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 |
| 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) |
| ►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 |
| CContactStrategyDMS< T > | Detection of contacts between triangle meshes |
| CContactStrategyGeometry< A, B > | Generic contact strategy that find contacts between two different types of geometry |
| 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< const LinkImpl > | |
| CPtr< const rw::geometry::Geometry > | |
| CPtr< const rw::geometry::ImplicitSurface > | |
| CPtr< const rw::geometry::QuadraticShell > | |
| CPtr< const rw::geometry::QuadraticSurface > | |
| CPtr< const rw::geometry::Shell > | |
| CPtr< const rw::geometry::Surface > | |
| CPtr< const rw::kinematics::Frame > | |
| CPtr< const rw::models::Device > | |
| CPtr< const rw::models::SerialDevice > | |
| CPtr< const rw::models::WorkCell > | |
| CPtr< const rw::pathplanning::QConstraint > | |
| CPtr< const rw::pathplanning::StateConstraint > | |
| CPtr< const rw::proximity::DistanceCalculator > | |
| CPtr< const rwlibs::mathematica::Mathematica::Expression > | |
| CPtr< const rwlibs::pathoptimization::ClearanceCalculator > | |
| 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::LogDistanceMultiResult > | |
| CPtr< const rwsim::log::LogDistanceResult > | |
| 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 Shell > | |
| CPtr< ControllerModel > | |
| CPtr< CSGEngine > | |
| CPtr< csgjs_model > | |
| CPtr< Device > | |
| CPtr< DistanceMultiStrategy > | |
| CPtr< DOMElem > | |
| CPtr< DrawableGeometryNode > | |
| CPtr< DrawableNode > | |
| CPtr< DynamicDevice > | |
| CPtr< DynamicSimulator > | |
| CPtr< DynamicWorkCell > | |
| CPtr< EngineTest > | |
| CPtr< Expression > | |
| CPtr< fclCollisionGeometry > | |
| CPtr< FixedFrame > | |
| CPtr< Frame > | |
| CPtr< FrameGrabber25D > | |
| CPtr< Geometry > | |
| CPtr< GeometryData > | |
| CPtr< GraspResult > | |
| CPtr< GraspTask > | |
| CPtr< GroupNode > | |
| CPtr< Image > | |
| CPtr< InvKinSolver > | |
| CPtr< IterativeIK > | |
| CPtr< JointDevice > | |
| CPtr< Log > | |
| CPtr< LogWriter > | |
| CPtr< Object > | |
| CPtr< Path< TimedState > > | |
| CPtr< placeholder > | |
| CPtr< Plane > | |
| CPtr< Player > | |
| CPtr< PointCloud > | |
| CPtr< PQP::PQP_Model > | |
| CPtr< PropertyMap > | |
| CPtr< ProximityModel > | |
| CPtr< QConstraint > | |
| CPtr< QEdgeConstraint > | |
| CPtr< QEdgeConstraintIncremental > | |
| CPtr< QToQPlanner > | |
| CPtr< Render > | |
| CPtr< RigidBody > | |
| CPtr< RobWork > | |
| CPtr< rw::common::ThreadPool > | |
| CPtr< rw::common::ThreadTask > | |
| CPtr< rw::core::Log > | |
| CPtr< rw::core::LogWriter > | |
| CPtr< rw::core::PropertyMap > | |
| CPtr< rw::core::RobWork > | |
| CPtr< rw::geometry::ConvexHull3D > | |
| CPtr< rw::geometry::Geometry > | |
| CPtr< rw::geometry::IndexedTriMeshN0< float, uint16_t > > | |
| CPtr< rw::geometry::Model3D > | |
| CPtr< rw::geometry::PlainTriMesh< rw::geometry::Triangle<> > > | |
| CPtr< rw::geometry::QHullND< 6 > > | |
| CPtr< rw::geometry::TriMesh > | |
| CPtr< rw::geometry::TriMeshData > | |
| CPtr< rw::graphics::DrawableGeometryNode > | |
| CPtr< rw::graphics::DrawableNode > | |
| CPtr< rw::graphics::GroupNode > | |
| CPtr< rw::graphics::Render > | |
| CPtr< rw::graphics::RenderFrame > | |
| CPtr< rw::graphics::SceneCamera > | |
| 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::Frame > | |
| CPtr< rw::kinematics::MovableFrame > | |
| CPtr< rw::kinematics::State > | |
| CPtr< rw::kinematics::StateCache > | |
| CPtr< rw::kinematics::StateData > | |
| CPtr< rw::kinematics::StateSetup > | |
| CPtr< rw::kinematics::StateStructure > | |
| 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::BVTreeCollider< rw::proximity::BinaryBVTree > > | |
| CPtr< rw::proximity::CollisionDetector > | |
| CPtr< rw::proximity::CollisionSetup > | |
| CPtr< rw::proximity::CollisionStrategy > | |
| CPtr< rw::proximity::DistanceStrategy > | |
| CPtr< rw::proximity::ProximityCache > | |
| CPtr< rw::proximity::ProximityFilterStrategy > | |
| CPtr< rw::proximity::ProximityModel > | |
| CPtr< rw::sensor::Camera > | |
| CPtr< rw::sensor::FTSensorModel > | |
| CPtr< rw::sensor::Image > | |
| CPtr< rw::sensor::Scanner25D > | |
| CPtr< rw::sensor::SensorModel > | |
| 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::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< rws::RobWorkStudio > | |
| CPtr< rws::SensorView > | |
| CPtr< rwsim::contacts::BaseContactDetector > | |
| 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< size_t > > | |
| CPtr< std::vector< ValueType > > | |
| CPtr< Strategy > | |
| CPtr< String > | |
| CPtr< Symbol > | |
| CPtr< TactileArrayModel > | |
| CPtr< Target< T > > | |
| CPtr< TaskBase > | |
| CPtr< TestHandle > | |
| CPtr< TriangleArray > | |
| CPtr< TriMesh > | |
| CPtr< TriMeshData > | |
| CPtr< ValueMatrix > | |
| CPtr< ValueType > | |
| CPtr< VertexArray > | |
| CPtr< View > | |
| CPtr< WorkCell > | |
| CPtr< WorkCellScene > | |
| CPtr< yaobi::CollModel > | |
| CPythonRunner | Class for running multiple python environments in a threadsafe manner |
| CQ | Configuration vector |
| ►CQAbstractItemModel | |
| CSimulatorLogModel | Model of a simulator log for Qt Tree view |
| ►CQCompleter | |
| CTreeModelCompleter | |
| CWCECompleter | |
| CQConfig | |
| CQConstraint | Interface for the checking for collisions for work cell states |
| ►CQDialog | |
| CBodyControlDialog | Dialog used to control dynamic bodies in the scene |
| CCreateEngineDialog | |
| 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 |
| 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 |
| CAboutBox | AboutBox in RobWorkStudio |
| CStrategyLibraryDialog | Dialog showing examples of the available assembly strategies |
| CTaskSetupDialog | Dialog for configuration of an assembly task |
| ►CQDockWidget | |
| ►CRobWorkStudioPlugin | Abstract interface for RobWork Studio plugins |
| CGTaskVisPlugin | A plugin that continuesly grasps an object from a target pose whereafter it is lifted to a home pose |
| CGraspTableGeneratorPlugin | Grphical interface for calculating resting configurations of rigid bodies using rigid body physics simulation |
| CPyPlugin | |
| CRWSimPlugin | A plugin for loading dynamic workcells and for doing simple dynamics simulation using different physics engines |
| CRWSimulatorPlugin | |
| 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 |
| 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 |
| CPyEditor | This plugin can be used to edit python code and run the code directly from RobWorkStudio |
| 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 |
| CWorkcellEditorPlugin | This plugin provides access to the workcell editor of RobWorkStudio |
| CEngineTestPlugin | A plugin for interactive testing of physics engines |
| CATaskVisPlugin | Plugin for visualization of assembly operations |
| ►CQDoubleSpinBox | |
| CRWSSpinBox | Implementation of QDoubleSpinBox with better fixup function |
| CQEdgeConstraint | Edge constraint interface |
| CQEdgeConstraintIncremental | Edge constraint interface for incremental testing of an edge |
| 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 | A lua editor and programming pad designed to resemble a teach pendent for devices in RobWorkStudio |
| CRobWorkStudio | Main robwork studio class |
| CWorkcellEditorWindow | A workcell editor that enables editing of workcells within RobWorkStudio |
| 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 |
| ►CQOpenGLWidget | |
| 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 |
| CQPController | |
| ►CQPlainTextEdit | |
| CCodeEditor | |
| CWCCodeEditor | |
| CQPSolver | Class providing an algorithms for solving the quadratic optimization problem associated with the QPController |
| ►CQPushButton | |
| CFileDialogButton | |
| CSetColorButton | |
| CQSampler | Interface for the sampling a configuration |
| CQState | The configuration state of a work cell |
| ►CQSyntaxHighlighter | |
| CLuaHighlighter | |
| CWorkcellHighlighter | |
| ►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 |
| CQuadraticTestObjects | Library of objects that are made up of Quadratic surfaces |
| CQuadraticUtil | Utility functions for operations on quadratic surfaces and curves |
| CQualityMeasure2D | |
| CCollisionDetector::QueryResult | Result of a collision query |
| CRaycaster::QueryResult | Result of a Raycast query. All contact information are described in ray coordinate frame |
| ►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 | |
| 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 | |
| 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 |
| CDistanceMultiResultWidget | Graphical representation of the log entry rwsim::log::DistanceMultiResultWidget. |
| 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 |
| CDistanceResultWidget | Graphical representation of the log entry rwsim::log::DistanceResultWidget |
| 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 |
| CSimulatorLogWidget | Widget for visualization of a simulation log |
| CSimulatorStatisticsWidget | Widget for visualisation of rwsim::log::SimulatorStatistics |
| CRandom | Generation of random numbers |
| CRANSACModel< MODEL, DATA > | An interface for RANSAC model fitting |
| ►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 |
| CReferencedEdge | |
| CReferencedTriangle | The ReferencedTriangle contains a reference to the mesh it has been created from. Therefore any changes to the triangle wil be reflected in the original mesh |
| CReferencedVertice | The ReferencedVertice contains a reference to the mesh it has been created from. Therefore any changes to the vertice wil be reflected in the original mesh |
| ►CRender | Abstract base class for all renderable classes |
| 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 |
| CRenderText | |
| 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 |
| ►CDrawableNode::RenderInfo | Information for rendering |
| CSceneGraph::SceneGraphRenderInfo | All general render information is located in this struct |
| CRenderUtil | Collection of utillities for rendering |
| CRestingConfig | |
| CRestingPoseGenerator | Finds resting poses of a dynamic scene |
| CDistanceMultiStrategy::Result | DistanceResult contains basic information about the distance result between two frames |
| 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 |
| CLogCollisionResult::ResultInfo | The result including info about the ProximityModels |
| CLogDistanceMultiResult::ResultInfo | The result including info about the ProximityModels |
| CLogDistanceResult::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. The app can be started with either a call to the run() function or the start() function depending on weather you want to run it from current thread or start it up in another tread |
| ►CRobWorkStudioPlugin | |
| CSupportPosePlugin | |
| CRotation2D< T > | A 2x2 rotation matrix \( \mathbf{R}\in SO(2) \) |
| CRotation2D< double > | |
| CRotation2DVector< T > | |
| CRotation3D< T > | A 3x3 rotation matrix \( \mathbf{R}\in SO(3) \) |
| CRotation3D< double > | |
| CRotation3D< float > | |
| CRotation3D< T > | |
| ►CRotation3DVector< T > | An abstract base class for Rotation3D parameterisations |
| CEAA< T > | |
| CQuaternion< T > | |
| ►CRotation3DVector< double > | |
| CEAA< double > | |
| CQuaternion< double > | |
| CEAA< T > | A class for representing an equivalent angle-axis rotation |
| CQuaternion< T > | A Quaternion \( \mathbf{q}\in \mathbb{R}^4 \) a complex number used to describe rotations in 3-dimensional space. \( q_w+{\bf i}\ q_x+ {\bf j} q_y+ {\bf k}\ q_z \) |
| CRPY< T > | A class for representing Roll-Pitch-Yaw Euler angle rotations |
| 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 |
| CProximityStrategyPQP::RWPQPModel | |
| ►CRWSimPlugin | |
| CRWSimPlugin | A plugin for loading dynamic workcells and for doing simple dynamics simulation using different physics engines |
| 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 |
| ►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 |
| ►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 |
| CVectorND< 6, bool > | |
| CKDTreeQ< Node > | |
| CState | 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 |
| CLogDistanceMultiResult | Log detailed info from a multi-distance detection |
| CLogDistanceResult | Log detailed info from a distance detection |
| CLogEquationSystem | Log entry for a linear equation system \(\mathbf{A}\mathbf{x}=\mathbf{b}\) |
| ►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 |
| ►CSimulatorLogScope | A scope can have children, and the type allows hierarchical logging |
| CLogStep | A special type of scope that is also a simulation step |
| 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 |
| ►CSimulatorLogUtil | Utility to make it more convenient to write to a SimulatorLogScope |
| CODELogUtil | Utility to write to SimulatorLog |
| 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 |
| ►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 |
| 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 |
| 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 | |
| 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 |
| 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 |
| ►CThreadSimulator::StepCallback | |
| 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 |
| 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 \( F(\mathbf{x})=0, \mathbf{x} \in \mathbb{R}^3\) |
| CImplicitTorus | Torus defined as an implicit surface |
| CQuadraticSurface | A quadratic surface |
| Csynced_stream | A helper class to synchronize printing to an output stream by different threads |
| CSyncVelocityRamp | Provides generation of synchronized velocity ramps for a device |
| CTactileArrayUtil | Utillity class for general computations on a tactile array |
| CTactilePadItem | |
| CParallelIKSolver::Target | A target definition used in the multi-target solve function |
| CSerialDeviceController::Target | |
| ►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 |
| ►CModel3D::Texture | |
| CTextureData | Container for storing texture data |
| Cthread_pool | A fast, lightweight, and easy-to-use C++17 thread pool class |
| 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::core::Ptr< rw::common::ThreadPool > > | |
| CThreadSafeVariable< std::list< rw::core::Exception > > | |
| CThreadSafeVariable< std::vector< rw::core::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 | A helper class to measure execution time for benchmarking purposes |
| 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< double > | |
| CTraits< float > | |
| CTraits< geometry::BSphere< T > > | |
| CTraits< proximity::BinaryBVTree< BV, PRIM > > | Define traits of the BinaryBVTree |
| CTraits< proximity::BVTreeColliderFactory::BalancedDescentStrategy< BVTREE > > | |
| CTraits< proximity::BVTreeColliderFactory::MaxAreaDescentStrategy< BVTREE > > | |
| CTraits< rw::geometry::OBB< T > > | Define traits of the OBB |
| CTraits< T< R > > | |
| ►CTrajectory< T > | Interface for Trajectories in RobWork |
| 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 > | |
| CBlendedTrajectory< T > | Implements a trajectory with blends between segments. TODO: Briefly describe how |
| CDeviceTrajectory | Implements a trajectory with blends between segments. TODO: Briefly describe how |
| ►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 > | |
| CTransform2DIdentity< T > | A 3x3 homogeneous transform matrix \( \mathbf{T}\in SE(2) \) |
| CTransform2DIdentity< double > | |
| CTransform2DIdentity< float > | |
| CTransform3D< T > | A 4x4 homogeneous transform matrix \( \mathbf{T}\in SE(3) \) |
| CTransform3D< double > | |
| CTransform3D< float > | |
| CTransform3D< T > | |
| CTransform3DVector< T > | This class is a interpolatable Transform3D, consisting of a Vecor3D and a Quaternion. It is implemented to be very Interconvertable with a Transform3D, and allow operations souch as Transform * scalar and Transform + Transform |
| 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 |
| 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 |
| CTriangle< double > | |
| 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 | |
| CTriMeshData | Simple data structure for keeping the information on vertices and triangles this is the underlying data stucture of SimpleTriMesh, and should be used through that |
| 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 |
| 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 |
| CModel3DS::Vector | |
| CVector< T > | Configuration vector |
| ►Cvector | |
| CPath< rw::math::Transform3D<> > | |
| CPath< rw::math::Q > | |
| CPath< rw::trajectory::Timed< rwlibs::assembly::AssemblyState > > | |
| CPath< T > | This is a std::Vector overloaded with some extra constructor functionality |
| CVector2D< T > | A 2D vector \( \mathbf{v}\in \mathbb{R}^2 \) |
| CVector2D< double > | |
| CVector2D< float > | |
| CVector3D< T > | A 3D vector \( \mathbf{v}\in \mathbb{R}^3 \) |
| CVector3D< double > | |
| CVector3D< float > | |
| CVector3D< T > | |
| 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 | |
| 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 | Extendible interface for loading of WorkCells from files |
| 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 | |
| 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 |
| 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::core::PropertyMap from XML |
| CXMLPropertySaver | Class for saving rw::core::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 |
1.9.1