| ►NParabolicRamp | |
| CDistanceCheckerBase | A base class for a distance checker. ObstacleDistance returns the radius of a L-z norm guaranteed to be collision-free. ObstacleDistanceNorm returns the value of z |
| CDynamicPath | A bounded-velocity, bounded-acceleration trajectory consisting of parabolic ramps |
| CFeasibilityCheckerBase | A base class for a feasibility checker |
| CParabolicRamp1D | Stores optimal trajectores for an acceleration and velocity-bounded 1D system |
| CParabolicRampND | Solves for optimal trajectores for a velocity-bounded ND system |
| CRampFeasibilityChecker | A class that encapsulates feaibility checking of a ParabolicRampND |
| CRandomNumberGeneratorBase | A custom random number generator that can be provided to DynamicPath::Shortcut() |
| ►Nurdf | |
| CBox | |
| CCamera | |
| CCollision | |
| CColor | |
| CCylinder | |
| CEntity | |
| CGeometry | |
| CInertial | |
| CJoint | |
| CJointCalibration | |
| CJointDynamics | |
| CJointLimits | |
| CJointMimic | |
| CJointSafety | Parameters for Joint Safety Controllers |
| CJointState | |
| CLink | |
| CMaterial | |
| CMesh | |
| CModelInterface | |
| CModelState | |
| CParseError | |
| CPose | |
| CRay | |
| CRotation | |
| CSensor | |
| CSphere | |
| CTime | |
| CTwist | |
| CVector3 | |
| CVisual | |
| CVisualSensor | |
| CWorld | |
| CAccelerometer | Simulates an accelerometer |
| CActiveRobotCSpace | A CSpace for just a few dofs of a robot. Slightly faster than using a regular RobotCSpace then picking out subvectors |
| CActuatorCommand | A basic motor type. Handles PID, torque, and locked velocity modes |
| CCameraSensor | Simulates an RGB, D, or RGB+D camera sensor. Provides a 2D grid of color and/or depth values, capped and quantized |
| CCartesianObjective | A goal that measures point-to-point distance |
| CCartesianTrackingObjective | Tracking a path in cartesian space |
| CCollisionConstraint | |
| CCOMAccelTask | |
| CCompositeBackend | |
| CCompositeObjective | An objective that merges contributions from multiple other objective functions |
| CConfigFixer | A class for "fixing" a configuration by sampling a feasible configuration near it |
| CConfigObjective | A goal that measures distance to a goal configuration qgoal |
| CConfigsResource | Resource for multiple Config's |
| CConstrainedInterpolator | Construct a polyline between a and b such that each point is near the constraint C(x)=0 |
| CConstraintChecker | Checks for static constraints for a robot at a given stance |
| CContactCSpace | A SingleRobotCSpace for a robot maintaining contact |
| CContactDistanceMetric | |
| CContactFeatureBase | A feature on the robot that can be used for contact |
| CContactFeatureMapping | A mapping from a ContactFeature to a point on the environment |
| CContactFeedbackInfo | Container for information about contacts regarding a certain object. Can be set to accumulate a summary over sub-steps or detailed data per-step |
| CContactForceTask | |
| CContactJointTrackingController | Makes a joint tracking controller 'aware' of a contact formation |
| CContactSensor | Simulates a contact sensor / tactile sensor |
| CContactTimeScaling | A time scaling with torque/contact constraints |
| CControlledRobot | An interface for a Klamp't controlled robot. This should be implemented if you wish to use Klamp't controllers to communicate directly with a real robot's motor controller |
| CControlledRobotSimulator | A class containing information about an ODE-simulated and controlled robot |
| CCorruptedSensor | A "piggyback" sensor that corrupts readings with quantization error and gaussian noise |
| CCSpaceFeasibilityChecker | Adapter for the ParabolicRamp feasibility checking routines |
| CCustomGeometryData | |
| CCustomTimeScaling | A base class for a time scaling with colocation point constraints. Subclasses should fill in dsmax, ds2ddsConstraintNormals, and ds2ddsConstraintOffsets before Optimize is called |
| CDefaultMotionQueueInterface | A MotionQueueInterface that just sends to a PolynomialMotionQueue |
| CDistanceQuery | A method for efficiently caching and updating distance computations using temporal coherence |
| CDrawEECallback | |
| CDrawEECallback2 | |
| CDrawEECallback3 | |
| CDriverTorqueSensor | Simulates a torque sensor |
| ►CDynamicHybridTreePlanner | The preferred dynamic sampling-based planner for realtime planning. Will alternate sampling-based planning and smoothing via shortcutting |
| CEdgeData | |
| CNodeData | |
| CDynamicIKPlanner | A planner that uses numerical inverse kinematics to reach the goal. The goal must be of CartesianObjective or IKObjective type, or a composite of several such objectives. (see PlannerObjectives.h) |
| CDynamicMotionPlannerBase | A base class for a motion planner that generates dynamic paths. The output should always respect joint, velocity, and acceleration limits and end in a zero-velocity terminal states |
| CDynamicPerturbationIKPlanner | A planner that perturbs the current configuration and uses numerical IK to get an improved path. All caveats of RealTimeIKPlanner apply |
| CDynamicPerturbationPlanner | A planner that perturbs the current configuration to get an improved path |
| CDynamicRRTPlanner | Dynamic RRT planner – not recently tested |
| CEdgeContactFeature | An edge contact feature |
| CFaceContactFeature | A (planar) face contact feature |
| CFacesContactFeature | A contact feature consisting of multiple faces |
| CFeedforwardController | A class that adds a feedforward torque to the basic control. The necessary feedforward torque is estimated assuming the robot is fixed-base |
| CFilteredSensor | An exponentially smoothed filter that acts as a "piggyback" sensor |
| CForceHook | A hook that adds a constant force to a body |
| CForceTorqueSensor | Simulates a force-torque sensor mounted between a link and its parent. Can be configured to be up to 6DOF |
| ►CGeneralizedRobot | A collection of robots and objects that can be treated like one "big robot" |
| CElement | |
| CGenericBackendBase | |
| CGenericGUIBase | A base class for a GUI frontend. Performs message passing to the backend in the easily serializable AnyCollection format |
| ►CGeometryManager | |
| CGeometryList | |
| CGLNavigationBackend | A backend that manages a camera and performs OpenGL scene management |
| CGLUIGUI | A base class for GLUI GUIs |
| CGLUTGUI | |
| CGrasp | Slightly more sophisticated than a Stance, a Grasp allows some of the robot's degrees of freedom to be fixed |
| CGraspResource | Resource for a Grasp |
| CGyroSensor | Simulates a gyroscope |
| CHold | A single contact between the robot and the environment |
| CHoldReader | |
| CHoldResource | Resource for a Hold |
| CIKCommandInterface | An interface that uses numerical IK to solve for a Cartesian objective function. Assumes that IK is fast enough to be solved in a single update step |
| CIKGoalResource | Resource for an IKGoal |
| CIKObjective | A goal for an IK solution (including possibly rotation) |
| CIKPlannerCommandInterface | An interface uses safe IK as the real-time planner class to achieve the user's objective |
| CIMUSensor | An inertial measurement unit. May provide all or some of a rigid body's state |
| CInputProcessingInterface | An interface that uses an InputProcessorBase subclass to process input. By default, it uses a StandardInputProcessor which lets the user to pose points on the robot in Cartesian space by pointing and dragging |
| CInputProcessorBase | An abstract base class for processing user input through a 2D mouse driven gui into PlannerObjectives used for planning |
| CIntegratedStateEstimator | A state estimator that integrates information from accelerometers (i.e., an Inertial Measurement Unit) and gravity sensors |
| CJointAccelTask | |
| CJointCommandInterface | An interface that allows the user to pose individual joints using mouse dragging |
| CJointLimitConstraint | |
| CJointPositionSensor | Simulates a joint encoder |
| CJointTrackingController | A controller base class that reads out a desired servo position and velocity using the method GetDesiredState |
| CJointVelocitySensor | Simulates a velocity sensor. (Does not perform differencing) |
| CLaserRangeSensor | Simulates a laser range sensor, either sweeping or stationary. Can both simulate both 1D sweeping and 2D sweeping |
| CLinearPath | A piecewise linear path |
| CLinearPathResource | Resource for a LinearPath |
| CLineReader | |
| CLocalForceHook | A hook that adds a constant force in world coordinates to a point on a body given in local coordinates |
| CLoggingController | A controllre that saves/replays low-level commands from disk |
| CManagedGeometry | A "smart" geometry loading class that caches previous geometries, and does not re-load or re-initialize existing collision detection data structures if the item has already been loaded |
| CMotionQueueInterface | |
| CMouseDragBackend | A backend that processes mouse motion calls into dragging callbacks. Makes it a bit easier to determine free-dragging, control-dragging, shift-dragging, etc |
| CMTIKPlannerCommandInterface | |
| CMTPlannerCommandInterface | A base class for a multithreaded planning robot UI. Subclasses must call planningThread.SetStartConfig(), SetCSpace(), and SetPlanner() |
| CMTRRTCommandInterface | |
| ►CMultiPath | A very general multi-section path container |
| CPathSection | |
| CMultiPathResource | Resource for a MultiPath |
| CObjectPlannerSettings | |
| CODEContactList | A list of contacts between two objects, returned as feedback from the simulation |
| CODEGeometry | An ODE collision geometry |
| CODEObjectID | An index that identifies some ODE object in the world. Environments, robots, robot bodies, or rigid objects are supported |
| CODERigidObject | An ODE-simulated rigid object |
| CODERobot | A robot simulated in an ODE "world" |
| CODESimulator | An interface to the ODE simulator |
| CODESimulatorSettings | Global simulator settings |
| CODESurfaceProperties | Surface properties for any ODE rigid object, robot link, or fixed object |
| COmniscientStateEstimator | A state estimator will full knowledge of the robot's simulated state. An ODERobot must be provided at initialization |
| COperationalSpaceController | A combination of multiple "tasks" that define a weighted optimization objective for the joint torques |
| CParameterizedVectorFieldFunction | A VectorFieldFunction that depends on a parameter theta |
| CPlannerCommandInterface | An interface that uses a real-time planner to solve for an arbitrary objective function. Subclasses must choose which type of planner to use |
| CPlannerObjectiveBase | A base class for objective functionals in time/config/velocity space |
| CPointCloudResource | Resource for a PointCloud3D |
| CPointContactFeature | A single point contact feature |
| CPolygon2DSampler | Samples points in a convex polygon |
| CPolygon3DSampler | Samples points in a convex polygon (in 3D) |
| CPolynomialMotionQueue | A motion queue that runs on a piecewise polynomial path. Can be commanded to reach configurations (with or without velocities specified) smoothly using piecewise linear or cubic curves |
| CPolynomialPathController | A controller that uses a piecewise polynomial trajectory |
| CPredictiveExtrapolationInputProcessor | Translates input and extrapolated velocity into a CartesianTrackingObjective |
| CPyController | A controller that interfaces with a python module |
| CRampCSpaceAdaptor | A CSpace where configurations are given by (q,dq) config, velocity pairs. Local paths are time-optimal acceleration bounded curves |
| CRampEdgeChecker | Edge planner class for the RampCSpaceAdaptor |
| CRampInterpolator | |
| CRampPathInterpolator | |
| CRealTimePlanner | A real-time planner. Supports constant time-stepping or adaptive time-stepping |
| CRealTimePlanningThread | An interface to a planning thread |
| CResourceGUIBackend | A backend for resource browsing. Natively supports configs, paths, transforms, ik goals, holds, stance, trimeshes |
| CRigidObject | A (static) rigid object that may be manipulated |
| CRigidObjectPoseWidget | |
| CRigidObjectResource | Resource for a RigidObject |
| CRobot | The main robot type used in RobotSim |
| CRobotConstrainedInterpolator | Just like a ConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints |
| CRobotController | A base class for a robot controller. The base class does nothing |
| CRobotControllerFactory | A class to simplify the loading of different controllers at run time |
| CRobotCSpace | Implements a basic robot configuration space with only joint limit constraint testing |
| CRobotIKPoseWidget | A widget that allows creating and editing IK constraints |
| CRobotJoint | Additional joint properties |
| CRobotJointDriver | Determines the effects of an actuator on the robot configuration |
| CRobotLinkPoseWidget | A widget that allows the robot's driven links to be posed |
| CRobotMotorCommand | A collection of basic motor types |
| CRobotPlannerSettings | |
| CRobotPoseBackend | Contains the functionality for the RobotPose program |
| CRobotPoseWidget | |
| CRobotResource | Resource for a Robot |
| CRobotSensors | A set of sensors for the robot |
| CRobotSmoothConstrainedInterpolator | Just like a SmoothConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints |
| CRobotStateEstimator | A generic state estimator base class. Base class does nothing |
| CRobotTestBackend | RobotTest program |
| CRobotUserInterface | An abstract base class for a user interface |
| CRobotWorld | The main world class containing multiple robots, objects, and static geometries (terrains). Lights and other viewport information may also be stored here |
| CRRTCommandInterface | An interface that uses the real-time RRT motion planner to achieve the user's objective |
| CSelfCollisionConstraint | |
| CSendPathCallbackBase | A base class for the path sending callback. Send is called by the planner to update the path used by the execution thread |
| CSensorBase | A sensor base class. A SensorBase should allow a Controller to both connect to a simulation as well as a real sensor |
| CSensorPlot | |
| CSerialControlledRobot | A Klamp't controlled robot that communicates to a robot (either real or virtual) using the Klamp't controller serialization mechanism. Acts as a client connecting to the given host |
| CSerialController | A controller that writes sensor data to a socket and reads robot commands from a socket |
| CSerializedObjectiveProcessor | Reads an objective function from a reader thread |
| CSimGUIBackend | Generic simulation program |
| CSimTestBackend | SimTest program |
| CSingleRigidObjectCSpace | A configuration space for a rigid object, treated like a robot |
| CSingleRobotCSpace | A cspace consisting of a single robot configuration in a RobotWorld. Feasibility constraints are joint and collision constraints |
| CSmoothConstrainedInterpolator | Constructs a piecewise polynomial path between a and b such that each point is near the constraint C(x)=0 |
| CSocketObjectiveProcessor | Reads an objective function from a socket |
| CSpringHook | A hook that acts as a Hookean spring to a given fixed target point |
| CStance | A collection of holds |
| CStanceCSpace | A configuration space that constrains a robot to the IK constraints in a stance, and checks for stability against gravity |
| CStanceResource | Resource for a Stance |
| CStandardInputProcessor | Translates click-and-drag input into an IKObjective |
| CSuppPolyConstraint | |
| CTabulatedController | A controller that reads from a grid of torque/desired configuration commands |
| CTerminalTimeObjective | A goal that measures absolute difference in terminal time (i.e., penalize stopping at a different time than specified) |
| CTerrain | A model of a static terrain with known friction |
| CTerrainPlannerSettings | |
| CTexturizer | Applies a texture to some object |
| CTiltSensor | Simulates a tilt sensor that measures the angle of a reference direction about certain axes |
| CTimeDelayedSensor | An time delayed "piggyback" sensor |
| CTimeObjective | An objective that measures path execution time |
| CTimeScaledBezierCurve | A convenience class that stores a Bezier curve and its time scaling. Useful for evaluating the scaled curve, and for plotting it |
| CTimeScaling | Maps time into a given path parameter range (e.g., [0,1]) with joint space velocity and acceleration bounds. Stores a piecewise quadratic time scaling. Most users will use the TimeScaledBezierCurve class or OptimizeTimeScaling methods instead |
| CTorqueLimitConstraint | |
| CTorqueTask | |
| CTorqueTimeScaling | A time scaling with torque constraints |t| <= tmax. Assuming fixed base manipulator |
| CTransformedSensor | A transformed "piggyback" sensor with a scale, bias, and minimum / maximum |
| CTriangle2DSampler | Samples points in a list of 2d triangles |
| CTriangle3DSampler | Samples points in a list of 3d triangles |
| CTriMeshResource | Resource for a TriMesh. Needs to be overloaded to load from alternate mesh formats (meshing/IO.h) |
| CURDFConverter | |
| CURDFLinkNode | |
| CVelocityObjective | A goal that measures distance to a goal velocity vgoal |
| CViewCamera | Draws a camera in the OpenGL world |
| CViewContact | Displays a contact point using OpenGL |
| CViewGrasp | Displays a grasp using OpenGL |
| CViewHold | Displays a hold using OpenGL |
| CViewIKGoal | |
| CViewPlot | An OpenGL x-y auto-scrolling plot. Used in SimTest (Interface/SimTestGUI.h) to draw sensor data |
| CViewPolytope | Displays a support polygon using OpenGL |
| CViewResource | |
| CViewRobot | Draws the robot (potentially color-coded) |
| CViewStance | Displays a stance using OpenGL |
| CViewTextures | |
| CViewWrench | |
| CWheelContactFeature | A wheel contact feature |
| CWorkspaceAccelTask | |
| CWorldDragWidget | |
| CWorldGUIBackend | A generic gui with a RobotWorld which allows clicking on entities and loading files |
| CWorldPlannerSettings | A structure containing settings that should be used for collision detection, contact solving, etc. Also performs modified collision checking with enabled/disabled collision checking between different objects |
| CWorldResource | Resource for a RobotWorld |
| CWorldSimulation | A physical simulator for a RobotWorld |
| CWorldSimulationHook | Any function that should be run per sub-step of the simulation needs to be a WorldSimulationHook subclass and added to the WorldSimulation.hooks member |
| CWrenchHook | A hook that adds a constant wrench (force f and moment m) to the body |
| CXmlODEGeometry | |
| CXmlODESettings | |
| CXmlRigidObject | |
| CXmlRobot | |
| CXmlSimulationSettings | |
| CXmlTerrain | |
| CXmlWorld | |
| CZMPTimeScaling | A time scaling with Zero Moment Point constraints. Each section of the multipath corresponds with one of the support polygons |
