| ►NBS | |
| Cmulti_future | A helper class to facilitate waiting for and/or getting the results of multiple futures at once |
| Cblocks | A helper class to divide a range into blocks. Used by parallelize_loop() and push_loop() |
| Cthread_pool | A fast, lightweight, and easy-to-use C++17 thread pool class |
| Csynced_stream | A helper class to synchronize printing to an output stream by different threads |
| Ctimer | A helper class to measure execution time for benchmarking purposes |
| ►NInputFormDialog | |
| CFormData | |
| CFormOptions | |
| NLineFit | |
| ►Nrw | Deprecated namespace since 16/4-2020 for this class |
| ►Ncommon | Various utilities and definitions of general use |
| Nserialization | Provide generic handler interface for serialization purposes. To enable serialization of some class MyClass one could either inherit from Serializable or provide overloaded methods to |
| CArchive | Archive interface for serializaion classes |
| CBINArchive | Archive for loading and saving serializable classes |
| CCache | This class is a template for caching |
| CCodeTimer | This class can be used to test how much time is used when executing a part of the code |
| CConstConcatVectorIterator | Forward iterator for the concatenation of a pair of vectors of pointers to T |
| CConcatVectorIterator | Forward iterator for the concatenation of a pair of vectors of pointers to T |
| CFileCache | Cache that use a timestamp in combination with a key to determine the uniqueness of an item in the cache |
| CINIArchive | Archive for loading and saving serializable classes to an ini-file format |
| CInputArchive | Archive interface for reading from a serialized class |
| 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 |
| COutputArchive | Serializable objects can be written to an output archive |
| CPairMap | 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 |
| CProgramOptions | Class for parsing program command line into a PropertyMap |
| CScopedTimer | Times what is executed in a scope |
| 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 |
| CThreadSafeVariable | A thread safe protected variable |
| CThreadPool | A thread pool that can be assigned work |
| CThreadSafeQueue | Queue class which is thread safe, eg. multiple threads may use it at the same time |
| CThreadSafeStack | Concurrent queue of WorkPiles |
| CThreadTask | A task that facilitates the use of a hierarchic tree of tasks and subtasks |
| CTimer | The timer class provides an easy to use platform independent timer |
| CTimerUtil | Access of the system clock so called wall time |
| CConstVectorIterator | Forward iterator for vectors of pointers to const T |
| CVectorIterator | Forward iterator for vectors of pointers to T |
| ►Ncontrol | |
| CSyncVelocityRamp | Provides generation of synchronized velocity ramps for a device |
| ►Ncore | Most basic types for RobWork |
| CPtr | Ptr stores a pointer and optionally takes ownership of the value |
| CAnyPtr | Smart pointer that can point to any type, and optionally takes ownership of the object pointer |
| ►CBoostXMLParser | DOMParser implementation based on the Boost xml parser in propertytree |
| CBoostInitializer | Utility class which initializes Boost local static variables |
| CBoostDOMElem | DOMElem based on Boost PropertyTree xml parser |
| ►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 |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMCorePropertyMapLoader | Class for loading rw::core::PropertyMap from XML |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMCorePropertyMapSaver | Class for saving rw::core::PropertyMap to XML |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMElem | Wrapper interface for easy access to XML DOM parser. This require an active back-end that does the actual parsing and validation |
| CIterator | DOMElem iterator based on concrete ItImpl implementations |
| CItImpl | The DOMElem Iterator is initialized with a specific implementation of this interface |
| ►CDOMParser | Interface for parsing documents in a DOM fasion |
| CFactory | 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 |
| ►CDOMPropertyMapFormat | Class storing the identifiers used for properties |
| CInitializer | Utility class which initializes local static variables |
| C_n1 | |
| C_n2 | |
| C_n3 | |
| C_n4 | |
| C_n5 | |
| C_n6 | |
| C_n7 | |
| C_n8 | |
| CFireFunctor | FireFunctor with 0 arguments |
| CEventListener | Structure for data associated to a listener |
| CEvent | Event is used for managing subscribtions and firing of events |
| 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 |
| CException | Standard exception type of RobWork |
| ►CExtension | Used to provide additonal functionality from a Plugin to other extension points of either the system or other plugins |
| CDescriptor | An extension descriptor |
| CExtensionPoint | 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 |
| 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 |
| CIOUtil | Collection of IO related utilities |
| CLog | Provides basic log functionality |
| CLogStreamWriter | Writes log output to a std::ostream |
| CLogWriter | Write interface for Logs |
| CMessage | Standard type for user messages of robwork |
| Citer_pair | 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(); |
| CPlugin | Interface for defining dynamically loadable plugins that define extensions and extension points |
| CProperty | 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 |
| CPropertyBase | Base class for Property handling |
| CPropertyMap | Container for a collection of Property Objects |
| CPropertyType | Represents type of a property |
| CPropertyValue | PropertyValue class |
| CPropertyValueBase | Base class for Property handling |
| CRobWork | RobWork instance which holds objects to be shared among multiple plugins |
| CStringUtil | Collection of string manipulation utilities |
| ►Ngeometry | Loading and storing of CAD models |
| Nqhull | |
| CAABB | Axis Aligned Bounding Box class |
| CAnalyticUtil | Utility functions for functions dealing with analytic geometry |
| ►CBREP | Boundary representation (or B-Rep) of a geometric shape, using a collection of connected surfaces, edges and vertices |
| CCommonCurveSet | Convenience type for a set of curves in a BREP |
| CFace | Face concept in the half-edge structure |
| CHalfEdge | Half-edge structure |
| CVertex | Vertex for the half-edge structure |
| CCurve | Curve is an abstract representation of a smooth curve geometry in 3D |
| CFace | Abstract interface for geometric faces |
| CGenericFace | The GenericFace implementation is a type of Face that consist of abstract Surfaces and Curves |
| ►CImplicitBREP | Type of BREP where all surfaces are of type ImplicitSurface, and edges are of type ParametricCurve |
| CCommonParametricCurveSet | Convenience type for a set of curves in a BREP |
| CImplicitFace | Type of Face, where the surface is an ImplicitSurface and the edges are of type ParametricCurve |
| CImplicitShell | Type of Shell where all surfaces are of type ImplicitSurface and all curves are of type ParametricCurve |
| 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 |
| ►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 |
| CIndexedFace | Structure that holds information for each face |
| 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}\) |
| ►CIndexedQuadraticFaceArray | Proxy class for a QuadraticShell, that allows sorting of faces without modifying the original object |
| CIndexedFace | Structure that holds information for each face |
| CPlainQuadraticShell | A collection of concrete Quadratic surface patches, that together form a shell |
| ►CQuadraticBREP | A boundary representation where the geometry of a face is a QuadraticSurface, and an edge curve is a QuadraticCurve |
| CCommonQuadraticCurveSet | Convenience type for a set of curves in a QuadraticBREP |
| CQuadraticCurve | A quadratic curve |
| CQuadraticFace | A Quadratic surface patch bounded by Quadratic curves |
| CQuadraticShell | A collection of Quadratic surface patches, that together form a shell |
| CQuadraticSurface | A quadratic surface |
| CQuadraticUtil | Utility functions for operations on quadratic surfaces and curves |
| CShell | A shell represents the geometry of an object as a collection of non-connected faces |
| CSurface | Surface is an abstract representation of a smooth surface geometry |
| CBox | Box primitive, origin is in center of box |
| CBSphere | Class representing an Bounding sphere |
| CBV | General bounding volume class for template inheritance. This class defines methods that a deriving class must implement |
| COBV | General oriented bounding volume class |
| CBVFactory | Interface of bounding volume factory |
| CBVCollider | Abstract class describing interface of a bounding volume collision detector. The inheritance is template based to reduce virtual method overhead |
| CCone | Cone primitive. Like a cylinder though where a radius can be specified for both ends |
| ►CContour2D | Class representing a 2d contour |
| CPoint | Point description of the contour |
| CConvexHull2D | Interface for convexhull calculators on 2d point sets |
| CConvexHull3D | Interface for convexhull calculators on 3d point sets |
| CConvexHullND | Interface for convexhull calculators on 3d point sets |
| CCovariance | Class for estimating the covariance of different data |
| 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 |
| ►CCSGEngine | An abstact class of the nessesary CSG operations. This is intended to be used in conjuction with SimpleTriMesh |
| CFactory | Factory for CSGEngine. This factory defines an extension point for CSGEngine |
| CCylinder | Cylinder primitive. By default the radius is in the x-y plane and height is along the z-axis |
| CDelaunay | Utility functions for doing Delaunay triangulations |
| CDistanceUtil | Class for performing distance calculations between different geometric primitives |
| CGeometry | Class for representing a geometry that is scaled and transformed, and which is attached to a frame |
| CGeometryData | Interface for geometry data |
| CGeometryUtil | Utility functions for calculating properties of geometry |
| CHyperSphere | A hyper-sphere of K dimensions |
| CIndexedPolygon | Indexed polygon class that saves N indices to the N vertices of the polygon |
| CIndexedPolygonN | Polygon with N vertice indices and 0 normals |
| CIndexedPolygonNN | Polygon with N vertices and N normals |
| CIndexedTriangle | Indexed triangle class that has 3 indices that points to 3 vertices in an array typically used with the IndexedTriMesh class. the indice type (size) is templated |
| CIndexedTriangleN1 | Indexed triangle class with an additional index for an face normal |
| CIndexedTriangleN3 | Indexed triangle class with an additional index for 3 normals one for each vertice in the triangle |
| CIndexedTriArray | This class is a proxy to a triangle mesh where the triangles can be indirectly copied in an efficient manner |
| CIndexedTriMesh | Interface for indexed triangle meshes |
| CIndexedTriMeshN0 | Indexed Triangle mesh with zero normals |
| CIntersectUtil | Utility class for calculating intersection points between geometry primitives |
| CLine | A line in 3D, described by a two points |
| CLineMetric | A metric for calculating line-to-line distance |
| ►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 |
| CMaterial | 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 |
| CTexture | |
| COBB | Class representing an Oriented Bounding Box (OBB) |
| COBBCollider | 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" |
| COBBFactory | Factory for computing tight fitting Oriented Bounding Boxes |
| COBBToleranceCollider | Class for testing if two Oriented Bounding Boxes are overlapping |
| ►CObject3DGeneric | An abstract 3d object consisting of geometry information, material and texture |
| CMaterialMapData | Mapping from triangles to materials |
| CMaterialPolys | Ordering polygons by material consumes more memmory but reduce switches between textures. All indices _subFaces share material _matIndex |
| CObject3D | A concrete 3d object consisting of geometry information, material and texture |
| CPlainTriMesh | Triangle mesh representation that maintains a list of simple triangles |
| CPlane | Plane primitive represented in Hessian normal-form: a*nx+b*ny+c*nz+d=0 |
| CPlaneMetric | A metric for calculating plane-to-plane distance |
| 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 |
| CPolygon | 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 |
| CPrimitive | Defines an interface for a geometric shape that is defined by a set of parameters |
| 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 |
| CQHull3D | Calculates the convex hull of a set of 3d points |
| CQHullND | Calculates the convex hull of a set of 3d points |
| CRay | A ray - an infinitely extending half-line described by a starting position and a direction |
| 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 |
| CSimpleTriMesh | A TriMesh with better interactions with the underlying data, and more capabilities |
| CSphere | Sphere primitive. centr in (0,0,0) and a radius |
| CTriangle | Plain triangle class. The second template argument specify the number of normals associated with the triangle. The triangle vertices should be arranged counter clock wise |
| CTriangleN1 | 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 | 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 |
| CTriDistanceCalc | Class for testing if two Oriented Bounding Boxes are overlapping |
| ►CTriMesh | Interface of a triangle mesh. The interface defines a way to get triangles from a triangle array/mesh |
| CTriCenterIterator | Struct for iterating over the centers of triangles in a mesh |
| CVerticeIterator | Struct for iterating over the centers of triangles in a mesh |
| CTriMeshSurfaceSampler | Random sampling of points and orientations close to the surface of a geometry |
| CTriTriIntersectDeviller | Tests if two triangles are intersecting using devillers method |
| CTriTriIntersectMoller | 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 |
| CTriTriToleranceIntersect | Tests if two swept sphere triangles are intersecting. This corresponds to testing if two triangles are within a certain distqance (tolerance) of each other |
| CTube | Tube primitive. radius is in xy-plane and height is in z-axis |
| ►Ngraphics | Generic scene graph related stuff |
| CDrawableGeometryNode | A specific type of DrawableNode that is able to draw a rw::geometry::Geometry |
| ►CDrawableNode | Abstract base class for all drawable classes |
| CRenderInfo | Information for rendering |
| CDrawableNodeClone | Abstract base class for all drawable classes |
| CGroupNode | SceneNode that has a transformation and 0 to many children |
| CPlot | Interface for generation of plot images |
| ►CPlotGenerator | Interface for for plot generators |
| CFactory | 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 |
| CRender | Abstract base class for all renderable classes |
| CSceneCamera | Node representing a camera in the scene. A SceneCamera sets up everything from rendering buffer to perspective transform |
| CCameraGroup | A group of cameras |
| ►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 |
| CDrawableProxy | Proxy class to represent some type of loadable and drawable entity |
| CVisualState | Struct for keeping track of the visual state of each frame |
| ►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 |
| CSceneGraphRenderInfo | All general render information is located in this struct |
| CSceneNode | Node that can have leafs (DrawableNode) or other nodes as children |
| ►CSceneViewer | Interface for viewing a scene graph |
| CView | |
| CTextureData | Container for storing texture data |
| CWorkCellScene | Class for wrapping the SceneGraph interface such that it extends the scene-graph functionality to work on frames and workcells |
| ►CModel3DS | |
| CChunkHeader | |
| CColor4i | |
| CMaterial | |
| CMaterialFaces | |
| CObject | |
| CVector | |
| CVertex | |
| ►Ngraspplanning | |
| 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) |
| 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 |
| 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 |
| CContactValidateFilter | Tests if a contact is valid in respect to some criterias implemented by a sub class |
| CContour2DInfoMap | Class for analysing 2d contours |
| CCurvatureThresFilter | Tests if a grasp is valid in respect to the curvature of the object surface in and around the contact points |
| 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 |
| 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 |
| CGraspQualityMeasure3D | Interface for methods evaluating the quality of a specific grasp |
| ►CGraspTable | A table of grasp configurations that has been generated using a robot hand, a number of preshapes, and some grasp policy |
| CGraspData | Data for describing a single grasp |
| CGraspValidateFilter | Tests if a grasp is valid in respect to some criterias implemented by a sub class |
| CGWSMeasure3D | Represents the grasp wrench space as a 3D force space and a 3D torque space |
| CPlaneClearanceFilter | Tests if a grasp is valid in respect to the distance of each contact point to some plane |
| CQualityMeasure2D | |
| CSemiForceClosureFilter | A conservative estimate of the force closure properties of the grasp are used to indicate weather a grasp is valid or not |
| ►Ninvkin | Inverse kinematics interfaces and iksolver classes |
| CAmbiguityResolver | Wraps a InvKinSolver and searches for ambiguities due to joint able to rotate \( 2 \ pi \) or more |
| 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 |
| 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 |
| CIKMetaSolver | Solve the inverse kinematics problem with respect to joint limits and collisions |
| CInvKinSolver | Interface for inverse kinematics algorithms |
| CIterativeIK | Interface for iterative inverse kinematics algorithms |
| CIterativeMultiIK | Interface for iterative inverse kinematics algorithms for problems or devices that utilize more than one end-effector |
| CJacobianIKSolver | A Jacobian based iterative inverse kinematics algorithm for devices with a single end effector |
| CJacobianIKSolverM | A Jacobian based iterative inverse kinematics algorithm for devices with multiple end effectors |
| ►CParallelIKSolver | Inverse kinematics method for parallel devices |
| CTarget | A target definition used in the multi-target solve function |
| CPieperSolver | Calculates the closed form inverse kinematics of a device using Piepers method |
| ►Nkinematics | Kinematic modelling |
| CFixedFrame | FixedFrame is a frame for which the transform relative to the parent is constant |
| CFKRange | Forward kinematics between a pair of frames |
| CFKTable | Forward kinematics for a set of frames |
| CFrame | The type of node of forward kinematic trees |
| CFrameMap | Specialized mapping implementation for frames. It uses the internal structure of Frames to provide fast O(1) lookup for mappings from Frame to anything |
| CFramePairMap | A map from an unordered pair of frames to some value |
| CFrameType | Enumeration of all concrete frame types of RobWork |
| CKinematics | Utility functions for the rw::kinematics module |
| CMovableFrame | MovableFrame is a frame for which it is possible to freely change the transform relative to the parent |
| CQState | The configuration state of a work cell |
| CState | The state of a work cell (or kinematics tree) |
| 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 |
| 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 |
| CStateless | Interface for a stateless or typically a part stateless class |
| CStatelessData | Class for enabling statelessness in classes that are data containers |
| CStateSetup | Utility class to help construct a State |
| CStateStructure | StateStructure is responsible for handling a structure of StateData and Frames |
| CTreeState | The tree structure state of a work cell |
| ►Nloaders | Workcell loaders and other loaders |
| CCollisionSetupLoader | |
| ►CDOMBasisTypes | Utility class to help read in the content of a XML-files parsed with Xerces |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMPathLoader | Enables loading in path file specified in the RobWork Path XML format |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMPathSaver | Class used for saving a Path using the RobWork XML Path Format |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMPropertyMapFormat | Class storing the identifiers used for properties |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMPropertyMapLoader | Class for loading rw::core::PropertyMap from XML |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMPropertyMapSaver | Class for saving rw::core::PropertyMap to XML |
| CInitializer | Utility class which initializes local static variables |
| CDOMProximitySetupLoader | Loader for the XML PropertySetup format |
| ►CDOMProximitySetupSaver | Class for saving rw::proximity::ProximitySetup to XML |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMTrajectoryLoader | Enables loading in trajectories file specified in the RobWork Trajectory XML format |
| CInitializer | Utility class which initializes local static variables |
| ►CDOMTrajectorySaver | Class for saving trajectories to file |
| CInitializer | Utility class which initializes local static variables |
| CDOMWorkCellSaver | Class for saving a WorkCell to a file |
| CGeometryFactory | Factory for geometric primitive |
| 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 |
| ►CImageLoader | Image loader interface |
| CFactory | Factory for ImageLoader. This factory also defines an extension point for image loaders |
| 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 |
| CSTLFile | Static methods for reading and writing geometry to and from STL files |
| CModel3DFactory | Factory for construction of drawables based on their type |
| ►CModel3DLoader | Interface for classes that are able to load 3d models |
| CFactory | Factory for Model3DLoaders. This factory defines an extension point for Model3DLoaders |
| CPathLoader | Load and store for various types of paths |
| CPathLoaderCSV | Loader for .csv files |
| CDependencyGraph | This class is used to create a dependency graph between string nodes and to check if any cycles exist in the dependency graph |
| CMultipleFileIterator | This class is used to iterate over multiple files, keeping track of the current file and current line number at all times |
| CXML | |
| ►CXMLErrorHandler | Error handler for XML parsing using boost spirit |
| CXMLError | XML error object |
| CXMLAttElemParser | Parser for xml elements with both attributes and child elements |
| CXMLAttParser | |
| CXMLRWLoader | This class loads a workcell in xml format from a filename |
| 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 |
| ►CWorkCellLoader | Extendible interface for loading of WorkCells from files |
| CFactory | A factory for WorkCellLoader. This factory also defines the "rw.loaders.WorkCellLoader" extension point where new loaders can be registered |
| CXercesErrorHandler | Error handler for the Xerces parser |
| CXMLStr | Utility class to help convert between Xerces unicode XMLCh* and ordinary C/C++ strings |
| CXercesInitializer | Utility class which initializes Xerces upon creation |
| COutStreamFormatTarget | XMLFormatTarget for writing to a std::ostream |
| CXMLInputStream | BinInputStream for wrappuing a std::istream |
| CInputStreamSource | Xerces input source for using std::istream |
| CXercesDocumentReader | Utility class for reading in XML to a DOMDocument |
| CXercesDocumentWriter | Utility class for writing a DOMDocument to file |
| ►CXMLBasisTypes | Utility class to help read in the content of a XML-files parsed with Xerces |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPathFormat | Class storing the identifiers used for paths in the XML Path Format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPathLoader | Enables loading in path file specified in the RobWork Path XML format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPathSaver | Class used for saving a Path using the RobWork XML Path Format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPropertyFormat | Class storing the identifiers used for properties in the XML Path Format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPropertyLoader | Class for loading rw::core::PropertyMap from XML |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLPropertySaver | Class for saving rw::core::PropertyMap to XML |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLProximitySetupFormat | Format specification for the XML PropertySetup format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLProximitySetupLoader | Loader for the XML PropertySetup format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLTrajectoryFormat | Class containing the definitions for the XML Trajectory Format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLTrajectoryLoader | Enables loading in trajectories file specified in the RobWork Trajectory XML format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLTrajectorySaver | Class for saving trajectories to file |
| CInitializer | Utility class which initializes local static variables |
| ►Nmath | Matrices, vectors, configurations, and more |
| CCameraMatrix | The PerspectiveTransform2D is a perspective transform in 2D. The homographic transform can be used to map one arbitrary 2D quadrilateral into another |
| ►CEigenDecomposition | Type representing a set of eigen values and eigen vectors |
| CMapSort | Sort function for ordering of eigen values and vectors |
| CEAA | A class for representing an equivalent angle-axis rotation |
| CFunction | Interface for functions |
| CInertiaMatrix | A 3x3 inertia matrix |
| CMetric | Template interface for metrics on type T |
| CManhattanMetric | Manhattan distance metric for vector types |
| CWeightedManhattanMetric | Weighted Manhattan distance metric for vector types |
| CEuclideanMetric | Euclidean distance metric for vector types |
| CWeightedEuclideanMetric | Weighted Euclidean metric for vector types |
| CInfinityMetric | Infinity norm distance metric for vector types |
| CWeightedInfinityMetric | Weighted infinity norm metric for vector types |
| CMahalanobisMetric | Mahalanobis distance metric for vector types |
| CRotation3DAngleMetric | Distance metric over rotations. The distance between two rotations is the smalles angle that rotates the one into the other |
| CTransform3DAngleMetric | Distance metrics between points in SE3 |
| CPerspectiveTransform2D | The PerspectiveTransform2D is a perspective transform in 2D |
| CPolynomial | Representation of an ordinary polynomial with scalar coefficients (that can be both real and complex) |
| CPose2D | A Pose3D \( \mathbf{x}\in \mathbb{R}^6 \) describes a position and orientation in 3-dimensions |
| CPose6D | A Pose6D \( \mathbf{x}\in \mathbb{R}^6 \) describes a position and orientation in 3-dimensions |
| CQuaternion | 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 \) |
| CRotation2D | A 2x2 rotation matrix \( \mathbf{R}\in SO(2) \) |
| CRotation3D | A 3x3 rotation matrix \( \mathbf{R}\in SO(3) \) |
| CRotation3DVector | An abstract base class for Rotation3D parameterisations |
| CRPY | A class for representing Roll-Pitch-Yaw Euler angle rotations |
| CStatistics | Class for collecting data and calculating simple statistics |
| CTransform2D | |
| CTransform3D | A 4x4 homogeneous transform matrix \( \mathbf{T}\in SE(3) \) |
| CVector | Configuration vector |
| CVector2D | A 2D vector \( \mathbf{v}\in \mathbb{R}^2 \) |
| CVector3D | A 3D vector \( \mathbf{v}\in \mathbb{R}^3 \) |
| CVectorND | A N-Dimensional Vector |
| CVelocityScrew6D | Class for representing 6 degrees of freedom velocity screws |
| CWrench6D | Class for representing 6 degrees of freedom wrenches |
| CFunction1Diff | Interface for functions which are 1 time differentiable |
| CJacobian | A Jacobian class. A jacobian with m rows and n columns |
| CLine2D | Describes a line segment in 2D |
| CLine2DPolar | Describes a line in 2D in polar coordinates |
| ►CLinearAlgebra | Collection of Linear Algebra functions |
| CEigenMatrix | Type for Eigen matrices used to reduce namespace cluttering |
| CEigenVector | Type for Eigen vectors, used to reduce namespace cluttering |
| CMath | Utility functions for the rw::math module |
| CMetricFactory | Metric constructor functions |
| CMetricUtil | Various metrics and other distance measures |
| CPolynomialND | Representation of a polynomial that can have non-scalar coefficients (polynomial matrix) |
| CPolynomialSolver | Find solutions for roots of real and complex polynomial equations |
| CProjectionMatrix | Projection matrix |
| CQ | Configuration vector |
| CRandom | Generation of random numbers |
| CRotation2DVector | |
| CTransform2DIdentity | A 3x3 homogeneous transform matrix \( \mathbf{T}\in SE(2) \) |
| CTransform2DIdentity< double > | |
| CTransform2DIdentity< float > | |
| CTransform3DVector | 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 |
| ►Nmodels | Workcell and device models |
| CCompositeDevice | A device constructed from a sequence of devices |
| CCompositeJointDevice | A device constructed from a sequence of devices |
| 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 |
| ►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 |
| CDeformableObjectCache | |
| 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 |
| CDevice | An abstract device class |
| CDeviceJacobianCalculator | Calculator for Jacobians of one or several Devices |
| CDHParameterSet | Simple class to help represent a set of Denavit-Hartenberg parameters |
| CJacobianCalculator | JacobianCalculator provides an interface for obtaining a Jacobian |
| CJacobianUtil | Primitive utilities for computing jacobians for joints of various types |
| CJoint | A Joint is a Frame with assignable values for position, velocity limits and acceleration limits |
| CJointDevice | A device for a sequence of joints |
| CJointDeviceJacobianCalculator | Calculator for Jacobians of a JointDevice |
| CMobileDevice | Provides a differential controlled mobile device |
| CModels | Utility functions for the rw::models module |
| 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 |
| CParallelDevice | This class defines the interface for Parallel devices |
| CParallelLeg | Class representing a single leg in a ParallelDevice |
| 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 |
| CRigidBodyInfo | A class to wrap rigid body information |
| 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 |
| CSE3Device | A Cartesian 6-Dof device |
| CSerialDevice | The device for a serial chain |
| CSphericalJoint | A spherical joint that allows rotations in all directions |
| CTreeDevice | A tree structured device |
| CUniversalJoint | A universal joint that allows rotations in two directions |
| CVirtualJoint | Virtuals joints |
| CWorkCell | WorkCell keeps track of devices, obstacles and objects in the scene |
| ►Npathplanning | Path-planning for devices |
| ►CPathAnalyzer | The PathAnalyzer provides a set a basic tools for analyzing a path |
| CCartesianAnalysis | Result struct for Cartesian analysis |
| CClearanceAnalysis | Result struct for CleracenAnalysis |
| CJointSpaceAnalysis | Result struct for joint space analysis |
| CTimeAnalysis | Result struct for Time analysis |
| CPathPlanner | Path planner interface |
| CPlannerConstraint | A tuple of (QConstraintPtr, QEdgeConstraintPtr) |
| CPlannerUtil | PlannerUtil provides various utilities useful in path planning |
| CQConstraint | Interface for the checking for collisions for work cell states |
| 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 |
| CQNormalizer | Normalization of configurations |
| CQSampler | Interface for the sampling a configuration |
| CQToQPlanner | Path planner interface |
| CQToQSamplerPlanner | Sampled region planner interface |
| CQToTPlanner | Approach planner interface |
| ►CQToTrajPlanner | Interface for planning robot trajectories with tool path trajectory constraints |
| CFactory | 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 |
| CStateConstraint | Interface for the checking for collisions for work cell states |
| CStopCriteria | StopCriteria is a class for specifying an instant a compution should be aborted |
| ►Nplugin | The plugin infrastructure, including extension and extension point mechanism |
| CDynamicLibraryLoader | Loader for dynamic/shared libraries |
| CDynamicLibraryLoaderBase | Base for DynamicLibraryLoader |
| CPluginFactory | Template class form which to inherit when creating a factory for a plugin |
| CPluginFactoryBase | Base class for PluginFactory |
| CPluginRepository | The PluginRepository provides a container load methods for plugins |
| ►Nproximity | Interfaces for collision checking and distance calculation |
| CBVDistanceCalc | |
| CSphereDistanceCalc | Class for testing if two Oriented Bounding Boxes are overlapping |
| 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 |
| ►CCollisionDetector | The CollisionDetector implements an efficient way of checking a complete frame tree for collisions |
| CQueryResult | Result of a collision query |
| ►CCollisionResult | Result of a single collision pair |
| CCollisionPair | Collision pair of |
| CCollisionSetup | Setup for the collision checker |
| ►CCollisionStrategy | An interface that defines methods to test collision between two objects |
| CContact | Describes a simple collision contact data structure |
| CFactory | A factory for a CollisionStrategy. This factory also defines an ExtensionPoint |
| ►CCollisionToleranceStrategy | This is a collision strategy that detects collisions between objects that are closer than a specified tolerance |
| CFactory | A factory for a CollisionToleranceStrategy. This factory also defines an ExtensionPoint |
| CDistanceCalculator | The DistanceCalculator implements an efficient way of calculating different distances between two objects, each represented by a frame |
| ►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 |
| CFactory | A factory for a DistanceMultiStrategy. This factory also defines an ExtensionPoint |
| CResult | DistanceResult contains basic information about the distance result between two frames |
| ►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 |
| CFactory | A factory for a DistanceStrategy. This factory also defines an ExtensionPoint |
| CResult | DistanceResult contains basic information about the distance result between two sets of geometries. These geometry sets |
| CProximityCache | Interface for cache used by ProximityStrategy |
| CProximityCalculator | The Proximity calculator implements an efficient and standardized way of using the following proximity strategies: |
| 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 |
| CProximityModel | Class for managing the collision geometries associated to a frame |
| 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 |
| CFactory | A factory for a ProximityStrategy. This factory also defines an ExtensionPoint |
| CProximityStrategyData | |
| ►CRaycaster | Raycast implementation that relies on a collision strategy for finding the collision between the ray and the scene |
| CQueryResult | Result of a Raycast query. All contact information are described in ray coordinate frame |
| ►CBTPNode | 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 |
| CNodeIterator | Iterator for the PtrNode |
| CBinaryBVTree | 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 |
| CPrimArrayAccessor | Interface for accessing primitives |
| CBVTreeIterator | |
| CBVTree | 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 |
| CBVTreeCollider | This class encapsulates the methods for iterating through two hierachical OBV trees while testing if the BV's are disjoint |
| ►CBVTreeColliderFactory | Factory for creating tree colliders |
| CBalancedDescentStrategy | Balanced descent strategy. The previous descent choice is saved and the oposite is choosen if |
| CBVDescentStrategy | Template base class to deside which node to descent into |
| CMaxAreaDescentStrategy | |
| ►CBVTreeFactory | Factory for creating bounding volume trees |
| CBVShellSplitterStrategy | Interface for bounding volume splitting strategy for objects with analytical surfaces |
| CBVSplitterStrategy | Interface of bounding volume splitting strategy |
| COBVMeanSplitter | Spatial Median splitting strategy. The median of the bounding volume projection extends are used as splitting point |
| COBVMedianSplitter | Object median splitting strategy using axis of largest variance. Splits the mesh in the median on the axis with largest variance |
| COBVShellMedianSplitter | Spatial Median splitting strategy for shell of analytical surfaces |
| COBVSpatialMedianSplitter | Spatial Median splitting strategy. The median of the bounding volume projection extends are used as splitting point |
| CShellAccessor | Access GenericFace primitive of Shell |
| CTriMeshAccessor | |
| CBVTreeToleranceCollider | 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 |
| COBVTreeDFSCollider | 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 |
| ►CProximityStrategyRW | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
| CModel | |
| CPCache | Cache for any of the queries possible on this strategy |
| CRWProximityModel | |
| CSAPFilterStrategy | This is a Sweep-And-Prune based filter strategy (broadphase strategy) |
| CTreeDistanceCalc | This class encapsulates the methods for iterating through two hierachical BV trees and finding the smallest distance between any triangle in the trees |
| ►Nsensor | Sensor interfaces |
| 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 |
| CCameraListener | Interface used for listening for camera events |
| ►CCameraModel | Defines a generel pinhole camera model where camera parameters and state values are stored |
| CCameraModelCache | CameraModelCache that define data to store in the State |
| CContact2D | Data structure for describing a contact in 2D |
| CContact3D | Data structure for describing a contact in 3D |
| CFTSensor | Interface of a N-axis Force Torque sensor |
| CFTSensorModel | N-axis Force Torque sensor model |
| CPixel4f | |
| ►CImage | The image class is a simple wrapper around a char data array. This Image wrapper contain information of width, height and encoding |
| CPixel4i | |
| CImageUtil | Collection of simple image utility functions |
| CRGBDCameraModel | |
| CScanner | This interface describe a generic range scanning class |
| CScanner1D | One dimensional range 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 |
| ►CScanner25DModel | Model of a 25D (2D with depth information) scanner. The images are essentially point clouds |
| CScanner25DModelCache | Cache object for storing relevant state information |
| CScanner2D | The Scanner2D sensor encapsulate the basic interface of a 2 dimensional range scanning device such as SICK or Hokyuo laser range scanners |
| ►CScanner2DModel | The Scanner2DModel encapsulate the basic model of a 2 dimensional range scanning device such as SICK or Hokyuo laser range scanners |
| CScanner2DModelCache | Cache to allow storing state information |
| 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 |
| CSensorData | Toplevel class for sensor data. Basicly describes interface for setting and getting timestamps |
| 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 |
| 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 |
| CTactileArray | |
| ►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 |
| CTactileModelCache | Cache to store state information |
| CTactileArrayUtil | Utillity class for general computations on a tactile array |
| Ntask | Task descriptions |
| ►Ntrajectory | Trajectory, path, interpolation and blending |
| CPath | This is a std::Vector overloaded with some extra constructor functionality |
| CBlend | Interface for blending |
| CBlendedTrajectory | Implements a trajectory with blends between segments. TODO: Briefly describe how |
| CCircularInterpolator | Circular interpolator |
| CCircularInterpolator< rw::math::Vector3D< T > > | Makes circular interpolation based on rw::math::Vector3D |
| CCubicSplineFactory | Factory for creating cubic splines |
| CCubicSplineInterpolator | This class represents a 3-degree polynomial function, used in Cubic Splines hence the name CubicSegment |
| CCubicSplineInterpolator< rw::math::Rotation3D< T > > | |
| CCubicSplineInterpolator< rw::math::Transform3D< T > > | |
| CCubicSplineInterpolator< rw::math::Transform3DVector< T > > | |
| CDeviceTrajectory | Implements a trajectory with blends between segments. TODO: Briefly describe how |
| CFixedInterpolator | Implements a fixed value interpolator |
| CInterpolator | Interface for interpolators |
| CTrajectoryIterator | Forward declaration of Trajectory Iterator (needed for friend declaration) |
| CInterpolatorTrajectory | Sequence of interpolators and blends giving a trajectory |
| CInterpolatorTrajectoryIterator | Bi-directional iterator for running efficiently through a trajectory |
| ►CInterpolatorUtil | Utilities used in the implementation of various interpolators and blends |
| CTransform2VectorWrapper | Wraps an interpolator using rw::math::Transform3D<T> to interpolator with a vector with 7 elements |
| CLinearInterpolator | Make a linear interpolation between to position |
| CParabolicBlend | Forward declaration for parabolic blend to make the LinearInterpolator<rw::math::Transform3D<T> > a friend |
| CLinearInterpolator< rw::math::Rotation3D< T > > | Implements LinearInterpolator for rw::math::Rotation3D<T> |
| CLinearInterpolator< rw::math::Transform3D< T > > | Implements LinearInterpolator for rw::math::Transform3D<T> |
| CLloydHaywardBlend | Implements LloydHayward blending |
| CLloydHaywardBlend< rw::math::Rotation3D< T > > | Template specialization of LloydHaywardBlend for using a rw::math::Rotation3D<T> |
| CLloydHaywardBlend< rw::math::Transform3D< T > > | Template specialization of LloydHaywardBlend for using a rw::math::Transform3D<T> |
| CParabolicBlend< rw::math::Rotation3D< T > > | Template specialization of ParabolicBlend for using a rw::math::Rotation3D<T> |
| CParabolicBlend< rw::math::Transform3D< T > > | Template specialization of ParabolicBlend for using a rw::math::Transform3D<T> |
| CRampInterpolator | Make a ramp interpolation between two position |
| CRampInterpolator< double > | |
| CRampInterpolator< rw::math::Rotation3D< T > > | Implements RampInterpolator for rw::math::Rotation3D<T> |
| CRampInterpolator< rw::math::Vector3D< T > > | Implements RampInterpolator for rw::math::Vector3D<T> |
| CRampInterpolator< rw::math::Transform3D< T > > | Implements RampInterpolator for rw::math::Transform3D<T> |
| CSQUADInterpolator | |
| CTimed | A tuple of (time, value) |
| CTimedUtil | Construction of paths of Timed values |
| CTimeMetricUtil | Methods for analyzing time distance of various paths |
| CTrajectory | Interface for Trajectories in RobWork |
| CTrajectoryFactory | Trajectory constructors |
| CTrajectorySequence | Combines a number of trajectories |
| CTraits | This is a forward declaration of the traits class |
| CTraits< double > | |
| CTraits< float > | |
| CTraits< T< R > > | |
| CTraits< geometry::BSphere< T > > | |
| CTraits< rw::geometry::OBB< T > > | Define traits of the OBB |
| CTraits< proximity::BinaryBVTree< BV, PRIM > > | Define traits of the BinaryBVTree |
| CTraits< proximity::BVTreeColliderFactory::BalancedDescentStrategy< BVTREE > > | |
| CTraits< proximity::BVTreeColliderFactory::MaxAreaDescentStrategy< BVTREE > > | |
| ►Nrwlibs | Extension libraries for RobWork |
| ►Nalgorithms | Various algorithms |
| ►Nqpcontroller | |
| CQPSolver | Class providing an algorithms for solving the quadratic optimization problem associated with the QPController |
| ►CBFGS | BFGS is a class including the BFGS minimization algorithm |
| CBFGS_function_struct | Minimisation function struct |
| CBasicGPM | Implements a Gradient Projection Method (GPM) |
| ►CKDTree | Space partitioning structure for organizing points in k-dimensional space. Used for searches involving multi.dimensional search keys, including nearest neighbor and range search |
| CKDNode | Struct for the node in the tree |
| CKDResult | |
| ►CKDTreeQ | Space partitioning structure for organizing points in k-dimensional space. Used for searches involving multi.dimensional search keys, including nearest neighbor and range search |
| CKDNode | Struct for the node in the tree |
| CKDResult | |
| CLineModel | A line model |
| CPlaneModel | A plane model |
| CPointModel | A point model |
| CPointPairsRegistration | |
| CIKQPSolver | Iterative inverse kinematics solved based on the QPController |
| CQPController | |
| CRANSACModel | An interface for RANSAC model fitting |
| CStablePlanePose | Calculate the stable poses of an object lying on a planar support structure |
| CStablePose0DModel | A stable pose with 0 DoF model. o Models a stable pose with 0 DoF, i.e. essentially a single orientation in SE3 |
| CStablePose1DModel | A stable pose with 1 DoF model |
| CStructuredLineModel | A model for points placed along a line with regular intervals |
| CNullSpaceProjection | Performs a projection in the null space of the device Jacobian to move joints away from singularities |
| ►CXQPController | An extended version of the QPController |
| CConstraint | Constraint for the XQPController |
| ►Nassembly | Assembly strategies and task & result formats for assembly operations |
| CAssemblyControlResponse | The output from a AssemblyControlStrategy |
| ►CAssemblyControlStrategy | The interface for control strategies for assembly |
| CControlState | Derive from the ControlState class to implement state that is specific to a AssemblyControlStrategy |
| CAssemblyParameterization | Interface for a parameterization that can be used by a AssemblyControlStrategy |
| CAssemblyRegistry | A registry of control strategies. The registry defines an extension point |
| CAssemblyResult | A specification of the result from an execution of an AssemblyTask |
| CAssemblyState | Information about the trajectory of the objects and sensor information during execution |
| CAssemblyTask | Specification of a AssemblyTask |
| CCircularPiHControlStrategy | A AssemblyControlStrategy that can be used specifically for cylindric peg in hole operations |
| CCircularPiHParameterization | The parameterization used for the CircularPiHControlStrategy |
| CPiHParameterization | Parameterization of a Peg in Hole action, used by the PiHStrategy |
| CPiHStrategy | Control strategy for a Peg in Hole operation |
| CSpiralParameterization | Parameterization of a strategy that searches for a hole using a spiral strategy |
| CSpiralStrategy | Control strategy for a Peg in Hole operation using a spiral search |
| ►Ncalibration | |
| 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 |
| CXmlCalibrationLoader | Loads a calibration file for a workcell |
| CXmlCalibrationSaver | Save function for writing a work cell calibration in an XML format |
| ►Ncontrol | |
| 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 |
| ►Ncsg | |
| ►Nengines | |
| CCSGJSEngine | |
| CCSGEJSEnginePlugin | A plugin providing CSGJSEngine for RobWork |
| CCSGConvert | |
| CCSGModel | A CSG (Constructive Solid Geometry) model representation |
| CCSGModelFactory | Factory class that allows construction of CSG model primitives |
| CCSGUtil | A CSG utility class |
| Ndll | Dynamic library loading |
| ►Ngeometry | Custom geometry implementations |
| ►Nsimplefinger | |
| CSimpleFinger | |
| CSimpleFingerPlugin | |
| CAnalyticGeometryPlugin | Plugin adding new analytic geometry types to the rw.loaders.GeometryFactory extension point |
| CQuadraticTestObjects | Library of objects that are made up of Quadratic surfaces |
| Nlua | A Lua interface to RobWork |
| ►Nmathematica | Implementation of the Wolfram Symbolic Transfer Protocol (WSTP) to allow communication with Mathematica. |
| CEnterExpressionPacket | A Mathematica WSTP EnterExpressionPacket |
| CEnterTextPacket | A Mathematica WSTP EnterTextPacket |
| CEvaluatePacket | A Mathematica WSTP EvaluatePacket |
| CFactorInteger | Representation of the Mathematica FactorInteger function |
| CImage | Representation of the Mathematica Image function |
| CInputNamePacket | A Mathematica WSTP InputNamePacket |
| CList | Representation of the Mathematica List function |
| CListPlot | Representation of the Mathematica ListPlot function |
| ►CMathematica | Implementation of the Wolfram Symbolic Transfer Protocol (WSTP) to allow communication with Mathematica |
| CArray | An Array primitive |
| CAutoExpression | Convenience class for automatic Expression deduction |
| CExpression | A representation of a Mathematica expression |
| CFunction | A user definable function expression |
| CFunctionBase | A base interface for function expressions |
| CInteger | An integer primitive |
| CLink | Representation of a link |
| CPacket | A Packet expression |
| CReal | A real primitive |
| CString | A string primitive |
| CSymbol | A symbol primitive |
| CMessagePacket | A Mathematica WSTP MessagePacket |
| COutputNamePacket | A Mathematica WSTP OutputNamePacket |
| CRawArrayUtil | Utility for the RawArray type |
| CRawArray | Representation of a N-dimensional Mathematica array with fixed depth |
| CRawArray< T, Dynamic > | Representation of a N-dimensional Mathematica array with dynamic depth |
| CReturnExpressionPacket | A Mathematica WSTP ReturnExpressionPacket |
| CReturnPacket | A Mathematica WSTP ReturnPacket |
| CReturnTextPacket | A Mathematica WSTP ReturnTextPacket |
| CRule | Representation of a Mathematica Rule |
| CTextPacket | A Mathematica WSTP TextPacket |
| CToExpression | Representation of the Mathematica ToExpression function |
| ►Nopengl | OpenGL drawing of workcells and geometries |
| CDrawable | Abstract base class for all drawable classes |
| CDrawableFactory | Factory for construction of drawables based on their type |
| CDrawableGeometry | Abstract base class for all drawable classes |
| CDrawableUtil | Utility class for drawable stuff |
| 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 | |
| CRenderUtil | Collection of utillities for rendering |
| CRenderVelocity | Render for linear and angular velocity |
| CRWGLFrameBuffer | Class for off-screen GL rendering |
| CRWGLTexture | Texture class that wraps the construction of opengl textures |
| CSceneOpenGL | Helps with Visualizing a Workcell. SceneOpenGL is OpenGL specific |
| CTactileArrayRender | Renders a TactileArray |
| Nos | A collection of OS specific include configurations |
| ►Npathoptimization | A collection of pathoptimization algorihms |
| CClearanceCalculator | Interface for ClearanceCalculator |
| CClearanceOptimizer | The ClearanceOptimizer implements the C-Retraction algorithms from [1] |
| CMinimumClearanceCalculator | Implements a MinimumClearanceCalculator |
| CPathLengthOptimizer | The PathLengthOptimizer implements the 3 different path length optimizers presented in [1] |
| ►Npathplanners | Path planners |
| ►Nprm | |
| CPartialIndexTable | Provides an Partial Index Table to be used for nearest neighbor search |
| CARWExpand | ARWExpand expands a random walk in the configuration space by one step |
| CARWPlanner | Adaptive Random Walk planners |
| CARWQToQPlanner | Adaptive Random Walk Planner |
| CPRMPlanner | Implements a probabilistic roadmap (PRM) planner |
| CRRTTree | Tree data type for RRT based planners |
| CRRTNode | 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 |
| CSBLExpand | Interface for sampling a configuration in the vicinity of some other configuration |
| CSBLInternal | Internal algorithms used by the SBLPlanner |
| CSBLPlannerConstraint | A SBL planner constraint |
| CSBLOptions | SBL planner setup |
| CSBLPlanner | SBL based planners |
| CSBLSetup | Common parameters for SBL based planners |
| CZ3Planner | Z3 based planners |
| CZ3QToQPlanner | Z3 based point-to-point planner |
| ►Nplots | |
| CMathGLPlot | MathGL based implementation of a plot |
| CMathGLPlotGenerator | MathGL based implementation of a plot generator |
| CMathGLPlugin | Plugin providing MathGL plots |
| ►Nproximitystrategies | Proximity strategies |
| ►CProximityStrategyBullet | This is a strategy wrapper for the distance and collision library Gimpact from the Bullet physicsengine |
| CBulletModel | |
| CProximityCacheBullet | Cache for any of the queries possible on this BulletStrategy |
| CProximityModelBullet | |
| CProximityStrategyFactory | Factory class that enables constructing collision strategies |
| ►CProximityStrategyFCL | This is a strategy wrapper for the Flexible Collision Library (FCL) |
| CFCLModel | Datatype to hold the FCL bounding volume and related geometrical data |
| CFCLProximityModel | Datatype to hold the proximity models |
| CProximityStrategyPlugin | A plugin providing proximity strategies for RobWork |
| CPQPCollisionCache | Cache for the PQP proximity strategy |
| ►CProximityStrategyPQP | This is a strategy wrapper for the distance library PQP (Proximity Query Package) |
| CPQPProximityCache | Cache for any of the queries possible on this PQPStrategy |
| CPQPProximityModel | |
| CRWPQPModel | |
| CProximityStrategyYaobi | This is a strategy wrapper for the collision library Yaobi |
| ►Nsimulation | Simulation of cameras and other I/O units |
| CFrameGrabber | The FrameGrabber abstract interface, can be used to grab images from a specialized source |
| CFrameGrabber25D | The FrameGrabber25D 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 |
| CGLFrameGrabber25D | An implementation of the FrameGrabber interface. The GLFrameGrabber25D grabs images from a OpenGL scene using a simple pinhole camera model |
| CKinematicSimulator | Interface of a kinematic simulator |
| CSimulatedCamera | Makes it posible to use virtual camera sensors by using different framegrapper implementations |
| CSimulatedController | Interface of a simulated controller |
| 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 |
| CSimulatedSensor | Simulated sensor interface |
| ►CSimulator | Interface of a general simulator |
| CUpdateInfo | Step info is used when updating controllers, devices and bodies |
| ►Nsoftbody | Simulation of beam models and other soft bodies |
| 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 |
| CEBBeam | Class for calculating the analytical solution to the Euler-Bernoulli beam model in fixed-free configuration |
| CModRussel_NLP | Implementation of the Modified Russel beam problem, using the IPOPT TNLP structure |
| CModRusselBeamBase | Base class for implementing Modified Russel beam problems |
| CModRusselBeamIpopt | Implementation of the Modified Russel Beam Problem using IPOPT |
| CRusselIntegrand | Implementation of the Modified Russel energy density functions |
| CRusselIntegrandEonly | Implementation of the Modified Russel elastic energy density function |
| CFdUtil | Various numerical methods using finite-differences |
| CTrapMethod | Implementation of the trapezoidal rule for integration |
| ►Nswig | Define helper functions and all the classes that are being wrapped by SWIG. The wrapped classes are defined as typedefs of other classes in RobWork |
| CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.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 |
| CFactory | 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 |
| CLuaLibrary | |
| ►Ntask | |
| CTask | Template based implementation of Task |
| CTarget | Template class implementing Target |
| CActionType | Specification of Action Type |
| CAction | Specification of an action in a task |
| CEntityType | Type of an Entity |
| CEntity | Base class of object inserted into a Task |
| CGraspResult | Describes the result of a single grasp |
| CGraspSubTask | Describes a sub task of overall grasp task |
| 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 |
| ►CDOMTaskFormat | Definition of the identifier used in the task format |
| CInitializer | Utility class which initializes local static variables |
| CDOMTaskLoader | Loader for the RobWork task format, using the DOMParser |
| ►CDOMTaskSaver | Saver for the RobWork task format, using the DOMParser |
| CInitializer | Utility class which initializes local static variables |
| ►CTaskLoader | Interface for loaders of the task format |
| CFactory | A factory for TaskLoader. This factory also defines an extension point for task loaders |
| ►CTaskSaver | Interface for savers of the task format |
| CFactory | A factory for TaskSaver. This factory also defines an extension point for task savers |
| ►CXMLTaskFormat | Class storing the identifiers used for paths in the XML Task Format |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLTaskLoader | Loader for the XML task format, based on Xerces |
| CInitializer | Utility class which initializes local static variables |
| ►CXMLTaskSaver | Saver for the XML task format, based on Xerces |
| CInitializer | Utility class which initializes local static variables |
| CMotionType | Specification of Action Type |
| CMotionBase | Base class for motions providing common interface |
| CMotion | Specified the template based interface of a motion |
| CP2PMotion | Class describing point to point motions |
| CLinearMotion | Class describing linear motions |
| CCircularMotion | Class describing circular motions |
| CTargetBase | Base class for targets |
| CTaskBase | Base class for tasks |
| CGenericTask | Implements a template based and generic version of a task |
| CTaskUtils | Collection of utility function associated to tasks |
| CType | Class defining general types |
| CTypeRepository | The TypeRepository provides a repository in which types can be mapped to Type objects |
| ►Nrws | RobWorkStudio is the visualization framework of RobWork |
| ►Npython | |
| CPythonRunner | Class for running multiple python environments in a threadsafe manner |
| Nswig | |
| CAboutBox | AboutBox in RobWorkStudio |
| CArcBallController | Use the ArcBallController method to control the camera view point in a scene |
| CCameraController | Interface for controlling the camera using a mouse |
| 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 |
| CImageUtil | |
| CPlotSimpleView | |
| ►CPlotView | GUI Element for showing RobWork plots |
| CDispatcher | Dispatcher for plots |
| CFactory | 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 |
| CRobWorkStudio | Main robwork studio class |
| CRobWorkStudioPlugin | Abstract interface for RobWork Studio plugins |
| CRWSImageLoaderPlugin | A RobWork image loader factory plugin. It adds additional image loader functionality to the rw::loaders::ImageFactory through RobWork plugin structure |
| CRWSSpinBox | Implementation of QDoubleSpinBox with better fixup function |
| CRWStudioView3D | This class adds RobWorkStudio specific functionality to a WorkCellViewer |
| CSceneOpenGLViewer | Class representing an OpenGL based QT Widget for 3D visualization of the SceneGraph SceneOpenGL |
| CSceneViewerWidget | Class representing a Qt widget for 3D visualization of a scene |
| ►CChartView | |
| CDispatcher | Dispatcher for plots |
| CChartViewGenerator | |
| CChartViewPlugin | Plugin providing plots based on QChartView |
| 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 |
| 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 |
| CLua | This plugin provides access to editing and executing lua commands |
| CLuaConsoleWidget | Widget that mimics console functionality for executing lua commands in a RobWorkStudio framework |
| CLuaEditorWindow | A lua editor and programming pad designed to resemble a teach pendent for devices in RobWorkStudio |
| CLuaExecutionThread | This class handles the execution of lua commands such that they are executed in a seperate thread |
| 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 |
| 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 |
| CSensors | Sensor plugin for RobWorkStudio |
| 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 |
| 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 |
| CWorkcellEditorWindow | A workcell editor that enables editing of workcells within RobWorkStudio |
| CWorkcellEditorPlugin | This plugin provides access to the workcell editor of RobWorkStudio |
| ►Nrwsim | RobWorkSim is the dynamic simulation framework of RobWork |
| ►Ncontacts | Contact Detection |
| CBallBallStrategy | Detection of contacts between balls. Each model can consist of multiple balls |
| CBaseContactDetector | |
| CContact | A common interface for the most important data for a contact |
| ►CContactDetector | The ContactDetector allows detailed control of the strategies used for contact detection between specific frames and geometry types |
| CStrategyTableRow | One row in the strategy table, with a priority, match-rules, a strategy and associated ContactModels |
| 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 |
| CContactInfo | Meta-data for a contact that allows it to be recalculated |
| CContactModel | The ContactModel is an interface for the contact models implemented by different contact strategies |
| ►CContactModelGeometry | Generic contact model for strategies that find contacts between two different types of geometry |
| CGeometryModel | Model for each geometry |
| CContactStrategy | The ContactStrategy is a common interface for different contact strategies |
| ►CContactStrategyData | Container for data that is stored by contact strategies between contact detection calls |
| CSpecificData | Base class that can be extended to implement strategy-specific data |
| CContactStrategyDMS | Detection of contacts between triangle meshes |
| CContactStrategyGeometry | Generic contact strategy that find contacts between two different types of geometry |
| ►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 |
| CStrategyData | Base struct that can be extended for strategy specific data |
| CUserData | Base struct that can be extended for user specific data |
| CRenderContacts | Render for contacts |
| CThreadedContactDetector | |
| ►Ncontrol | |
| 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 |
| CPDParam | Struct for holding PD parameters |
| 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 |
| CCompiledTarget | |
| CTarget | |
| ►CSpringJointController | |
| CSpringParam | Parameters of a 1 dof spring |
| ►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 |
| CSpring | |
| 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 |
| ►Ndrawable | |
| 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 |
| ►Ndynamics | |
| CBeamBody | A deformable body composed of a sequence of connected rigid bodies |
| CBodyInfo | Body info holds the values that determine the dynamic behavior of the body, such as mass and inertia |
| 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 |
| CBodyUtil | Utility functions related to dynamic bodies |
| ►CConstraint | A constraint is a mathematical model that constrain the movement between two arbitrary bodies in a dynamic simulation |
| CLimit | Definition of a limit for one single degree of freedom |
| CSpringParams | Parameters for a spring |
| CContactCluster | Calculates contact clusters |
| ►CContactDataMap | This class is a storage component for storing collision/contact data information |
| CChatterjeeData | Data required for the Chatterjee collision model |
| CNewtonData | Data required for the Newton collision model |
| 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 |
| CContactPoint | Representation of a contact point |
| CDynamicDevice | Base class for dynamic devices that has dynamic state values such as velocity and acceleration |
| CDynamicUtil | Utility functions for calculating dynamic properties |
| CWorkCellDimension | WorkCellDimension describe a center and the box halflengths of the space that the WorkCell expands |
| 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 |
| 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 |
| CKinematicBodyState | State data for a kinematic body |
| CKinematicDevice | Kinematic device is able to influence the simulated environment but the device is not influenced by any external force as is the RigidDevice |
| CLink | The Link is a body that is part of a dynamic device where joints are used to constrain the movement of links |
| CFrictionData | Definition of a friction model |
| CMaterialDataMap | A map of materials and friction models defined between materials |
| COBRManifold | Contact manifold based on Oriented Bounding Rectangle, so in 2D |
| ►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 |
| CRigidBodyState | The state of a rigid body |
| 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 |
| CScapePoseFormat | Saving object poses in Scape format |
| ►Nloaders | |
| CDynamicWorkCellLoader | Class for loading of dynamic owrkcells |
| CDynamicWorkCellSaver | Class for saving a WorkCell to a file |
| ►Nlog | Logging system for dynamic simulation |
| ►CLogCollisionResult | Log detailed info from a collision detection |
| CResultInfo | The result including info about the ProximityModels |
| CLogConstraintForceTorque | Log wrench for constraints |
| ►CLogConstraints | Log type for constraints |
| CConstraint | Information for a constraint |
| CLogContactForceTorque | Log a set of contact forces and torques |
| CLogContactSet | Log a set of contacts |
| CLogContactVelocities | Log a set of contact velocities |
| ►CLogDistanceMultiResult | Log detailed info from a multi-distance detection |
| CResultInfo | The result including info about the ProximityModels |
| ►CLogDistanceResult | Log detailed info from a distance detection |
| CResultInfo | The result including info about the ProximityModels |
| CLogEquationSystem | Log entry for a linear equation system \(\mathbf{A}\mathbf{x}=\mathbf{b}\) |
| CLogForceTorque | Logging for forces and torques |
| CLogMessage | Logging of a generic message |
| CLogPositions | Logging of body positions |
| CLogStep | A special type of scope that is also a simulation step |
| CLogValues | Logging of numeric values. These values will also be used for SimulatorStatistics |
| CLogVelocities | Logging of body velocities |
| CSimulatorLog | Base class for a hierarchical simulator log |
| ►CSimulatorLogEntry | A leaf log item with no children |
| CFactory | A factory for a SimulatorLogEntry. This factory also defines an extension point for SimulatorLogEntry |
| CSimulatorLogScope | A scope can have children, and the type allows hierarchical logging |
| CSimulatorLogUtil | Utility to make it more convenient to write to a SimulatorLogScope |
| CSimulatorStatistics | Statistics utility for automatic generation of data set based on a SimulatorLogScope |
| ►CDistanceMultiResultWidget | Graphical representation of the log entry rwsim::log::DistanceMultiResultWidget. |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►Nsensor | |
| ►CBodyContactSensor | This sensor attaches to a body and records all forces and the corresponding positions where the forces act |
| CClassState | The state of the sensor |
| CSimulatedFTSensor | A sensor that measures force and torque between two bodies around some reference frame |
| CSimulatedTactileSensor | Interface for simulated tactile sensors |
| ►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 |
| CClassState | Class for keeping statefull information |
| CDistPoint | |
| ►Nsimulator | Dynamic simulation |
| CBodyController | The body controller is a pure interface through which bodies are controlled |
| CBodyIntegrator | Abstract class for describing how the motion of a body behaves during a timestep |
| CCNodePairMap | This implementation creates an efficient mapping between CNodePair and some user defined type. Lookup and insertion is O(1) |
| CCNodePool | Interface for creating and deleting constraintEdges and ConstraintNodes |
| CConstantForceManipulator | Class for adding a constant force to any body it controls |
| CConstraintEdge | |
| CConstraintFactory | The ContactModelFactory functions as a mediator to the functionallity that is required by the contact graph |
| CFilteredPoint | |
| 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 |
| CCNodePair | |
| CSolverInfo | Parameters for the constraint solver |
| CConstraintSolver | Abstraction over a constraint solver for dynamics simulations |
| CContact | |
| CContactGraph | Creates a graph where nodes can be physical, logical and compound entities and the edges between nodes are constraints of some sort |
| 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 |
| CEulerIntegrator | Body motion integrator that use an implicit Euler formulation to calculate the motion of a body |
| CGuendelContactModel | |
| CRK4Integrator | |
| CRWBody | |
| CRWBodyPool | Interface for creating and deleting constraintEdges and ConstraintNodes. ConstraintEdges are frequently created and deleted so efficient data structures are here needed |
| CRWDebugRender | |
| CRWSimulator | |
| 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 |
| CAssemblySimulator | A simulator for execution of AssemblyTasks |
| CDynamicSimulator | A general physics engine interface for simulating dynamics of objects and robot devices |
| ►CGraspTaskSimulator | A class for simulating multiple grasping tasks |
| CGraspedObject | |
| CSimState | |
| ►CPhysicsEngine | A general physics engine interface for simulating dynamics of objects and robot devices |
| CDispatcher | Each engine implements a dispatcher that creates instances of the engine |
| CFactory | Factory for PhysicsEngine. This factory defines an extension point for PhysicsEngines |
| CThreadSimulator | Wraps a simulator in a thread safe interface, and creates a separate thread for the simulator to run in |
| 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 |
| CODEContactStrategy | Detection of contacts using the internal ODE collision detector |
| CODEDebugRender | |
| CODEDevice | Interface for classes (ODEDevices) that control a set of ode bodies that map to a RWSim dynamic device type |
| 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 |
| CODEKinematicDevice | A bridge between the RW KinematicDevice and kinematicly controlled ODE dBodies |
| CODELogUtil | Utility to write to SimulatorLog |
| CODEMaterialMap | The ODE material map is responsible for the modelling of contact dynamics, such as friction and restitution phenomena |
| CODEPlugin | A ODE plugin that define extensions for rwsim.simulator.PhysicsEngine |
| ►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 |
| CODEStateStuff | |
| CODESuctionCupDevice | Interface for classes (ODEDevices) that control a set of ode bodies that map to a RWSim dynamic device type |
| CODETactileSensor | |
| CODEThreading | Utility functions related to the use of Open Dynamics Engine from multiple threads |
| ►CODEUtil | |
| CTriGeomData | |
| CTriMeshData | |
| CODEVelocityDevice | A bridge between the RW RigidDevice and a set of connected joints and rigid bodies |
| ►Nswig | |
| CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
| ►Nutil | Utilities |
| CCircleModel | Model of a circle, represented as a normal, a center and a radius |
| CCollisionFreeSampler | Samples another state sampler until it returns a collision free state |
| CDistModel | |
| 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 |
| CGraspPolicy | Grasp policy defines how a grasp is executed from some initial configuration |
| CGraspPolicyFactory | |
| CGraspQualityFactory | |
| CGraspStrategy | GraspStrategy define how the initial configuration of a grasping system is generated |
| CGraspStrategyFactory | |
| CHughLineExtractor | |
| CLinePolar | |
| CMovingAverage | |
| CPlanarSupportPoseGenerator | Calculates the stable poses of an object when the support structure is planar |
| CPlaneModel | |
| CPointRANSACFitting | |
| CPreshapeGraspStrategy | This strategy samples |
| CPreshapeSampler | This StateSampler will never become empty |
| ►CRecursiveNewtonEuler | The recursive Newton-Euler method is used for calculating inverse dynamics of a kinematic tree |
| CMotion | Motion of a body defined as velocity and acceleration |
| CRestingPoseGenerator | Finds resting poses of a dynamic scene |
| CSimStateConstraint | |
| 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 |
| CStateSampler | Interface for generating states |
| CSupportPose | |
| 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 |
| ►Nrwsimlibs | RobWorkSim libraries: Physics engines, plugins, and script interface |
| ►Nbullet | The Bullet engine implementation |
| ►CBtBody | Wrapper class for a bullet btRigidBody, that bridges between RobWork and Bullet |
| CBodyMetaData | Data structure to attach to bullet bodies, allowing friction and restitution to be specified separately for each pair of bodies |
| CGeometryMetaData | Data structure to attch to bullet collision shapes |
| CBtConstraint | Allows constraining the motion between two bodies in Bullet simulation |
| CBtContactStrategy | Detection of contacts using the internal Bullet collision detector |
| CBtDebugRender | Debug render for the Bullet engine |
| CBtDevice | An interface for Bullet devices |
| CBtMaterial | Used as body userdata to be able to determine friction and restitution on contact pairs |
| CBtPlugin | A Bullet plugin that provides additional functionality to the rwsim::simulator::PhysicsEngine::Factory through the plugin structure |
| CBtPositionDevice | A position device |
| ►CBtRWCollisionAlgorithm | The RobWork implementation of a Bullet collision algorithm, using the standard ContactDetector |
| CCreateFunc | Function for creating a BtRWCollisionAlgorithm |
| CBtRWCollisionConfiguration | A collision configuration that uses the btCompoundCompoundCollisionAlgorithm and BtRWCollisionAlgorithm to handle contacts |
| CBtSimulator | A physics engine that uses Bullet Physics as the underlying engine |
| CBtTactileSensor | Class for updating SimulatedTactileSensor from Bullet simulation |
| CBtUtil | Utility functions that allows easy conversion between Bullet and RobWork types |
| CBtVelocityDevice | A velocity device |
| ►Ngui | GUI elements related to RobWorkSim |
| ►CBodyMotionWidget | Graphical representation of the log entries rwsim::log::LogPositions and rwsim::log::LogVelocities |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CCollisionResultWidget | Graphical representation of the log entry rwsim::log::LogCollisionResult |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CConstraintWidget | Graphical representation of the log entry rwsim::log::LogConstraints |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CContactSetWidget | Graphical representation of the log entry rwsim::log::LogContactSet |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CContactVelocitiesWidget | Graphical representation of the log entry rwsim::log::LogContactVelocities |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CDistanceResultWidget | Graphical representation of the log entry rwsim::log::DistanceResultWidget |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CEquationSystemWidget | Graphical representation of the log entry rwsim::log::LogEquationSystem |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CForceTorqueWidget | Graphical representation of the log entry rwsim::log::LogForceTorque |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CLogMessageWidget | Graphical representation of the rwsim::log::LogMessage log entry |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| ►CLogValuesWidget | Graphical representation of the rwsim::log::LogValues log entry |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget. |
| CMathematicaPlotWidget | Widget for Mathematica plots |
| ►CSimulatorLogEntryWidget | A widget that is a graphical representation of a rwsim::log::SimulatorLogEntry |
| CDispatcher | Dispatchers are responsible for creating new widgets of type SimulatorLogEntryWidget |
| CFactory | A factory for a SimulatorLogEntryWidget. This factory also defines an extension point for SimulatorLogEntryWidget::Dispatcher |
| CSimulatorLogModel | Model of a simulator log for Qt Tree view |
| CSimulatorLogWidget | Widget for visualization of a simulation log |
| CSimulatorStatisticsWidget | Widget for visualisation of rwsim::log::SimulatorStatistics |
| Node | The Open Dynamics Engine implementation |
| ►Nplugins | RobWorkStudio plugins providing RobWorkSim functionality |
| CEngineTestPlugin | A plugin for interactive testing of physics engines |
| Nrwpe | The RobWorkPhysicsEngine implementation |
| ►Nswig | |
| CThreadSimulatorStepCallbackEnv | An extension to the StepCallback function defined in ThreadSimulator that allows saving additional environment/user data |
| ►Ntest | Test case library for RobWorkSim |
| ►CDynamicWorkCellBuilder | Helper for building Dynamic Workcells |
| CColorScheme | Color scheme specification |
| CPaHColors | Default color scheme |
| ►CEngineTest | Generic test type for physics engines, which provides a factory for standard tests along with an extension point for user defined tests |
| CEngineLoopInfo | The info passed in a callback function |
| CFactory | A factory for engine tests. This factory also defines an ExtensionPoint |
| CFailure | Format for a failure to an engine test |
| CResult | A result of an engine test. Each test can return multiple results |
| CTestHandle | Handle for a concrete test run, which makes it possible to interact with the test during simulation |
| CIntegratorGravityTest | Test for linear free-falling motion |
| CIntegratorRotationTest | Test for rotational motion |
| CIntegratorSpringTest | Test for the motion when an undamped linear spring is used |
| CIntegratorTest | Common parent class for all integrator tests |
| ►Ntools | Standalone tools related to simulation |
| CSimulatorLogViewer | Stand-alone application for visualization of internal data from a Physics Engine |
| ►Nrwslibs | RobWorkStudio extension libraries |
| ►Nswig | |
| CLuaPlugin | A Lua plugin that define extensions for rwlibs.swig.LuaState.LuaLibrary |
| CATaskVisPlugin | Plugin for visualization of assembly operations |
| CStrategyLibraryDialog | Dialog showing examples of the available assembly strategies |
| CTaskSetupDialog | Dialog for configuration of an assembly task |
1.9.1