Klamp't  0.8.1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12]
 CAccelerometerSimulates an accelerometer
 CActiveRobotCSpaceA CSpace for just a few dofs of a robot. Slightly faster than using a regular RobotCSpace then picking out subvectors
 CActuatorCommandA basic motor type. Handles PID, torque, and locked velocity modes
 CCameraSensorSimulates an RGB, D, or RGB+D camera sensor. Provides a 2D grid of color and/or depth values, capped and quantized
 CCartesianObjectiveA goal that measures point-to-point distance
 CCartesianTrackingObjectiveTracking a path in cartesian space
 CCompositeObjectiveAn objective that merges contributions from multiple other objective functions
 CConfigFixerA class for "fixing" a configuration by sampling a feasible configuration near it
 CConfigObjectiveA goal that measures distance to a goal configuration qgoal
 CConfigsResourceResource for multiple Config's
 CConstrainedInterpolatorConstruct a polyline between a and b such that each point is near the constraint C(x)=0
 CConstraintCheckerChecks for static constraints for a robot at a given stance
 CContactCSpaceA SingleRobotCSpace for a robot maintaining contact
 CContactFeatureBaseA feature on the robot that can be used for contact
 CContactFeatureMappingA mapping from a ContactFeature to a point on the environment
 CContactFeedbackInfoContainer for information about contacts regarding a certain object. Can be set to accumulate a summary over sub-steps or detailed data per-step
 CContactJointTrackingControllerMakes a joint tracking controller 'aware' of a contact formation
 CContactSensorSimulates a contact sensor / tactile sensor
 CContactTimeScalingA time scaling with torque/contact constraints
 CControlledRobotAn 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
 CControlledRobotSimulatorA class containing information about an ODE-simulated and controlled robot
 CCorruptedSensorA "piggyback" sensor that corrupts readings with quantization error and gaussian noise
 CCSpaceFeasibilityCheckerAdapter for the ParabolicRamp feasibility checking routines
 CCustomTimeScalingA base class for a time scaling with colocation point constraints. Subclasses should fill in dsmax, ds2ddsConstraintNormals, and ds2ddsConstraintOffsets before Optimize is called
 CDefaultMotionQueueInterfaceA MotionQueueInterface that just sends to a PolynomialMotionQueue
 CDistanceQueryA method for efficiently caching and updating distance computations using temporal coherence
 CDriverTorqueSensorSimulates a torque sensor
 CDynamicHybridTreePlannerThe preferred dynamic sampling-based planner for realtime planning. Will alternate sampling-based planning and smoothing via shortcutting
 CDynamicIKPlannerA 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)
 CDynamicMotionPlannerBaseA 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
 CDynamicPerturbationIKPlannerA planner that perturbs the current configuration and uses numerical IK to get an improved path. All caveats of RealTimeIKPlanner apply
 CDynamicPerturbationPlannerA planner that perturbs the current configuration to get an improved path
 CDynamicRRTPlannerDynamic RRT planner – not recently tested
 CEdgeContactFeatureAn edge contact feature
 CFaceContactFeatureA (planar) face contact feature
 CFacesContactFeatureA contact feature consisting of multiple faces
 CFeedforwardControllerA class that adds a feedforward torque to the basic control. The necessary feedforward torque is estimated assuming the robot is fixed-base
 CFilteredSensorAn exponentially smoothed filter that acts as a "piggyback" sensor
 CForceHookA hook that adds a constant force to a body
 CForceTorqueSensorSimulates a force-torque sensor mounted between a link and its parent. Can be configured to be up to 6DOF
 CGeneralizedRobotA collection of robots and objects that can be treated like one "big robot"
 CGenericGUIBaseA base class for a GUI frontend. Performs message passing to the backend in the easily serializable AnyCollection format
 CGLNavigationBackendA backend that manages a camera and performs OpenGL scene management
 CGLUIGUIA base class for GLUI GUIs
 CGraspSlightly more sophisticated than a Stance, a Grasp allows some of the robot's degrees of freedom to be fixed
 CGraspResourceResource for a Grasp
 CGyroSensorSimulates a gyroscope
 CHoldA single contact between the robot and the environment
 CHoldResourceResource for a Hold
 CIKCommandInterfaceAn 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
 CIKGoalResourceResource for an IKGoal
 CIKObjectiveA goal for an IK solution (including possibly rotation)
 CIKPlannerCommandInterfaceAn interface uses safe IK as the real-time planner class to achieve the user's objective
 CIMUSensorAn inertial measurement unit. May provide all or some of a rigid body's state
 CInputProcessingInterfaceAn 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
 CInputProcessorBaseAn abstract base class for processing user input through a 2D mouse driven gui into PlannerObjectives used for planning
 CIntegratedStateEstimatorA state estimator that integrates information from accelerometers (i.e., an Inertial Measurement Unit) and gravity sensors
 CJointCommandInterfaceAn interface that allows the user to pose individual joints using mouse dragging
 CJointPositionSensorSimulates a joint encoder
 CJointTrackingControllerA controller base class that reads out a desired servo position and velocity using the method GetDesiredState
 CJointVelocitySensorSimulates a velocity sensor. (Does not perform differencing)
 CLaserRangeSensorSimulates a laser range sensor, either sweeping or stationary. Can both simulate both 1D sweeping and 2D sweeping
 CLinearPathA piecewise linear path
 CLinearPathResourceResource for a LinearPath
 CLocalForceHookA hook that adds a constant force in world coordinates to a point on a body given in local coordinates
 CLoggingControllerA controllre that saves/replays low-level commands from disk
 CManagedGeometryA "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
 CMouseDragBackendA backend that processes mouse motion calls into dragging callbacks. Makes it a bit easier to determine free-dragging, control-dragging, shift-dragging, etc
 CMTPlannerCommandInterfaceA base class for a multithreaded planning robot UI. Subclasses must call planningThread.SetStartConfig(), SetCSpace(), and SetPlanner()
 CMultiPathA very general multi-section path container
 CMultiPathResourceResource for a MultiPath
 CODEContactListA list of contacts between two objects, returned as feedback from the simulation
 CODEGeometryAn ODE collision geometry
 CODEObjectIDAn index that identifies some ODE object in the world. Environments, robots, robot bodies, or rigid objects are supported
 CODERigidObjectAn ODE-simulated rigid object
 CODERobotA robot simulated in an ODE "world"
 CODESimulatorAn interface to the ODE simulator
 CODESimulatorSettingsGlobal simulator settings
 CODESurfacePropertiesSurface properties for any ODE rigid object, robot link, or fixed object
 COmniscientStateEstimatorA state estimator will full knowledge of the robot's simulated state. An ODERobot must be provided at initialization
 COperationalSpaceControllerA combination of multiple "tasks" that define a weighted optimization objective for the joint torques
 CParameterizedVectorFieldFunctionA VectorFieldFunction that depends on a parameter theta
 CPlannerCommandInterfaceAn interface that uses a real-time planner to solve for an arbitrary objective function. Subclasses must choose which type of planner to use
 CPlannerObjectiveBaseA base class for objective functionals in time/config/velocity space
 CPointCloudResourceResource for a PointCloud3D
 CPointContactFeatureA single point contact feature
 CPolygon2DSamplerSamples points in a convex polygon
 CPolygon3DSamplerSamples points in a convex polygon (in 3D)
 CPolynomialMotionQueueA 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
 CPolynomialPathControllerA controller that uses a piecewise polynomial trajectory
 CPredictiveExtrapolationInputProcessorTranslates input and extrapolated velocity into a CartesianTrackingObjective
 CPyControllerA controller that interfaces with a python module
 CRampCSpaceAdaptorA CSpace where configurations are given by (q,dq) config, velocity pairs. Local paths are time-optimal acceleration bounded curves
 CRampEdgeCheckerEdge planner class for the RampCSpaceAdaptor
 CRealTimePlannerA real-time planner. Supports constant time-stepping or adaptive time-stepping
 CRealTimePlanningThreadAn interface to a planning thread
 CResourceGUIBackendA backend for resource browsing. Natively supports configs, paths, transforms, ik goals, holds, stance, trimeshes
 CRigidObjectA (static) rigid object that may be manipulated
 CRigidObjectResourceResource for a RigidObject
 CRobotThe main robot type used in RobotSim
 CRobotConstrainedInterpolatorJust like a ConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints
 CRobotControllerA base class for a robot controller. The base class does nothing
 CRobotControllerFactoryA class to simplify the loading of different controllers at run time
 CRobotCSpaceImplements a basic robot configuration space with only joint limit constraint testing
 CRobotIKPoseWidgetA widget that allows creating and editing IK constraints
 CRobotJointAdditional joint properties
 CRobotJointDriverDetermines the effects of an actuator on the robot configuration
 CRobotLinkPoseWidgetA widget that allows the robot's driven links to be posed
 CRobotMotorCommandA collection of basic motor types
 CRobotPoseBackendContains the functionality for the RobotPose program
 CRobotResourceResource for a Robot
 CRobotSensorsA set of sensors for the robot
 CRobotSmoothConstrainedInterpolatorJust like a SmoothConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints
 CRobotStateEstimatorA generic state estimator base class. Base class does nothing
 CRobotTestBackendRobotTest program
 CRobotUserInterfaceAn abstract base class for a user interface
 CRobotWorldThe main world class containing multiple robots, objects, and static geometries (terrains). Lights and other viewport information may also be stored here
 CRRTCommandInterfaceAn interface that uses the real-time RRT motion planner to achieve the user's objective
 CSendPathCallbackBaseA base class for the path sending callback. Send is called by the planner to update the path used by the execution thread
 CSensorBaseA sensor base class. A SensorBase should allow a Controller to both connect to a simulation as well as a real sensor
 CSerialControlledRobotA 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
 CSerialControllerA controller that writes sensor data to a socket and reads robot commands from a socket
 CSerializedObjectiveProcessorReads an objective function from a reader thread
 CSimGUIBackendGeneric simulation program
 CSimTestBackendSimTest program
 CSingleRigidObjectCSpaceA configuration space for a rigid object, treated like a robot
 CSingleRobotCSpaceA cspace consisting of a single robot configuration in a RobotWorld. Feasibility constraints are joint and collision constraints
 CSmoothConstrainedInterpolatorConstructs a piecewise polynomial path between a and b such that each point is near the constraint C(x)=0
 CSocketObjectiveProcessorReads an objective function from a socket
 CSpringHookA hook that acts as a Hookean spring to a given fixed target point
 CStanceA collection of holds
 CStanceCSpaceA configuration space that constrains a robot to the IK constraints in a stance, and checks for stability against gravity
 CStanceResourceResource for a Stance
 CStandardInputProcessorTranslates click-and-drag input into an IKObjective
 CTabulatedControllerA controller that reads from a grid of torque/desired configuration commands
 CTerminalTimeObjectiveA goal that measures absolute difference in terminal time (i.e., penalize stopping at a different time than specified)
 CTerrainA model of a static terrain with known friction
 CTexturizerApplies a texture to some object
 CTiltSensorSimulates a tilt sensor that measures the angle of a reference direction about certain axes
 CTimeDelayedSensorAn time delayed "piggyback" sensor
 CTimeObjectiveAn objective that measures path execution time
 CTimeScaledBezierCurveA convenience class that stores a Bezier curve and its time scaling. Useful for evaluating the scaled curve, and for plotting it
 CTimeScalingMaps 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
 CTorqueTimeScalingA time scaling with torque constraints |t| <= tmax. Assuming fixed base manipulator
 CTransformedSensorA transformed "piggyback" sensor with a scale, bias, and minimum / maximum
 CTriangle2DSamplerSamples points in a list of 2d triangles
 CTriangle3DSamplerSamples points in a list of 3d triangles
 CTriMeshResourceResource for a TriMesh. Needs to be overloaded to load from alternate mesh formats (meshing/IO.h)
 CVelocityObjectiveA goal that measures distance to a goal velocity vgoal
 CViewCameraDraws a camera in the OpenGL world
 CViewContactDisplays a contact point using OpenGL
 CViewGraspDisplays a grasp using OpenGL
 CViewHoldDisplays a hold using OpenGL
 CViewPlotAn OpenGL x-y auto-scrolling plot. Used in SimTest (Interface/SimTestGUI.h) to draw sensor data
 CViewPolytopeDisplays a support polygon using OpenGL
 CViewRobotDraws the robot (potentially color-coded)
 CViewStanceDisplays a stance using OpenGL
 CWheelContactFeatureA wheel contact feature
 CWorldGUIBackendA generic gui with a RobotWorld which allows clicking on entities and loading files
 CWorldPlannerSettingsA 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
 CWorldResourceResource for a RobotWorld
 CWorldSimulationA physical simulator for a RobotWorld
 CWorldSimulationHookAny function that should be run per sub-step of the simulation needs to be a WorldSimulationHook subclass and added to the WorldSimulation.hooks member
 CWrenchHookA hook that adds a constant wrench (force f and moment m) to the body
 CZMPTimeScalingA time scaling with Zero Moment Point constraints. Each section of the multipath corresponds with one of the support polygons