| CKlampt::ActuatorCommand | A basic motor type. Handles PID, torque, and locked velocity modes |
| ►CBasicResource | |
| CKlampt::TriMeshResource | Resource for a TriMesh. Needs to be overloaded to load from alternate mesh formats (meshing/IO.h) |
| ►CGraph::CallbackBase | |
| CDrawEECallback | |
| CDrawEECallback2 | |
| CDrawEECallback3 | |
| Curdf::Collision | |
| Curdf::Color | |
| CKlampt::COMAccelTask | |
| ►CCompoundResourceBase | |
| CKlampt::ConfigsResource | Resource for multiple Config's |
| CKlampt::GraspResource | Resource for a Grasp |
| CKlampt::HoldResource | Resource for a Hold |
| CKlampt::IKGoalResource | Resource for an IKGoal |
| CKlampt::LinearPathResource | Resource for a LinearPath |
| CKlampt::MultiPathResource | Resource for a MultiPath |
| CKlampt::StanceResource | Resource for a Stance |
| CKlampt::WorldResource | Resource for a WorldModel |
| CKlampt::ConfigFixer | A class for "fixing" a configuration by sampling a feasible configuration near it |
| ►CKlampt::ConstrainedInterpolator | Construct a polyline between a and b such that each point is near the constraint C(x)=0 |
| CKlampt::RobotConstrainedInterpolator | Just like a ConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints |
| CKlampt::ConstraintChecker | Checks for static constraints for a robot at a given stance |
| CKlampt::ContactDistanceMetric | |
| ►CKlampt::ContactFeatureBase | A feature on the robot that can be used for contact |
| CKlampt::EdgeContactFeature | An edge contact feature |
| CKlampt::FaceContactFeature | A (planar) face contact feature |
| CKlampt::FacesContactFeature | A contact feature consisting of multiple faces |
| CKlampt::PointContactFeature | A single point contact feature |
| CKlampt::WheelContactFeature | A wheel contact feature |
| CKlampt::ContactFeatureMapping | A mapping from a ContactFeature to a point on the environment |
| CKlampt::ContactFeedbackInfo | Container for information about contacts regarding a certain object. Can be set to accumulate a summary over sub-steps or detailed data per-step |
| CKlampt::ContactForceTask | |
| ►CKlampt::ControlledRobot | 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 |
| CKlampt::SerialControlledRobot | 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 |
| ►CCSpace | |
| CKlampt::RampCSpaceAdaptor | A CSpace where configurations are given by (q,dq) config, velocity pairs. Local paths are time-optimal acceleration bounded curves |
| CKlampt::CustomGeometryData | |
| ►CKlampt::CustomTimeScaling | A base class for a time scaling with colocation point constraints. Subclasses should fill in dsmax, ds2ddsConstraintNormals, and ds2ddsConstraintOffsets before Optimize is called |
| CKlampt::ContactTimeScaling | A time scaling with torque/contact constraints |
| CKlampt::TorqueTimeScaling | A time scaling with torque constraints |t| <= tmax. Assuming fixed base manipulator |
| CKlampt::ZMPTimeScaling | A time scaling with Zero Moment Point constraints. Each section of the multipath corresponds with one of the support polygons |
| CParabolicRamp::DistanceCheckerBase | 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 |
| CDistanceQuery | A method for efficiently caching and updating distance computations using temporal coherence |
| ►CKlampt::DynamicMotionPlannerBase | 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 |
| CKlampt::DynamicHybridTreePlanner | The preferred dynamic sampling-based planner for realtime planning. Will alternate sampling-based planning and smoothing via shortcutting |
| CKlampt::DynamicIKPlanner | 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) |
| CKlampt::DynamicPerturbationIKPlanner | A planner that perturbs the current configuration and uses numerical IK to get an improved path. All caveats of RealTimeIKPlanner apply |
| CKlampt::DynamicPerturbationPlanner | A planner that perturbs the current configuration to get an improved path |
| CKlampt::DynamicRRTPlanner | Dynamic RRT planner – not recently tested |
| CParabolicRamp::DynamicPath | A bounded-velocity, bounded-acceleration trajectory consisting of parabolic ramps |
| CKlampt::DynamicHybridTreePlanner::EdgeData | |
| ►CEdgePlanner | |
| CKlampt::RampEdgeChecker | Edge planner class for the RampCSpaceAdaptor |
| CKlampt::GeneralizedRobotModel::Element | |
| Curdf::Entity | |
| ►CParabolicRamp::FeasibilityCheckerBase | A base class for a feasibility checker |
| CKlampt::CSpaceFeasibilityChecker | Adapter for the ParabolicRamp feasibility checking routines |
| CKlampt::GeneralizedRobotModel | A collection of robots and objects that can be treated like one "big robot" |
| ►CKlampt::GenericBackendBase | |
| CKlampt::CompositeBackend | |
| ►CKlampt::MouseDragBackend | A backend that processes mouse motion calls into dragging callbacks. Makes it a bit easier to determine free-dragging, control-dragging, shift-dragging, etc |
| ►CKlampt::GLNavigationBackend | A backend that manages a camera and performs OpenGL scene management |
| ►CKlampt::WorldGUIBackend | A generic gui with a WorldModel which allows clicking on entities and loading files |
| ►CKlampt::ResourceGUIBackend | A backend for resource browsing. Natively supports configs, paths, transforms, ik goals, holds, stance, trimeshes |
| CKlampt::RobotPoseBackend | Contains the functionality for the RobotPose program |
| CKlampt::RobotTestBackend | RobotTest program |
| ►CKlampt::SimGUIBackend | Generic simulation program |
| CKlampt::SimTestBackend | SimTest program |
| ►CKlampt::GenericGUIBase | A base class for a GUI frontend. Performs message passing to the backend in the easily serializable AnyCollection format |
| CKlampt::GLUIGUI | A base class for GLUI GUIs |
| CKlampt::GLUTGUI | |
| ►CGeodesicCSpace | |
| CKlampt::ActiveRobotCSpace | A CSpace for just a few dofs of a robot. Slightly faster than using a regular RobotCSpace then picking out subvectors |
| ►CKlampt::RobotCSpace | Implements a basic robot configuration space with only joint limit constraint testing |
| ►CKlampt::SingleRobotCSpace | A cspace consisting of a single robot configuration in a WorldModel. Feasibility constraints are joint and collision constraints |
| ►CKlampt::ContactCSpace | A SingleRobotCSpace for a robot maintaining contact |
| CKlampt::StanceCSpace | A configuration space that constrains a robot to the IK constraints in a stance, and checks for stability against gravity |
| ►Curdf::Geometry | |
| Curdf::Box | |
| Curdf::Cylinder | |
| Curdf::Mesh | |
| Curdf::Sphere | |
| CKlampt::GeometryManager::GeometryList | |
| CKlampt::GeometryManager | |
| ►CGLUIProgramBase | |
| CKlampt::GLUIGUI | A base class for GLUI GUIs |
| ►CGLUTProgramBase | |
| CKlampt::GLUTGUI | |
| CKlampt::Grasp | Slightly more sophisticated than a Stance, a Grasp allows some of the robot's degrees of freedom to be fixed |
| CKlampt::Hold | A single contact between the robot and the environment |
| ►CInequalityConstraint | |
| CKlampt::CollisionConstraint | |
| CKlampt::SelfCollisionConstraint | |
| CKlampt::SuppPolyConstraint | |
| CKlampt::TorqueLimitConstraint | |
| Curdf::Inertial | |
| ►CKlampt::InputProcessorBase | An abstract base class for processing user input through a 2D mouse driven gui into PlannerObjectives used for planning |
| ►CKlampt::SerializedObjectiveProcessor | Reads an objective function from a reader thread |
| CKlampt::SocketObjectiveProcessor | Reads an objective function from a socket |
| ►CKlampt::StandardInputProcessor | Translates click-and-drag input into an IKObjective |
| CKlampt::PredictiveExtrapolationInputProcessor | Translates input and extrapolated velocity into a CartesianTrackingObjective |
| ►CInterpolator | |
| CKlampt::RampInterpolator | |
| CKlampt::RampPathInterpolator | |
| Curdf::Joint | |
| CKlampt::JointAccelTask | |
| Curdf::JointCalibration | |
| Curdf::JointDynamics | |
| Curdf::JointLimits | |
| Curdf::JointMimic | |
| Curdf::JointSafety | Parameters for Joint Safety Controllers |
| Curdf::JointState | |
| ►CLimitConstraint | |
| CKlampt::JointLimitConstraint | |
| CKlampt::LinearPath | A piecewise linear path |
| Curdf::Link | |
| CKlampt::ManagedGeometry | A "smart" geometry loading class that caches previous geometries and maintains shared collision detection / appearance information. This greatly speeds up loading time if multiple instances of the same geometry are loaded from disk, because multiple ManagedGeometry objects can share the same underlying data. It can also read from dynamic geometry sources (ROS point cloud topics, for now) |
| ►Cmap | |
| CKlampt::Stance | A collection of holds |
| Curdf::Material | |
| Curdf::ModelInterface | |
| Curdf::ModelState | |
| ►CKlampt::MotionQueueInterface | |
| CKlampt::DefaultMotionQueueInterface | A MotionQueueInterface that just sends to a PolynomialMotionQueue |
| CKlampt::MultiPath | A very general multi-section path container |
| CKlampt::DynamicHybridTreePlanner::NodeData | |
| CKlampt::ObjectPlannerSettings | |
| CKlampt::ODEContactList | A list of contacts between two objects, returned as feedback from the simulation |
| CKlampt::ODEGeometry | An ODE collision geometry |
| CKlampt::ODEJoint | A joint between two objects |
| CKlampt::ODEObjectID | An index that identifies some ODE object in the world. Environments, robots, robot bodies, or rigid objects are supported |
| CKlampt::ODERigidObject | An ODE-simulated rigid object |
| CKlampt::ODERobot | A robot simulated in an ODE "world" |
| CKlampt::ODESimulator | An interface to the ODE simulator |
| CKlampt::ODESimulatorSettings | Global simulator settings |
| CKlampt::ODESurfaceProperties | Surface properties for any ODE rigid object, robot link, or fixed object |
| CParabolicRamp::ParabolicRamp1D | Stores optimal trajectores for an acceleration and velocity-bounded 1D system |
| CParabolicRamp::ParabolicRampND | Solves for optimal trajectores for a velocity-bounded ND system |
| CKlampt::MultiPath::PathSection | |
| ►CKlampt::PlannerObjectiveBase | A base class for objective functionals in time/config/velocity space |
| CKlampt::CartesianObjective | A goal that measures point-to-point distance |
| CKlampt::CartesianTrackingObjective | Tracking a path in cartesian space |
| CKlampt::CompositeObjective | An objective that merges contributions from multiple other objective functions |
| CKlampt::ConfigObjective | A goal that measures distance to a goal configuration qgoal |
| CKlampt::IKObjective | A goal for an IK solution (including possibly rotation) |
| CKlampt::TerminalTimeObjective | A goal that measures absolute difference in terminal time (i.e., penalize stopping at a different time than specified) |
| CKlampt::TimeObjective | An objective that measures path execution time |
| CKlampt::VelocityObjective | A goal that measures distance to a goal velocity vgoal |
| ►CPolygon3D | |
| CKlampt::FaceContactFeature | A (planar) face contact feature |
| ►CKlampt::PolynomialMotionQueue | 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 |
| CKlampt::PolynomialPathController | A controller that uses a piecewise polynomial trajectory |
| Curdf::Pose | |
| CParabolicRamp::RampFeasibilityChecker | A class that encapsulates feaibility checking of a ParabolicRampND |
| CParabolicRamp::RandomNumberGeneratorBase | A custom random number generator that can be provided to DynamicPath::Shortcut() |
| CKlampt::RealTimePlanner | A real-time planner. Supports constant time-stepping or adaptive time-stepping |
| CKlampt::RealTimePlanningThread | An interface to a planning thread |
| ►CResourceBase | |
| CKlampt::PointCloudResource | Resource for a PointCloud3D |
| CKlampt::RigidObjectResource | Resource for a RigidObject |
| CKlampt::RobotResource | Resource for a Robot |
| CKlampt::RigidObjectModel | A (static) rigid object that may be manipulated |
| ►CKlampt::RobotController | A base class for a robot controller. The base class does nothing |
| CKlampt::ContactJointTrackingController | Makes a joint tracking controller 'aware' of a contact formation |
| CKlampt::FeedforwardController | A class that adds a feedforward torque to the basic control. The necessary feedforward torque is estimated assuming the robot is fixed-base |
| ►CKlampt::JointTrackingController | A controller base class that reads out a desired servo position and velocity using the method GetDesiredState |
| CKlampt::PolynomialPathController | A controller that uses a piecewise polynomial trajectory |
| CKlampt::LoggingController | A controllre that saves/replays low-level commands from disk |
| CKlampt::OperationalSpaceController | A combination of multiple "tasks" that define a weighted optimization objective for the joint torques |
| CKlampt::PyController | A controller that interfaces with a python module |
| CKlampt::SerialController | A controller that writes sensor data to a socket and reads robot commands from a socket |
| CKlampt::TabulatedController | A controller that reads from a grid of torque/desired configuration commands |
| CKlampt::RobotControllerFactory | A class to simplify the loading of different controllers at run time |
| CKlampt::RobotModelDriver | Determines the effects of an actuator on the robot configuration |
| CKlampt::RobotModelJoint | Additional joint properties |
| CKlampt::RobotMotorCommand | A collection of basic motor types |
| CKlampt::RobotPlannerSettings | |
| CKlampt::RobotSensors | A set of sensors for the robot |
| ►CKlampt::RobotStateEstimator | A generic state estimator base class. Base class does nothing |
| CKlampt::IntegratedStateEstimator | A state estimator that integrates information from accelerometers (i.e., an Inertial Measurement Unit) and gravity sensors |
| CKlampt::OmniscientStateEstimator | A state estimator will full knowledge of the robot's simulated state. An ODERobot must be provided at initialization |
| ►CKlampt::RobotUserInterface | An abstract base class for a user interface |
| ►CKlampt::InputProcessingInterface | 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 |
| CKlampt::IKCommandInterface | 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 |
| ►CKlampt::MTPlannerCommandInterface | A base class for a multithreaded planning robot UI. Subclasses must call planningThread.SetStartConfig(), SetCSpace(), and SetPlanner() |
| CKlampt::MTIKPlannerCommandInterface | |
| CKlampt::MTRRTCommandInterface | |
| ►CKlampt::PlannerCommandInterface | An interface that uses a real-time planner to solve for an arbitrary objective function. Subclasses must choose which type of planner to use |
| CKlampt::IKPlannerCommandInterface | An interface uses safe IK as the real-time planner class to achieve the user's objective |
| CKlampt::RRTCommandInterface | An interface that uses the real-time RRT motion planner to achieve the user's objective |
| CKlampt::JointCommandInterface | An interface that allows the user to pose individual joints using mouse dragging |
| ►CRobotWithGeometry | |
| CKlampt::RobotModel | The main robot type used in RobotSim |
| Curdf::Rotation | |
| ►Cstd::runtime_error | |
| Curdf::ParseError | |
| ►CSE3CSpace | |
| CKlampt::SingleRigidObjectCSpace | A configuration space for a rigid object, treated like a robot |
| CKlampt::SendPathCallbackBase | A base class for the path sending callback. Send is called by the planner to update the path used by the execution thread |
| Curdf::Sensor | |
| ►CKlampt::SensorBase | A sensor base class. A SensorBase should allow a Controller to both connect to a simulation as well as a real sensor |
| CKlampt::Accelerometer | Simulates an accelerometer |
| CKlampt::CameraSensor | Simulates an RGB, D, or RGB+D camera sensor. Provides a 2D grid of color and/or depth values, capped and quantized |
| CKlampt::ContactSensor | Simulates a contact sensor / tactile sensor |
| CKlampt::CorruptedSensor | A "piggyback" sensor that corrupts readings with quantization error and gaussian noise |
| CKlampt::DriverTorqueSensor | Simulates a torque sensor |
| CKlampt::FilteredSensor | An exponentially smoothed filter that acts as a "piggyback" sensor |
| CKlampt::ForceTorqueSensor | Simulates a force-torque sensor mounted between a link and its parent. Can be configured to be up to 6DOF |
| CKlampt::GyroSensor | Simulates a gyroscope |
| CKlampt::IMUSensor | An inertial measurement unit. May provide all or some of a rigid body's state |
| CKlampt::JointPositionSensor | Simulates a joint encoder |
| CKlampt::JointVelocitySensor | Simulates a velocity sensor. (Does not perform differencing) |
| CKlampt::LaserRangeSensor | Simulates a laser range sensor, either sweeping or stationary. Can both simulate both 1D sweeping and 2D sweeping |
| CKlampt::TiltSensor | Simulates a tilt sensor that measures the angle of a reference direction about certain axes |
| CKlampt::TimeDelayedSensor | An time delayed "piggyback" sensor |
| CKlampt::TransformedSensor | A transformed "piggyback" sensor with a scale, bias, and minimum / maximum |
| CKlampt::SensorPlot | |
| ►CSimpleParser | |
| ►CKlampt::LineReader | |
| CKlampt::HoldReader | |
| CKlampt::SimRobotController | A class containing information about an ODE-simulated and controlled robot |
| CKlampt::Simulator | A physical simulator for a WorldModel |
| ►CKlampt::SimulatorHook | Any function that should be run per sub-step of the simulation needs to be a SimulatorHook subclass and added to the Simulator.hooks member |
| CKlampt::ForceHook | A hook that adds a constant force to a body |
| CKlampt::JointForceHook | A hook that adds a constant force to a joint |
| CKlampt::JointSpringHook | A hook that adds a Hookean (optionally damped) virtual spring to a joint |
| CKlampt::LocalForceHook | A hook that adds a constant force in world coordinates to a point on a body given in local coordinates |
| CKlampt::SpringHook | A hook that acts as a Hookean (optionally damped) spring to a given fixed target point |
| CKlampt::WrenchHook | A hook that adds a constant wrench (force f and moment m) to the body |
| ►CKlampt::SmoothConstrainedInterpolator | Constructs a piecewise polynomial path between a and b such that each point is near the constraint C(x)=0 |
| CKlampt::RobotSmoothConstrainedInterpolator | Just like a SmoothConstrainedInterpolator but only projects the active DOFs. Much faster for high-DOF system with sparse constraints |
| CKlampt::TerrainModel | A model of a static terrain with known friction |
| CKlampt::TerrainPlannerSettings | |
| CKlampt::Texturizer | Applies a texture to some object |
| Curdf::Time | |
| CKlampt::TimeScaledBezierCurve | A convenience class that stores a Bezier curve and its time scaling. Useful for evaluating the scaled curve, and for plotting it |
| CKlampt::TimeScaling | 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 |
| CKlampt::TorqueTask | |
| ►CKlampt::Triangle2DSampler | Samples points in a list of 2d triangles |
| CKlampt::Polygon2DSampler | Samples points in a convex polygon |
| ►CKlampt::Triangle3DSampler | Samples points in a list of 3d triangles |
| CKlampt::Polygon3DSampler | Samples points in a convex polygon (in 3D) |
| Curdf::Twist | |
| CKlampt::URDFConverter | |
| CKlampt::URDFLinkNode | |
| Curdf::Vector3 | |
| ►CVectorFieldFunction | |
| CKlampt::ParameterizedVectorFieldFunction | A VectorFieldFunction that depends on a parameter theta |
| CKlampt::ViewCamera | Draws a camera in the OpenGL world |
| CKlampt::ViewContact | Displays a contact point using OpenGL |
| CKlampt::ViewGrasp | Displays a grasp using OpenGL |
| CKlampt::ViewHold | Displays a hold using OpenGL |
| CKlampt::ViewIKGoal | |
| CViewPlot | An OpenGL x-y auto-scrolling plot. Used in SimTest (Interface/SimTestGUI.h) to draw sensor data |
| CKlampt::ViewPolytope | Displays a support polygon using OpenGL |
| CKlampt::ViewResource | |
| CKlampt::ViewRobot | Draws the robot (potentially color-coded) |
| CKlampt::ViewStance | Displays a stance using OpenGL |
| CKlampt::ViewTextures | |
| CKlampt::ViewWrench | |
| Curdf::Visual | |
| ►Curdf::VisualSensor | |
| Curdf::Camera | |
| Curdf::Ray | |
| ►CGLDraw::Widget | |
| CKlampt::RobotLinkPoseWidget | A widget that allows the robot's driven links to be posed |
| CKlampt::WorldDragWidget | |
| CKlampt::WorldViewWidget | A widget interface that can be overloaded to interact with a world |
| ►CGLDraw::WidgetSet | |
| CKlampt::RigidObjectPoseWidget | |
| CKlampt::RobotIKPoseWidget | A widget that allows creating and editing IK constraints |
| CKlampt::RobotPoseWidget | |
| CKlampt::WorkspaceAccelTask | |
| Curdf::World | |
| CKlampt::WorldModel | The main world class containing multiple robots, objects, and static geometries (terrains). Lights and other viewport information may also be stored here |
| CKlampt::WorldPlannerSettings | 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 |
| CKlampt::XmlODEGeometry | |
| CKlampt::XmlODESettings | |
| CKlampt::XmlRigidObject | |
| CKlampt::XmlRobot | |
| CKlampt::XmlSimulationSettings | |
| CKlampt::XmlTerrain | |
| CKlampt::XmlWorld | |
