Drake

►Ndrake  
►Nassert  
CConditionTraits< symbolic::Formula >  
►Nautomotive  
CAutomotiveSimulator  AutomotiveSimulator is a helper class for constructing and running automotiverelated simulations 
CBicycleCar  BicycleCar implements a nonlinear rigid body bicycle model from Althoff & Dolan (2014) [1] 
CBoxCarVis  BoxCarVis displays a box as the visual representation of a vehicle 
CCarVis  CarVis is a base class that provides visualization geometries and their poses 
CCarVisApplicator  CarVisApplicator takes as input a PoseVector containing vehicle poses 
CClosestPose  ClosestPose bundles together the RoadOdometry of a particular target along with its distance measure relative to the ego vehicle 
►CCurve2  Curve2 represents a path through twodimensional Cartesian space 
CPositionResult  A result type for the GetPosition method 
CIdmController  IdmController implements the IDM (Intelligent Driver Model) planner, computed based only on the nearest car ahead 
CIdmPlanner  IdmPlanner implements the IDM (Intelligent Driver Model) equation governing longitudinal accelerations of a vehicle in singlelane traffic [1, 2] 
CLaneDirection  LaneDirection holds the lane that a MaliputRailcar is traversing and the direction in which it is moving 
CMaliputRailcar  MaliputRailcar models a vehicle that follows a maliput::api::Lane as if it were on rails and neglecting all physics 
CMobilPlanner  MOBIL (Minimizing Overall Braking Induced by Lane Changes) [1] is a planner that minimizes braking requirement for the ego car while also minimizing (per a weighting factor) the braking requirements of any trailing cars within the ego car's immediate neighborhood 
CMonolaneOnrampMerge  MonolaneOnrampMerge contains an example lanemerge scenario expressed as a maliput monolane road geometry 
CPoseSelector  PoseSelector is a class that provides the relevant pose or poses with respect to a given ego vehicle driving within a given maliput road geometry 
CPriusVis  PriusVis displays a visualization of a 2015 Toyota Prius 
CPurePursuit  PurePursuit computes the required steering angle to achieve a goal point on an continuous planar path 
CPurePursuitController  PurePursuitController implements a pure pursuit controller 
CRoadCharacteristics  RoadCharacteristics computes and stores characteristics of a road network; i.e 
CRoadOdometry  RoadOdometry contains the position of the vehicle with respect to a lane in a road, along with its velocity vector in the world frame 
CRoadPath  RoadPath converts a sequence of Maliput Lanes into a PiecewisePolynomial for the purpose of generating a path for a car to follow 
CSimpleCar  SimpleCar models an idealized response to driving commands, neglecting all physics 
CSimplePowertrain  SimplePowertrain models a powertrain with firstorder lag 
CTrafficLight  This class is a firstpass model of a traffic light 
CTrajectoryCar  TrajectoryCar models a car that follows a preestablished trajectory 
►Nbenchmarks  
►Nfree_body  
CFreeBody  The purpose of the FreeBody class is to provide the data (initial values and gravity) and methods for calculating the exact analytical solution for the translational and rotational motion of a toquefree rigid body B with axially symmetric inertia, in a Newtonian frame (World) N 
►Nbouncing_ball  
CBall  Dynamical system representation of the onedimensional equations of motion for a ball in flight, dropped with an initial position (height) and velocity 
CBouncingBall  Dynamical representation of the idealized hybrid dynamics of a ball dropping from a height and bouncing on a surface 
►Ncommon  
►Ninternal  
CPythonAccessor  
CPythonApi  
CPythonAttrPolicy  
CPythonItemPolicy  
CMatlabRemoteVariable  Holds a reference to a variable stored on the matlab client, which can be passed back into a future lcm_call_matlab call 
CPythonRemoteVariable  Presents variable stored in Python side 
►Ndetail  
Cassert_default_constructible  
Cassertion_error  This is what DRAKE_ASSERT and DRAKE_DEMAND throw when our assertions are configured to throw 
CFNV1aHasher  The FNV1a hash algorithm, used for hash_append generic hashing 
Ctype_at_impl  
Ctype_at_impl< N, N, T, Ts... >  
Ctype_pack_extract_impl  
Ctype_pack_extract_impl< Tpl< Ts... > >  
►Ctype_visit_impl  
Crunner  
Crunner< T, false >  
►Nexamples  
►Nacrobot  
CAcrobotCommandReceiver  Receives the output of an LcmSubscriberSystem that subscribes to the acrobot input channel with LCM type lcmt_acrobot_u, and outputs the acrobot input as a BasicVector 
CAcrobotCommandSender  Receives the output of an acrobot controller, and outputs it as an LCM message with type lcm_acrobot_u 
CAcrobotPlant  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
CAcrobotSpongController  
CAcrobotStateReceiver  Receives the output of an LcmSubsriberSystem that subsribes to the acrobot state channel with LCM type lcmt_acrobot_x, and outputs the acrobot states as an AcrobotStateVector 
CAcrobotStateSender  Receives the output of an acrobot_plant, and outputs it as an LCM message with type lcm_acrobot_x 
CAcrobotWEncoder  Constructs the Acrobot with (only) encoder outputs 
►Nbead_on_a_wire  
CBeadOnAWire  Dynamical system of a point (unit) mass constrained to lie on a wire 
►Nbouncing_ball  
CBouncingBallPlant  A model of a bouncing ball with HuntCrossley compliant contact model 
►Ndouble_pendulum  
►Nhumanoid_controller  
CAtlasCommandTranslatorSystem  A class that extends QpOutputTranslatorSystem to output an additional bot_core::atlas_command_t 
CBodyOfInterest  An object that holds important kinematic properties 
CHumanoidController  A controller for humanoid balancing built on top of HumanoidPlanEvalSystem and QpInverseDynamicsSystemSystem 
CHumanoidManipulationPlan  A baseline manipulation plan interpretor for a humanoid robot 
CHumanoidPlanEvalSystem  This class extends PlanEvalBaseSystem to interpret plans for humanoid robots 
CHumanoidStatus  Mostly a thin wrapper on RigidBodyTree 
CRobotStateMsgToHumanoidStatusSystem  Translates a bot_core::robot_state_t message to HumanoidStatus 
►Nkinova_jaco_arm  
CJacoCommandReceiver  Handles lcmt_jaco_command messages from a LcmSubscriberSystem 
CJacoCommandSender  Creates and outputs lcmt_jaco_command messages 
CJacoStatusReceiver  Handles lcmt_jaco_status messages from a LcmSubscriberSystem 
CJacoStatusSender  Creates and outputs lcmt_jaco_status messages 
►Nkuka_iiwa_arm  
►Nbox_rotation  
CIiwaAndBoxPlantWithStateEstimator  A custom systems::Diagram composed of a systems::RigidBodyPlant , and a systems::InverseDynamicsController , and two OracularStateEstimation systems 
►Nmonolithic_pick_and_place  
CMonolithicPickAndPlaceSystem  A custom systems::Diagram representing the entire pickandplace demo 
►Npick_and_place  
CAction  Base class for actions used by the pick and place demo 
CIiwaMove  A class that represents an action that sends a sequence of desired joint positions through LCM to move the KUKA iiwa arm 
CLcmPlanner  A custom systems::Diagram composed of a PickAndPlaceStateMachineSystem and drake::manipulation::OptitrackPoseExtractor systems 
CLcmPlant  A custom systems::Diagram comprised of an IiwaWsgPlantWithStateEstimator, a simulated Optitrack system, and SchunkWsgControllers for each gripper in the plant 
COptitrackConfiguration  Optitrack information required for a pickandplace scenario with multiple arms, tables, and manipulable objects 
COptitrackInfo  Information required to track a model from an Optitrack frame 
CPickAndPlaceStateMachine  A class which controls the pick and place actions for moving a single target in the environment 
CPickAndPlaceStateMachineSystem  A class that implements the FiniteStateMachine logic for the PickAndPlace demo 
CPlannerConfiguration  Information required to set up a planner for a pickandplace task 
CSimulatedPlantConfiguration  Information required to set up a simulation of a pickandplace scenario with multiple arms, tables, and manipulable objects 
CWorldState  A class that represents the iiwa pick and place world, which contains a KUKA iiwa arm, a Schunk WSG gripper, and an object that is being manipulated 
CWsgAction  An Action that closes / opens the gripper 
CIiwaAndWsgPlantWithStateEstimator  A custom systems::Diagram composed of a systems::RigidBodyPlant, a systems::controllers::InverseDynamicsController, and a number of OracularStateEstimation systems 
CIiwaCommandReceiver  Handles lcmt_iiwa_command messages from a LcmSubscriberSystem 
CIiwaCommandSender  Creates and outputs lcmt_iiwa_command messages 
CIiwaStatusReceiver  Handles lcmt_iiwa_status messages from a LcmSubscriberSystem 
CIiwaStatusSender  Creates and outputs lcmt_iiwa_status messages 
CLcmPlanInterpolator  
COracularStateEstimation  A System block that takes state vector and output a bot_core::robot_state_t message 
►Nmultibody  
►Npendulum  
CPendulumPlant  A model of an idealized pendulum with a point mass on the end of a massless rigid rod 
►Nparticles  
CParticle  A linear 1DOF particle system 
►Npendulum  
CPendulumPlant  A model of a simple pendulum \[ ml^2 \ddot\theta + b\dot\theta + mgl\sin\theta = u \] 
►Nqp_inverse_dynamics  
CManipulatorJointSpaceController  This class implements an example of a general purpose controller for a fixed based manipulator based on qp inverse dynamics 
CManipulatorMoveJointPlanEvalSystem  This class extends PlanEvalBaseSystem 
►Nquadrotor  
CQuadrotorPlant  The Quadrotor  an underactuated aerial vehicle 
►Nrod2d  
CRod2D  Dynamical system representation of a rod contacting a halfspace in two dimensions 
►Nsolar_system  
CSolarSystem  A model of an orrery – a simple mechanical model of the solar system 
►Nvalkyrie  
CValkyrieSimulationDiagram  
►Nvan_der_pol  
CVanDerPolOscillator  Van der Pol oscillator 
►Ngeometry  
►Ninternal  
CInternalAnchoredGeometry  This class represents the internal representation of registered anchored geometry 
CInternalFrame  This class represents the internal representation of a GeometryFrame 
CInternalGeometry  This class represents the internal representation of registered dynamic geometry 
CInternalGeometryBase  Base class for the internal representation of registered geometry 
CCylinder  Definition of a cylinder 
CFrameIdVector  Represents an ordered set of frame identifiers 
CFrameKinematicsVector  A FrameKinematicsVector associates a std::vector with a geometry source 
CGeometryContext  The custom leaf context type for GeometrySystem and GeometryWorld 
CGeometryFrame  This simple class carries the definition of a frame used by GeometryWorld 
CGeometryInstance  A geometry instance combines a geometry definition (i.e., a shape of some sort), a pose (relative to a parent "frame" P), material information, and an opaque collection of metadata 
CGeometryState  The contextdependent state of GeometryWorld 
CGeometrySystem  GeometrySystem serves as the nexus for all geometry (and geometrybased operations) in a Diagram 
CHalfSpace  Definition of a half space 
CIdentifier  A simple identifier class 
CPenetrationAsPointPair  A characterization of the intersection of two penetrating geometries 
CQueryObject  The QueryObject serves as a mechanism to perform geometry queries on the world's geometry 
CShape  The base interface for all shape specifications 
CShapeReifier  The interface for converting shape descriptions to real shapes 
CShapeTag  Simple struct for instantiating the typespecific Shape functionality 
CSphere  Definition of sphere 
►Nlcm  
CDrakeLcm  A wrapper around a real LCM instance 
CDrakeLcmInterface  A pure virtual interface that enables LCM to be mocked 
CDrakeLcmLog  A LCM interface for logging LCM messages to a file or playing back from a existing log 
CDrakeLcmMessageHandlerInterface  Defines a message handler interface that must be implemented by all LCM subscribers within Drake 
CDrakeMockLcm  A mock LCM instance 
CLcmReceiveThread  Maintains a thread that receives LCM messages and dispatches the messages to the appropriate message handlers 
CTranslatorBase  Base API for a translator between arbitrary data of DataType and a Lcm message of MsgType 
►Nlogging  
Clogger  A stubbedout version of spdlog::logger 
►Nmaliput  
►Napi  
CBranchPoint  A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another 
CGeoPositionT  A position in 3dimensional geographical Cartesian space, i.e., in the world frame, consisting of three components x, y, and z 
CHBounds  Bounds in the elevation dimension (h component) of a Lane frame, consisting of a pair of minimum and maximum h value 
CIsoLaneVelocity  Isometric velocity vector in a Lane frame 
CJunction  A Junction is a closed set of Segments which have physically coplanar road surfaces, in the sense that RoadPositions with the same h value (height above surface) in the domains of two Segments map to the same GeoPosition 
CLane  A Lane represents a lane of travel in a road network 
►CLaneEnd  A specific endpoint of a specific Lane 
CStrictOrder  An arbitrary strict complete ordering, useful for, e.g., std::map 
CLaneEndSet  A set of LaneEnds 
CLanePositionT  A 3dimensional position in a Lane frame, consisting of three components: 
CRBounds  Bounds in the lateral dimension (r component) of a Lane frame, consisting of a pair of minimum and maximum r value 
CRoadGeometry  Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3space 
CRoadPosition  A position in the road network, consisting of a pointer to a specific Lane and a Lane frame position in that Lane 
CRotation  A 3dimensional rotation 
CSegment  A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface 
CTypeSpecificIdentifier  TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T 
►Ndragway  
CBranchPoint  Dragway's implementation of api::BranchPoint 
CJunction  Dragway's implementation of api::Junction 
CLane  Dragway's implementation of api::Lane 
CLaneEndSet  Dragway's implementation of api::LaneEndSet 
CRoadGeometry  Dragway's implementation of api::RoadGeometry 
CSegment  Dragway's implementation of api::Segment 
►Nmonolane  
CArcLane  Specialization of Lane with a circular arc as its reference curve in the xyplane (the ground plane) of the world frame 
CArcOffset  Specification for path offset along a circular arc 
CBranchPoint  An implementation of api::BranchPoint 
CBuilder  Convenient builder class which makes it easy to construct a monolane road network 
CConnection  Representation of a reference path connecting two endpoints 
CCubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
CEndpoint  Complete set of parameters for an endpoint of a connection, specified in the world frame 
CEndpointXy  XYplaneonly parameters for an endpoint of a connection, specified in the world frame 
CEndpointZ  Outofplane parameters for an endpoint of a connection, specified in the world frame 
CGroup  A group of Connections 
CJunction  An api::Junction implementation 
CLane  Base class for the monolane implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet 
CLineLane  Specialization of Lane with a line segment as its reference curve in the xyplane (the ground plane) of the world frame 
CRoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
CRot3  An R^3 rotation parameterized by roll, pitch, yaw 
CSegment  An api::Segment implementation 
►Nmultilane  
CArcOffset  Specification for path offset along a circular arc 
CArcRoadCurve  RoadCurve specification for a reference curve that describes a piece of an arc 
CBranchPoint  An implementation of api::BranchPoint 
CBuilder  Convenient builder class which makes it easy to construct a multilane road network 
CConnection  Representation of a reference path connecting two endpoints 
CCubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
CEndpoint  Complete set of parameters for an endpoint of a connection, specified in the world frame 
CEndpointXy  XYplaneonly parameters for an endpoint of a connection, specified in the world frame 
CEndpointZ  Outofplane parameters for an endpoint of a connection, specified in the world frame 
CGroup  A group of Connections 
CJunction  An api::Junction implementation 
CLane  Base class for the multilane implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet 
CLineRoadCurve  RoadCurve specification for a reference curve that describes a line 
CRoadCurve  Defines an interface for a path in a Segment object surface 
CRoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
CRot3  An R^3 rotation parameterized by roll, pitch, yaw 
CSegment  An api::Segment implementation 
►Nrndf  
CArcLengthParameterizedSpline  An extension for ignition::math::Splines that reparameterizes them by path length 
CBranchPoint  An implementation of api::BranchPoint for RNDF 
CBuilder  A class to ease the construction of a RoadGeometry from Connection and DirectedWaypoint objects 
CConnection  A container that holds the information needed by a Builder to construct one or more Lane objects 
CDirectedWaypoint  A container that holds the information needed by a Builder to construct a Lane from a sequence of ignition::rndf::Waypoint objects 
CInverseFunctionInterpolator  A linear interpolator for arbitrary inverse functions 
CJunction  An api::Junction implementation for RNDF 
CLane  Base class for the RNDF implementation of api::Lane 
CLaneEndSet  An implementation of LaneEndSet for RNDF 
CRoadCharacteristics  Holds common api::RoadGeometry characteristics needed to construct one 
CRoadGeometry  An api::RoadGeometry implementation for RNDF specification 
CSegment  An api::Segment implementation for RNDF 
CSplineLane  Specialization of drake::maliput::rndf::Lane with a spline curve as its reference path 
►Nutility  
CObjFeatures  Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults 
►Nmanipulation  
►Nperception  
COptitrackPoseExtractor  Extracts and provides an output of the pose of a desired object as an Eigen::Isometry3d from an Optitrack LCM OPTITRACK_FRAME_T message, the pose transformed to a desired coordinate frame 
CPoseSmoother  This class accepts the pose of a rigid body (composed by a Eigen::Isometry3d) and returns a smoothed pose by performing either the first or both of these processes : i 
►Nplanner  
►CConstraintRelaxingIk  A wrapper class around the IK planner 
CIkCartesianWaypoint  Cartesian waypoint 
CRobotPlanInterpolator  This class implements a source of joint positions for a robot 
►Nschunk_wsg  
CSchunkWsgController  This class implements a controller for a Schunk WSG gripper 
CSchunkWsgStatusSender  Sends lcmt_schunk_wsg_status messages for a Schunk WSG 
CSchunkWsgTrajectoryGenerator  Receives lcmt_schunk_wsg_command for a Schunk WSG (input port 0) along with the current state of the simulated WSG (input port 1), and emits target position/velocity for the actuated finger to reach the commanded target 
►Nsensors  
CXtion  Attaches an Asus Xtion PRO Live camera to a given frame on a RigidBodyTree, and provides the ability to add the camera as a system in a diagram builder 
►Nutil  
CFramePoseTracker  Implements a class that maintains pose and velocity information for a set of specified RigidBodyFrames 
CModelInstanceInfo  
CMovingAverageFilter  The implementation of a Moving Average Filter 
CSimDiagramBuilder  A wrapper class around DiagramBuilder that facilitates diagram building for controlled simulation 
CWorldSimTreeBuilder  A helper class to construct robot world RigidBodyTree objects from model (URDF/SDF) files 
CPiecewiseCartesianTrajectory  A wrapper class that represents a Cartesian trajectory, whose position part is a PiecewiseCubicTrajectory, and the rotation part is a PiecewiseQuaternionSlerp 
CPiecewiseCubicTrajectory  A wrapper class that stores a PiecewisePolynomial and its first and second derivatives 
CRobotStateLcmMessageTranslator  This is a utility class for converting bot_core::robot_state_t message to and from various eigen vectors that correspond to the generalized position, velocity and actuator torque 
CSimpleTreeVisualizer  A utility to render a RigidBodyTree in a specified configuration 
►Nmath  
►Ninternal  
CInitializeAutoDiffTupleHelper  Helper for initializeAutoDiffTuple function (recursive) 
CInitializeAutoDiffTupleHelper< 0 >  Helper for initializeAutoDiffTuple function (base case) 
CResizeDerivativesToMatchScalarImpl  
CResizeDerivativesToMatchScalarImpl< Derived, Eigen::AutoDiffScalar< DerivType > >  
CTotalSizeAtCompileTime  Helper for totalSizeAtCompileTime function (recursive) 
CTotalSizeAtCompileTime< Head >  Helper for totalSizeAtCompileTime function (base case) 
CAutoDiffToGradientMatrix  
CAutoDiffToValueMatrix  
CGetSubMatrixGradientArray  
CGetSubMatrixGradientSingleElement  
CGradient  
CGradient< Derived, Nq, 1 >  
CGrayCodesMatrix  GrayCodesMatrix::type returns an Eigen matrix of integers 
CGrayCodesMatrix< Eigen::Dynamic >  
CMatGradMult  
CMatGradMultMat  
►Nmultibody  
►Nbenchmarks  
►Nkuka_iiwa_robot  
►NMG  
CMGKukaIIwaRobot  This class is Drake's interface to the MotionGenesis solution for a 7DOF KUKA LBR iiwa robot (14 kg payload) which is described at: https://www.kuka.com/ende/products/robotsystems/industrialrobots/lbriiwa Geometry, jointtypes, and mass/inertia properties are contained in: drake/multibody/benchmarks/kuka_iiwa_robot/kuka_iiwa_robot.urdf 
CDrakeKukaIIwaRobot  This class is a MultibodyTree model for a 7DOF Kuka iiwa robot arm 
CKukaRobotJointReactionForces  Utility struct to assist with returning joint torques/forces 
CAcrobot  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
CMassDamperSpringAnalyticalSolution  This class provides an analytical solution to a massdamperspring system 
►Ncollision  
CBulletCollisionWorldWrapper  
CBulletModel  
CCollisionFilterGroup  The specification of a collision filter group: its name, bodies that belong to it, and the names of collision filter groups that it ignores 
CCollisionFilterGroupManager  This class provides management utilities for the definition of collision filter groups for RigidBodyTree instances 
CElement  The underyling primitive class used for collision analysis 
CFclModel  
CModel  Model is an abstract base class of a collision model 
COverlapFilterCallback  
CPointPair  Structure containing the results of a collision query 
CUnknownShapeException  
CUnusableModel  An unusable model, used when no collision detection backend is available 
►Nconstraint  
CConstraintAccelProblemData  Structure for holding constraint data for computing constraint forces at the accelerationlevel 
CConstraintSolver  Solves constraint problems for constraint forces 
CConstraintVelProblemData  Structure for holding constraint data for computing constraint forces at the velocitylevel (i.e., impact problems) 
►Ninternal  
CBodyNode  For internal use only of the MultibodyTree implementation 
CBodyNodeImpl  For internal use only of the MultibodyTree implementation 
CBodyNodeWelded  This class represents a BodyNode for nodes with zero degrees of freedom 
CJointImplementationBuilder  
►Nmultibody_tree  
►Ntest  
CFreeRotatingBodyPlant  This plant models the rotational motion of a torque free body in space 
►Ntest_utilities  
CSpatialKinematicsPVA  Utility class containing the transform and spatial velocity/acceleration of an arbitrary frame B in another arbitrary frame N (e.g., the world) 
►Nparsers  
►Nparsing  
CFrameCache  Keeps a set of frames and the transforms that relate them, using a root or fixed frame to conjoin them all 
CFramedIsometry3  An isometric transform along with the frame in which it is defined 
CSdfJoint  A representation of a <joint> element in an SDF file 
CSdfLink  A representation of a <link> element in an SDF file 
CSdfModel  This class provides a representation of a <model> element within a given SDF specification 
CSdfSpec  This class provides a representation for an SDF specification 
►Nrigid_body_plant  
►Ntest  
CAccelerationKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
CBody  Body provides the general abstraction of a body with an API that makes no assumption about whether a body is rigid or deformable and neither does it make any assumptions about the underlying physical model or approximation 
CBodyFrame  A BodyFrame is a material Frame that serves as the unique reference frame for a Body 
CBodyNodeTopology  Data structure to store the topological information associated with a tree node 
CBodyTopology  Data structure to store the topological information associated with a Body 
CFixedOffsetFrame  FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P 
CForceElement  A ForceElement allows modeling state and time dependent forces in a MultibodyTree model 
CForceElementTopology  Data structure to store the topological information associated with a ForceElement 
CFrame  Frame is an abstract class representing a material frame (also called a physical frame), meaning that it is associated with a material point of a Body 
CFrameBase  FrameBase is an abstract representation of the concept of a frame in multibody dynamics 
CFrameTopology  Data structure to store the topological information associated with a Frame 
CGlobalInverseKinematics  Solves the inverse kinematics problem as a mixed integer convex optimization problem 
►CJoint  A Joint models the kinematical relationship which characterizes the possible relative motion between two bodies 
CBluePrint  (Advanced) Structure containing all the information needed to build the MultibodyTree implementation for a Joint 
CJointImplementation  (Advanced) A Joint is implemented in terms of MultibodyTree elements such as bodies, mobilizers, force elements and constraints 
CKukaTest  
CMobilizer  Mobilizer is a fundamental object within Drake's multibody engine used to specify the allowed motions between two Frame objects within a MultibodyTree 
CMobilizerImpl  Base class for specific Mobilizer implementations with the number of generalized positions and velocities resolved at compile time as template parameters 
CMobilizerTopology  Data structure to store the topological information associated with a Mobilizer object 
CMultibodyForces  A class to hold a set of forces applied to a MultibodyTree system 
CMultibodyTree  MultibodyTree provides a representation for a physical system consisting of a collection of interconnected rigid and deformable bodies 
CMultibodyTreeContext  MultibodyTreeContext is an object that contains all the information needed to uniquely determine the state of a MultibodyTree 
CMultibodyTreeElement< ElementType< T >, ElementIndexType >  A class representing an element or component of a MultibodyTree 
CMultibodyTreeTopology  Data structure to store the topological information associated with an entire MultibodyTree 
CPositionKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
CRevoluteJoint  This Joint allows two bodies to rotate relatively to one another around a common axis 
CRevoluteMobilizer  This Mobilizer allows two frames to rotate relatively to one another around an axis that is constant when measured in either this mobilizer's inboard or outboard frames, while the distance between the two frames does not vary 
CRigidBody  The term rigid body implies that the deformations of the body under consideration are so small that they have no significant effect on the overall motions of the body and therefore deformations can be neglected 
CRotationalInertia  This class helps describe the mass distribution (inertia properties) of a body or composite body about a particular point 
CRotationMatrix  This class represents a 3x3 rotation matrix between two arbitrary frames A and B and helps ensure users create valid rotation matrices 
CSpaceXYZMobilizer  This mobilizer models a gimbal joint between an inboard frame F and an outboard frame M that allows frame M to rotate freely with respect to F ( though a gimbal joint provides arbitrary orientation like a ball joint but with some restrictions, discussed below) 
CSpatialAcceleration  This class is used to represent a spatial acceleration that combines rotational (angular acceleration) and translational (linear acceleration) components 
CSpatialForce  This class is used to represent a spatial force (also called a wrench) that combines both rotational (torque) and translational force components 
CSpatialInertia  This class represents the physical concept of a Spatial Inertia 
CSpatialVector  This class is used to represent physical quantities that correspond to spatial vectors such as spatial velocities, spatial accelerations and spatial forces 
CSpatialVelocity  This class is used to represent a spatial velocity (also called a twist) that combines rotational (angular) and translational (linear) velocity components 
CTransform  This class represents a rigid transform between two frames, which can be regarded in two ways 
CUniformGravityFieldElement  This ForceElement allows modeling the effect of a uniform gravity field as felt by bodies on the surface of the Earth 
CUnitInertia  This class is used to represent rotational inertias for unit mass bodies 
CVelocityKinematicsCache  This class is one of the cache entries in MultibodyTreeContext 
►Nparsers  
CFloatingJointConstants  Defines constants used by AddFloatingJoint() 
CPackageMap  Maps ROS package names to their full path on the local file system 
►Nperception  
►Nestimators  
CArticulatedBodyInfluence  Description on how the optimization affects a body 
CArticulatedIcpBodyPoints  Contains a group of points to be rendered in a linearized ICP cost 
CArticulatedIcpErrorCost  Accumulate errors and render the cost into an appropriate format 
CArticulatedIcpErrorNormCost  Aggregate L2 norm cost of pointtopoint error set 
CArticulatedIcpErrorSet  A set of Cartesian errors and their gradients: {(eᵢ, Jᵢ)}ᵢ₌₁..ₙ 
CArticulatedIcpLinearizedNormCost  Accumulate the L2 norm of the linearized pointtopoint errors to be rendered into a QuadraticCost operating on variables q :  eᵢ + Jᵢ (q  q0) ^2 where eᵢ is the ith 3x1 error in Cartesian space, Jᵢ is the 3 x nq Jacobian of this error 
CBounds  
CInterval  
CIntervalIndex  
CObjectTestSetup  
CPlaneIndices  
CPointCloudVisualizer  
CPointCorrespondence  Simple pointtopoint correspondence 
CScene  A scene describes a group of objects (stored within a rigid body tree structure), the world frame, and the camera frame 
CSceneState  Stored state of a scene 
►Npc_flags  Point cloud flags 
CDescriptorType  Describes an descriptor field with a name and the descriptor's size 
CFields  Allows combination of BaseField and DescriptorType for a PointCloud 
CFeedforwardNeuralNetwork  
CNeuralNetwork  Base class for different kinds of neural network 
CPointCloud  Implements a point cloud (with contiguous storage), whose main goal is to offer a convenient, synchronized interface to commonly used fields and data types applicable for basic 3D perception 
►Npydrake  
►Nsolvers  
►Ndetail  
Cassert_if_is_constraint  Template condition to only catch when Constraints are inadvertently passed as an argument 
CFunctionTraits  FunctionTraits 
CFunctionTraits< std::reference_wrapper< F > >  
CFunctionTraits< std::shared_ptr< F > >  
CFunctionTraits< std::unique_ptr< F > >  
Cis_binding_compatible  Enables us to catch and provide a meaningful assertion if a Constraint is passed in, when we should have a Cost 
Cis_convertible_workaround  
Cis_convertible_workaround< std::unique_ptr< A >, std::shared_ptr< B > >  
Cis_cost_functor_candidate  Template condition to check if F is a candidate to be used to construct a FunctionCost object for generic costs 
►Ninternal  
CSymbolicError  
►Ntest  
CConvexCubicProgramExample  A simple convex optimization program min 12 * x + x³ s.t x >= 0 Notice the objective function is convex in the feasible region x >= 0 The optimal solution is x = 2 
CGenericTrivialConstraint1  
CGenericTrivialCost1  
CGenericTrivialCost2  
CGloptiPolyConstrainedMinimizationProblem  GloptiPolyConstrainedMinimization 
CInfeasibleLinearProgramTest0  An infeasible linear program 
CLinearFeasibilityProgram  Test a simple linear programming problem with zero cost, i.e 
CLinearMatrixEqualityExample  For a stable linear system ẋ = A x, find its Lyapunov function by solving the Lyapunov equality on the symmetric matrix X Aᵀ * X + X * A = E 
CLinearProgram0  Adapt from the linear programming example http://cvxopt.org/examples/tutorial/lp.html Solve the following linear program min 2x0 + x1 s.t inf <= x0 + x1 <= 1 2 <= x0 + x1 <=inf inf <= x0  2x1 <= 4 x1 >= 2 x0 >= 0 The optimal solution is x0 = 1, x1 = 2 
CLinearProgram1  
CLinearProgram2  
CLinearProgram3  
CLinearProgramTest  
CLinearSystemExample1  Simple example x = b 
CLinearSystemExample2  Simple linear system x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
CLinearSystemExample3  Simple linear system 3 * x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
CLowerBoundedProblem  This test comes from Section 3.4 of Handbook of Test Problems in Local and Global Optimization 
CMinDistanceFromPlaneToOrigin  An SOCP with Lorentz cone and rotated Lorentz cone constraints 
CNonConvexQPproblem1  This test comes from Section 2.2 of Handbook of Test Problems in Local and Global Optimization 
CNonConvexQPproblem2  This test comes from Section 2.3 of Handbook of Test Problems in Local and Global Optimization 
COptimizationProgram  
CQuadraticProgram0  
CQuadraticProgram1  Adapt from the simple test on the Gurobi documentation 
CQuadraticProgram2  
CQuadraticProgram3  
CQuadraticProgram4  
CQuadraticProgramTest  
CTestEllipsoidsSeparation  This test is taken from the course notes of EE127A from University of California, Berkeley The goal is to find a hyperplane, that separates two ellipsoids E₁ = x₁ + R₁ * u₁, u₁ ≤ 1 E₂ = x₂ + R₂ * u₂, u₂ ≤ 1 A hyperplane aᵀ * x = b separates these two ellipsoids, if and only if for SOCP p* = min t₁ + t₂ s.t t₁ ≥ R₁ᵀ * a t₂ ≥ R₂ᵀ * a aᵀ(x₂x₁) = 1 the optimal solution p* is no larger than 1 
CTestFindSpringEquilibrium  
CTestQPasSOCP  This example is taken from the course notes of EE127A from University of California, Berkeley For a quadratic program 0.5 * x' * Q * x + c' * x s.t b_lb <= A * x <= b_ub It can be casted as an SOCP, as follows By introducing a new variable w = Q^{1/2}*x and y, z The equivalent SOCP is min c'x + y s.t 2 * y >= w' * w w = Q^{1/2} * x b_lb <= A * x <= b_ub 
CUnboundedLinearProgramTest0  An unbounded linear program 
CAddRotationMatrixBilinearMcCormickMilpConstraintsReturn  The return types from AddRotationMatrixBilinearMcComickMilpConstraints 
CBinding  A binding on constraint type C is a mapping of the decision variables onto the inputs of C 
CBoundingBoxConstraint  Implements a constraint of the form lb <= x <= ub 
CConstraint  A constraint is a function + lower and upper bounds 
CCost  Provides an abstract base for all costs 
CDrealSolver  
CEqualityConstrainedQPSolver  
CEvaluatorBase  Provides an abstract interface to represent an expression, mapping a fixed or dynamic number of inputs to a fixed number of outputs, that may be evaluated on a scalar type of double or AutoDiffXd 
CEvaluatorConstraint  A constraint that may be specified using another (potentially nonlinear) evaluator 
CEvaluatorCost  A cost that may be specified using another (potentially nonlinear) evaluator 
CFunctionEvaluator  An evaluator that may be specified using a callable object 
►CGurobiSolver  
CSolveStatusInfo  Contains info returned to a user function that handles a Node or Solution callback 
CIpoptSolver  
CLinearComplementarityConstraint  Implements a constraint of the form: 
CLinearConstraint  Implements a constraint of the form lb <= Ax <= ub 
CLinearCost  Implements a cost of the form a'x + b 
CLinearEqualityConstraint  Implements a constraint of the form Ax = b 
CLinearMatrixInequalityConstraint  Impose the matrix inequality constraint on variable x \[ F_0 + x_1 F_1 + ... + x_n F_n \text{ is p.s.d} \] where p.s.d stands for positive semidefinite 
CLinearSystemSolver  
CLogarithmicSos2NewBinaryVariables  The size of the new binary variables in the compile time, for Special Ordered Set of type 2 (SOS2) constraint 
CLogarithmicSos2NewBinaryVariables< Eigen::Dynamic >  
CLorentzConeConstraint  Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone 
►CMathematicalProgram  
CSolverData  
CMathematicalProgramSolverInterface  Interface used by implementations of individual solvers 
CMobyLCPSolver  A class for solving Linear Complementarity Problems (LCPs) 
CMobyLcpSolverId  Nontemplate class for MobyLcpSolver<T> constants 
CMosekSolver  
CNewSymmetricVariableNames  
CNewVariableNames  
CNewVariableNames< Eigen::Dynamic >  
CNewVariableNames< Rows, Cols >  
CNewVariableNames< Size >  The type of the names for the newly added variables 
CNloptSolver  
CPolynomialConstraint  Lb[i] <= Pi <= ub[i], where each P[i] is a multivariate polynomial in x, y.. 
CPolynomialCost  Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y, .. 
CPolynomialEvaluator  Implements an evaluator of the form P(x, y...) where P is a multivariate polynomial in x, y, .. 
CPositiveSemidefiniteConstraint  Implements a positive semidefinite constraint on a symmetric matrix S \[\text{ S is p.s.d }\] namely, all eigen values of S are nonnegative 
CQuadraticConstraint  Lb <= .5 x'Qx + b'x <= ub Without loss of generality, the class stores a symmetric matrix Q 
CQuadraticCost  Implements a cost of the form .5 x'Qx + b'x + c 
CRotatedLorentzConeConstraint  Constraining that the linear expression \( z=Ax+b \) lies within rotated Lorentz cone 
CScsSolver  
CSnoptSolver  
CSolverId  Identifies a MathematicalProgramSolverInterface implementation 
CSolverTypeConverter  Converts between SolverType and SolverId 
►CSystemIdentification  Utility functions for system identification 
CSystemIdentificationResult  A helper struct to hold System ID results 
►Nsymbolic  
►Ndetail  
CRelationalOpTraits  Provides a return type of relational operations (=, ≠, ≤, <, ≥, >) between Eigen::Array s 
CBinaryExpressionCell  Represents the base class for binary expressions 
CEnvironment  Represents a symbolic environment (mapping from a variable to a value) 
CExpression  Represents a symbolic form of an expression 
CExpressionAbs  Symbolic expression representing absolute value function 
CExpressionAcos  Symbolic expression representing arccosine function 
CExpressionAdd  Symbolic expression representing an addition which is a sum of products 
CExpressionAddFactory  Factory class to help build ExpressionAdd expressions 
CExpressionAsin  Symbolic expression representing arcsine function 
CExpressionAtan  Symbolic expression representing arctangent function 
CExpressionAtan2  Symbolic expression representing atan2 function (arctangent function with two arguments) 
CExpressionCeiling  Symbolic expression representing ceil function 
CExpressionCell  Represents an abstract class which is the base of concrete symbolicexpression classes 
CExpressionConstant  Symbolic expression representing a constant 
CExpressionCos  Symbolic expression representing cosine function 
CExpressionCosh  Symbolic expression representing hyperbolic cosine function 
CExpressionDiv  Symbolic expression representing division 
CExpressionExp  Symbolic expression representing exponentiation using the base of natural logarithms 
CExpressionFloor  Symbolic expression representing floor function 
CExpressionIfThenElse  Symbolic expression representing ifthenelse expression 
CExpressionLog  Symbolic expression representing logarithms 
CExpressionMax  Symbolic expression representing max function 
CExpressionMin  Symbolic expression representing min function 
CExpressionMul  Symbolic expression representing a multiplication of powers 
CExpressionMulFactory  Factory class to help build ExpressionMul expressions 
CExpressionNaN  Symbolic expression representing NaN (notanumber) 
CExpressionPow  Symbolic expression representing power function 
CExpressionSin  Symbolic expression representing sine function 
CExpressionSinh  Symbolic expression representing hyperbolic sine function 
CExpressionSqrt  Symbolic expression representing squareroot 
CExpressionTan  Symbolic expression representing tangent function 
CExpressionTanh  Symbolic expression representing hyperbolic tangent function 
CExpressionUninterpretedFunction  Symbolic expression representing an uninterpreted function 
CExpressionVar  Symbolic expression representing a variable 
CFormula  Represents a symbolic form of a firstorder logic formula 
CFormulaAnd  Symbolic formula representing conjunctions (f1 ∧ .. 
CFormulaCell  Represents an abstract class which is the base of concrete symbolicformula classes (i.e 
CFormulaEq  Symbolic formula representing equality (e1 = e2) 
CFormulaFalse  Symbolic formula representing false 
CFormulaForall  Symbolic formula representing universal quantifications (∀ x₁, ..., * xn 
CFormulaGeq  Symbolic formula representing 'greaterthanorequalto' (e1 ≥ e2) 
CFormulaGt  Symbolic formula representing 'greaterthan' (e1 > e2) 
CFormulaIsnan  Symbolic formula representing isnan predicate 
CFormulaLeq  Symbolic formula representing 'lessthanorequalto' (e1 ≤ e2) 
CFormulaLt  Symbolic formula representing 'lessthan' (e1 < e2) 
CFormulaNeq  Symbolic formula representing disequality (e1 ≠ e2) 
CFormulaNot  Symbolic formula representing negations (¬f) 
CFormulaOr  Symbolic formula representing disjunctions (f1 ∨ .. 
CFormulaPositiveSemidefinite  Symbolic formula representing positivesemidefinite (PSD) constraint 
CFormulaTrue  Symbolic formula representing true 
CFormulaVar  Symbolic formula representing a Boolean variable 
CGradedReverseLexOrder  Implements Graded reverse lexicographic order 
CMonomial  Represents a monomial, a product of powers of variables with nonnegative integer exponents 
CNaryFormulaCell  Represents the base class for Nary logic operators (∧ and ∨) 
CPolynomial  Represents symbolic polynomials 
CRelationalFormulaCell  Represents the base class for relational operators (==, !=, <, <=, >, >=) 
CUnaryExpressionCell  Represents the base class for unary expressions 
CVariable  Represents a symbolic variable 
CVariables  Represents a set of variables 
►Nsystems  
►Nanalysis  
►Ntest  
CRobertsonSystem  Robertson's stiff chemical reaction problem 
CStiffDoubleMassSpringSystem  A coupled, mass spring system taken from the SD/FAST user's manual 
►Nanalysis_test  
CClockWitness  Witness function for determining when the time of the empty system crosses zero 
CExplicitErrorControlledIntegratorTest  
CLogisticSystem  System with state evolution yielding a logistic function, for purposes of witness function testing using the differential equation dx/dt = α⋅(1  (x/k)^ν)⋅t, where ν > 0 (affects the shape of the curve), α > 0 (growth rate), and k is the upper asymptote 
CLogisticWitness  Witness function for determining when the state of the logistic system crosses zero 
CMySpringMassSystem  
CStatelessSystem  System with no state for testing a simplistic witness function 
►Ncontrollers  
►Nplan_eval  
CGenericPlan  This class represents a plan interpretor, which conceptually serves as a bridge between a high level planner (e.g 
CGenericPlanTest  
CManipulatorMoveEndEffectorPlan  A concrete plan that sets up a Cartesian tracking objective for the end effector assuming no contacts 
CPlanEvalBaseSystem  A base class that outputs QpInput for the qp inverse dynamics controller 
►Nqp_inverse_dynamics  
CBodyAcceleration  This class holds spatial acceleration for a rigid body 
CConstrainedValues  Base class for specifying various desired objectives 
CContactInformation  This class describes contact related information for each body in contact with other bodies in the world 
CContactParam  A struct for holding contactrelated parameters such as local offsets of the contact points, friction coefficient, etc 
CDesiredBodyMotion  A wrapper class specifying desired body motion (acceleration) for a rigid body and their corresponding weights for the QP 
CDesiredCentroidalMomentumDot  A wrapper class specifying desired centroidal momentum change and their corresponding weights for the QP 
CDesiredDofMotions  A wrapper class specifying desired DoF (degree of freedom) motions (acceleration) and their corresponding weights for the QP 
CDesiredMotionParam  Struct for storing parameters for generating a desired acceleration objective \( \dot{v}_d \) for the QP inverse dynamics controller 
CParamSet  A class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller 
CQpInput  Input to the QP inverse dynamics controller 
CQpInverseDynamics  
CQpInverseDynamicsSystem  A discrete time system block for an inverse dynamics controller 
CQpOutput  Output of the QP inverse dynamics controller 
CQpOutputTranslatorSystem  An abstract base class that translates a QpOutput to a vector of torque commands in the actuator order within the RigidBodyTree 
CResolvedContact  This class holds contact force related information, and works closely with ContactInformation 
CRobotKinematicState  A wrapper class around KinematicsCache and several useful matrices such as the inertia matrix, etc 
CRobotKinematicStateTranslatorSystem  Provides transformation from a state vector to RobotKinematicState 
CCartesianSetpoint  This is used to compute target spatial acceleration, which is the input to the inverse dynamics controller 
CInverseDynamics  Solves inverse dynamics with no consideration for external wrenches, under actuation, joint torque limits or closed kinematic chains 
CInverseDynamicsController  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
CLinearModelPredictiveController  Implements a basic Model Predictive Controller that linearizes the system about an equilibrium condition and regulates to the same point by solving an optimal control problem over a finite time horizon 
CLinearQuadraticRegulatorResult  
►CPidControlledSystem  A system that encapsulates a PidController and a controlled System (a.k.a the "plant") 
CConnectResult  The return type of ConnectController 
CPidController  Implements the PID controller 
CStateFeedbackControllerInterface  Interface for state feedback controllers 
CVectorSetpoint  
CZMPPlanner  Given a desired two dimensional (X and Y) zeromoment point (ZMP) trajectory parametrized as a piecewise polynomial, an optimal center of mass (CoM) trajectory is planned using a linear inverted pendulum model (LIPM) 
CZMPTestTraj  A structure for storing trajectories from simulating a linear inverted pendulum model (LIPM) using the policy from a ZMPPlanner 
►Ndetail  
CInputPortEvaluatorInterface  InputPortEvaluatorInterface is implemented by classes that are able to evaluate the OutputPortValue connected to a particular InputPortValue 
CModelValues  Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) 
COutputPortListenerInterface  OutputPortListenerInterface is an interface that consumers of an output port must satisfy to receive notifications when the value of that output port may have changed 
►Nestimators  
CLuenbergerObserver  A simple state observer for a dynamical system of the form: \[\dot{x} = f(x,u) \] \[y = g(x,u) \] the observer dynamics takes the form \[\dot{\hat{x}} = f(\hat{x},u) + L(y  g(\hat{x},u)) \] where \(\hat{x}\) is the estimated state of the original system 
►Nimplicit_integrator_test  
CDiscontinuousSpringMassDamperSystem  
CSpringMassDamperSystem  
►Ninternal  
CCacheEntry  A single cached piece of data, its validity bit, and the set of other cache entries that depend on it 
CDiagramDiscreteVariables  DiagramDiscreteVariables is a version of DiscreteState that owns the constituent discrete states 
CDiagramOutput  DiagramOutput is an implementation of SystemOutput that holds unowned OutputPortValue pointers 
CDiagramOutputPort  Holds information about the subsystem output port that has been exported to become one of this Diagram's output ports 
CDiagramTimeDerivatives  DiagramTimeDerivatives is a version of DiagramContinuousState that owns the constituent continuous states 
CRandomSource  A source block which generates random numbers at a fixed sampling interval, with a zeroorder hold between samples 
CRandomState  State for a given random distribution and generator 
►Nlcm  
CDataTypeTraits< DataType, false >  
CLcmAndVectorBaseTranslator  Defines an abstract parent class of all translators that convert between LCM message bytes and drake::systems::VectorBase objects 
CLcmDrivenLoop  This class implements a loop that's driven by a Lcm message 
CLcmMessageToTimeInterface  A generic translator interface that extracts time in seconds from an abstract type 
CLcmPublisherSystem  Publishes an LCM message containing information from its input port 
CLcmSubscriberSystem  Receives LCM messages from a given channel and outputs them to a System<double>'s port 
CLcmtDrakeSignalTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_drake_signal 
CLcmTranslatorDictionary  A dictionary that maps between LCM channel names and translators that convert between LCM message objects and VectorBase objects 
CSerializer  Serializer is specific to a single LcmMessage type, and translates between LCM message bytes and drake::systems::Value<LcmMessage> objects 
CSerializerInterface  SerializerInterface translates between LCM message bytes and drake::systems::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal> 
CUtimeMessageToSeconds  A translator class for Lcm message types that have a "utime" field, which is in micro seconds 
►Nplants  
►Nrigid_body_plant  
►Ntest  
CContactResultTestCommon  
►Ntest  
CIKTrajectoryHelper  This class is a helper for backend implementations of inverse kinematics trajectory planning 
CKinematicsCacheHelper  Helper class to avoid recalculating a kinematics cache which is going to be used repeatedly by multiple other classes 
CQuasiStaticConstraintWrapper  
CSingleTimeKinematicConstraintWrapper  
►Nrendering  
CFrameVelocity  A 6vector representing the derivatives of the position transform of frame A in the world frame, Xdot_WA, in the form {R_WA, p_WA} , where p is the derivatives of xyz translation, and R is the derivatives of xyz rotation 
CPoseAggregator  PoseAggregator is a multiplexer for heterogeneous sources of poses and the velocities of those poses 
CPoseBundle  PoseBundle is a container for a set of poses, represented by an Isometry3, and corresponding velocities, represented by a FrameVelocity 
CPoseBundleToDrawMessage  PoseBundleToDrawMessage converts a PoseBundle on its single abstractvalued input port to a Drake Visualizer Interface LCM draw message, lcmt_viewer_draw, on its single abstractvalued output port 
CPoseStampedTPoseVectorTranslator  The translator that converts from/to rendering::PoseVector<double> to/from lcm message bytes which encodes robotlocomotion::pose_stamped_t 
CPoseVector  A 7vector representing the transform of frame A in the world frame, X_WA, in the form {p_WA, R_WA} , where p is represented as an xyz translation, and R is represented as a quaternion 
►Nscalar_conversion  
CFromDoubleTraits  A concrete traits class providing sugar to support for converting only from the double scalar type 
CNonSymbolicTraits  A concrete traits class providing sugar to disable support for symbolic evaluation (i.e., the symbolic::Expression scalar type) 
CTraits  A templated traits class for whether an S<T> can be converted into an S<U>; the default value is true for all values of S, T, and U 
CTraits< automotive::IdmController >  
CTraits< automotive::PurePursuitController >  
CTraits< automotive::TrajectoryCar >  
CTraits< drake::examples::multibody::pendulum::PendulumPlant >  
CTraits< geometry::GeometrySystem >  
CTraits< perception::FeedforwardNeuralNetwork >  
CTraits< PiecewisePolynomialAffineSystem >  
CTraits< PiecewisePolynomialLinearSystem >  
►Nsensors  
►Ntest  
CRgbdRendererTest  
CScreenCoord  
CAccelerometer  A simulated ideal accelerometer that measures the linear acceleration of a frame associated with a RigidBodyPlant 
CAccelerometerExampleDiagram  Implements the Diagram shown below, which demonstrates how an accelerometer can be used 
CAccelerometerOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Accelerometer's output 
CAccelerometerOutputConstants  
CAccelerometerXdotHack  Implements a system with one input port and one output port, both vector valued 
CBeamModel  Implements the "Beam Models of Range Finders" from section 6.3 of Probabilistic Robotics (2006), by Thrun, Burgard, and Fox 
CCameraInfo  Simple data structure for camera information that includes the image size and camera intrinsic parameters 
CColor  Holds r, g, b values to represent a color pixel 
CColorPalette  Creates and holds a palette of colors for visualizing different objects in a scene (the intent is for a different color to be applied to each identified object) 
CDepthSensor  A simple model of an ideal depth sensor 
CDepthSensorOutput  Specializes BasicVector with specific getters and setters that are useful for consumers of DepthSensor's output 
CDepthSensorSpecification  Holds a DepthSensor's specification 
CDepthSensorToLcmPointCloudMessage  A DepthSensorToLcmPointCloudMessage takes as input a DepthSensorOutput and the pose of the depth sensor in the world (X_WS ) 
CGyroscope  A simulated ideal gyroscope 
CGyroscopeOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Gyroscope's output 
CGyroscopeOutputConstants  Defines the semantics of each index in GyroscopeOutput's vector 
CImage  Simple data format for Image 
CImageToLcmImageArrayT  An ImageToLcmImageArrayT takes as input an ImageRgba8U, ImageDepth32F and ImageLabel16I 
CImageTraits  Traits class for Image 
CImageTraits< PixelType::kBgr8U >  
CImageTraits< PixelType::kBgra8U >  
CImageTraits< PixelType::kDepth16U >  
CImageTraits< PixelType::kDepth32F >  
CImageTraits< PixelType::kGrey8U >  
CImageTraits< PixelType::kLabel16I >  
CImageTraits< PixelType::kRgb8U >  
CImageTraits< PixelType::kRgba8U >  
CInvalidDepth  Set of constants used to represent invalid depth values 
CLabel  Set of labels used for label image 
COptitrackEncoder  Implements a class that allows a simulation to mock the basic output of the Optitrack system 
COptitrackLCMFrameSender  The system has one abstractvalued input port and one abstractvalued output port 
CRenderingConfig  Common configurations of rendering systems 
CRgbdCamera  An RGBD camera system that provides RGB, depth and label images using visual elements of RigidBodyTree 
CRgbdCameraDiscrete  Wraps a continuous RgbdCamera with zero order holds to have it function as a discrete sensor 
CRgbdRenderer  Abstract interface of RGBD renderers, which render RGB, depth and label images using VisualElement 
CRgbdRendererVTK  An RgbdRenderer implementation using VTK 
CRotaryEncoders  Simple model to capture the quantization and calibration offset effects of a rotary encoder 
CTrackedBody  A structure used to store the attributes of a tracked rigid body 
►Ntest  
CMatrixData  
►Ntrajectory_optimization  
CDirectCollocation  DirectCollocation implements the approach to trajectory optimization as described in C 
CDirectTranscription  DirectTranscription is perhaps the simplest implementation of a multiple shooting method, where we have decision variables representing the control and input at every sample time in the trajectory, and onestep of numerical integration provides the dynamic constraints between those decision variables 
CMultipleShooting  MultipleShooting is an abstract class for trajectory optimization that creates decision variables for inputs, states, and (optionally) sample times along the trajectory, then provides a number of methods for working with those decision variables 
CAbstractValue  A fully typeerased container class 
CAbstractValues  AbstractValues is a container for nonnumerical state and parameters 
CAccelerometerTestLogger  A sink block that logs the most recent plant state and the accelerometer reading 
CActuatorEffortToRigidBodyPlantInputConverter  
CAdder  An adder for arbitrarily many inputs of equal size 
CAffineLinearSystemTest  
CAffineSystem  A discrete OR continuous affine system (with constant coefficients) 
CBasicVector  BasicVector is a semanticsfree wrapper around an Eigen vector that satisfies VectorBase 
CCache  Cache is a keyvalue store used within the System2 framework to avoid computing intermediate data multiple times during simulation or analysis 
CCompliantContactModel  This class encapsulates the compliant contact model force computations as described in detail in Compliant Contact in Drake 
CCompliantContactModelParameters  The set of parameters for the compliant contact model 
CCompliantMaterial  The set of perobject compliant material parameters with one material applied to each collision object 
CCompositeEventCollection  This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection 
CConstantValueSource  A source block that always outputs a constant value 
CConstantVectorSource  A source block with a constant output port at all times 
CContactDetail  The base class for defining a contact detail 
CContactForce  The data for a single contact force applied to one body of a contacting pair 
CContactInfo  A class containing information regarding contact response between two bodies including: 
CContactResultantForceCalculator  This is a utility class for replacing a set of force/torques by an equivalent force/torque (defined by the ContactForce class) 
CContactResults  A class containg the contact results (contact points and response spatial forces for each colliding pair of collision elements) 
CContactResultsToLcmSystem  A System that encodes ContactResults into a lcmt_contact_results_for_viz message 
CContext  Context is an abstract base class template that represents all the inputs to a System: time, state, and input vectors 
CContinuousState  ContinuousState is a container for all the continuous state variables xc 
CDemultiplexer  This system splits a vector valued signal on its input into multiple outputs 
CDependentInputPortValue  A DependentInputPortValue wraps a pointer to an OutputPortValue associated with one System for use as an input to another System 
CDiagram  Diagram is a System composed of one or more constituent Systems, arranged in a directed graph where the vertices are the constituent Systems themselves, and the edges connect the output of one constituent System to the input of another 
CDiagramBuilder  DiagramBuilder is a factory class for Diagram 
CDiagramCompositeEventCollection  CompositeEventCollection for a Diagram 
CDiagramContext  The DiagramContext is a container for all of the data necessary to uniquely determine the computations performed by a Diagram 
CDiagramContinuousState  DiagramContinuousState is a ContinuousState consisting of Supervectors over a set of constituent ContinuousStates 
CDiagramEventCollection  A concrete class that holds all simultaneous homogeneous events for a Diagram 
CDiagramState  DiagramState is a State, annotated with pointers to all the mutable substates that it spans 
CDiscreteUpdateEvent  This class represents a discrete update event 
CDiscreteValues  DiscreteValues is a container for numerical but noncontinuous state and parameters 
CDrakeVisualizer  This is a Drake System block that takes a RigidBodyTree and publishes LCM messages that are intended for the DrakeVisualizer 
►CEvent  Abstract base class that represents an event 
CPeriodicAttribute  A token describing an event that recurs on a fixed period 
CEventCollection  There are three concrete event types for any System: publish, discrete state update, and unrestricted state update, listed in order of increasing ability to change the state (i.e., zero to all) 
CExplicitEulerIntegrator  A firstorder, explicit Euler integrator 
CFirstOrderLowPassFilter  An elementwise first order low pass filter system that filters the ith input uᵢ into the ith output zᵢ 
CFrameVisualizer  This is a Drake System block that takes in a state vector, and outputs a drake::lcmt_viewer_draw message that contains information about the frames for visualization 
CFreestandingInputPortValue  A FreestandingInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports 
CGain  An elementwise gain block with input u and output y = k * u with k a constant vector 
CImplicitEulerIntegrator  A firstorder, fully implicit integrator with second order error estimation 
CInputPortDescriptor  InputPortDescriptor is a notation for specifying the kind of input a System accepts, on a given port 
CInputPortValue  InputPortValue identifies the value source for a single System input port 
CIntegrator  An integrator for a continuous vector input 
CIntegratorBase  An abstract class for an integrator for ODEs and DAEs as represented by a Drake System 
CKinematicsResults  A class containing the kinematics results from a RigidBodyPlant system 
CLcmDecoderSystem  A decoding system that converts a Lcm message of MsgTypedata to data of DataType 
CLcmEncoderSystem  An encoding system that converts data of DataType to a Lcm message of MsgType 
CLeafCompositeEventCollection  A CompositeEventCollection for a LeafSystem 
CLeafContext  LeafContext is a container for all of the data necessary to uniquely determine the computations performed by a leaf System 
CLeafEventCollection  A concrete class that holds all simultaneous homogeneous events for a LeafSystem 
CLeafOutputPort  Adds methods for allocation, calculation, and caching of an output port's value 
CLeafSystem  A superclass template that extends System with some convenience utilities that are not applicable to Diagrams 
CLeafSystemOutput  A container for the values of all output ports of a leaf System 
CLinearSystem  A discrete OR continuous linear system 
CLinearTimeVaryingData  Stores matrix data necessary to construct a linear time varying system as a piecewise polynomial trajectory 
CMatrixGain  A system that specializes LinearSystem by setting coefficient matrices A , B , and C to all be zero 
CMultiplexer  This system combines multiple vectorvalued inputs into a vectorvalued output 
CMyVector  A simple subclass of BasicVector<T> for testing, particularly for cases where BasicVector subtyping must be preserved through the framework 
COutputPort  An OutputPort belongs to a System and represents the properties of one of that System's output ports 
COutputPortValue  OutputPortValue contains the value of a single System output port 
CParameters  Parameters is a container for variables that parameterize a System so that it can represent a family of related models 
CPassThrough  A pass through system with input u and output y = u 
CPeriodicAttributeComparator  Structure for comparing two PeriodicAttributes for use in a map container, using an arbitrary comparison method 
CPidControlledSpringMassSystem  A model of a onedimensional springmass system controlled to achieve a given target position using a PID controller 
CPiecewisePolynomialAffineSystem  A continuous or discretetime Affine TimeVarying system described by a piecewise polynomial trajectory of system matrices 
CPiecewisePolynomialLinearSystem  A continuous or discretetime Linear TimeVarying system described by a piecewise polynomial trajectory of system matrices 
CPointContactDetail  An implementation of the ContactDetail where the contact details consist of a single ContactForce 
CPublishEvent  This class represents a publish event 
CRigidBodyPlant  This class provides a System interface around a multibody dynamics model of the world represented by a RigidBodyTree 
CRigidBodyPlantThatPublishesXdot  This is a child class of RigidBodyPlant that publishes xdot , time derivative of RBPlant's state vector x , on an LCM channel encoded as an lcmt_drake_signal message 
CRobotCommandToDesiredEffortConverter  Converts an atlas_command_t message into desired efforts, presented on one output port per actuator 
CRobotStateDecoder  Converts a robot_state_t LCM message into a KinematicsCache object 
CRobotStateEncoder  Assembles information from various input ports into a robot_state_t LCM message, presented on an output port 
CRungeKutta2Integrator  A secondorder, explicit Runge Kutta integrator 
CRungeKutta3Integrator  A thirdorder Runge Kutta integrator with a third order error estimate 
CSaturation  An elementwise hard saturation block with inputs signal u , saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: 
CSemiExplicitEulerIntegrator  A firstorder, semiexplicit Euler integrator 
CSignalLog  This class serves as an inmemory cache of timedependent vector values 
CSignalLogger  A sink block which logs its input to memory 
CSimulator  A forward dynamics solver for hybrid dynamic systems represented by System<T> objects 
CSine  A sine system which outputs y = a * sin(f * t + p) and first and second derivatives w.r.t 
CSingleOutputVectorSource  A base class that specializes LeafSystem for use with no input ports, and only a single, vector output port 
CSpringMassStateVector  The state of a onedimensional springmass system, consisting of the position and velocity of the mass, in meters and meters/s 
CSpringMassSystem  A model of a onedimensional springmass system 
CState  State is a container for all the data comprising the complete state of a particular System at a particular moment 
CStepInfo  Contains information about the independent variable including time and step number 
CSubvector  Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase 
CSupervector  Supervector is a concrete class template that implements VectorBase by concatenating multiple VectorBases, which it does not own 
CSystem  A superclass template for systems that receive input, maintain state, and produce output of a given mathematical type T 
CSystemConstraint  A SystemConstraint is a generic baseclass for constraints on Systems 
CSystemOutput  An abstract base class template for the values of the output ports of a System 
CSystemScalarConverter  Helper class to convert a System<U> into a System<T>, intended for internal use by the System framework, not directly by users 
CSystemSymbolicInspector  The SystemSymbolicInspector uses symbolic::Expressions to analyze various properties of the System, such as time invariance and inputtooutput sparsity, along with many others 
CSystemTypeTag  A tag object that denotes a System subclass S in function signatures 
CTimeSteppingRigidBodyPlant  This class provides a System interface around a multibody dynamics model of the world represented by a RigidBodyTree, implemented as a first order discretization of rigid body dynamics and constraint equations, without stepping to event times 
CTimeVaryingAffineSystem  Base class for a discrete or continuoustime, timevarying affine system, with potentially timevarying coefficients 
CTimeVaryingData  Stores matrix data necessary to construct an affine time varying system as a piecewise polynomial trajectory 
CTimeVaryingLinearSystem  Base class for a discrete or continuous linear timevarying (LTV) system 
CTrajectorySource  A source block that generates the value of a Trajectory for a given time 
CUnrestrictedUpdateEvent  This class represents an unrestricted update event 
CValkyriePDAndFeedForwardController  
CValue  A container class for an arbitrary type T 
CVectorBase  VectorBase is an abstract base class that realvalued signals between Systems and realvalued System state vectors must implement 
CVectorSystem  A base class that specializes LeafSystem for use with only zero or one vector input ports, and only zero or one vector output ports 
CViewerDrawTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_viewer_draw 
CWitnessFunction  Abstract class that describes a function that is able to help determine the time and state at which a simulation should be halted, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling) 
CZeroOrderHold  A ZeroOrderHold block with input u , which may be vectorvalued (discrete or continuous) or abstract, and discrete output y , where the y is sampled from u with a fixed period 
►Ntest  
CAutoDiffXdTest  
►Ntools  
►Ntest  
CSample  Specializes BasicVector with specific getters and setters 
CSampleIndices  Describes the row indices of a Sample 
CSampleTranslator  Translates between LCM message objects and VectorBase objects for the Sample type 
Ccopyable_unique_ptr  A smart pointer with deep copy semantics 
CDelegatingHasher  An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtimeprovided std::function of the same signature 
Cdummy_value  Provides a "dummy" value for a ScalarType – a value that is unlikely to be mistaken for a purposefullycomputed value, useful for initializing a value before the true result is available 
Cdummy_value< Eigen::AutoDiffScalar< DerType > >  Specializes common/dummy_value.h 
Cdummy_value< int >  
Cdummy_value< symbolic::Expression >  Specializes common/dummy_value.h 
CEigenPtr  This wrapper class provides a way to write nontemplate functions taking raw pointers to Eigen objects as parameters while limiting the number of copies, similar to Eigen::Ref 
CEigenSizeMinPreferDynamic  EigenSizeMinPreferDynamic<a, b>::value gives the min between compiletime sizes a and b 
CEigenSizeMinPreferFixed  EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic 
CFindResourceResult  Models the outcome of drake::FindResource 
Cis_eigen_nonvector_expression_double_pair  
Cis_eigen_nonvector_of  
Cis_eigen_scalar_same  
Cis_eigen_type  
Cis_eigen_vector  
Cis_eigen_vector_expression_double_pair  
Cis_eigen_vector_of  
Cis_numeric  Is_numeric is true for types that are on the real line 
Cis_numeric< symbolic::Expression >  Specializes is_numeric to be false for symbolic::Expression type 
CMultiplyEigenSizes  MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes 
Cnever_destroyed  Wraps an underlying type T such that its storage is a direct member field of this object (i.e., without any indirection into the heap), but unlike most member fields T's destructor is never invoked 
CNiceTypeName  Obtains canonicalized, platformindependent, humanreadable names for arbitrarilycomplicated C++ types 
CPiecewisePolynomialTrajectory  A PiecewisePolynomialTrajectory is a Trajectory that is represented by (implemented in terms of) a PiecewisePolynomial 
CPiecewiseQuaternionSlerp  A class representing a trajectory for quaternions that are interpolated using piecewise slerp (spherical linear interpolation) 
Creinit_after_move  Type wrapper that performs valueinitialization on the wrapped type, and guarantees that when moving from this type that the donor object is reset to its valueinitialized value 
CSortedPair  This class is similar to the std::pair class 
Ctemplate_single_tag  Provides a tag for singleparameter templates 
CTrajectory  A Trajectory represents a timevarying matrix of doubles 
Ctype_at  Extracts the Ith type from a sequence of types 
Ctype_check_different_from  Provides a check which returns whether T is different than U 
Ctype_pack  Provides a tag to pass a parameter packs for ease of inference 
Ctype_tag  Provides a tag to pass a type for ease of inference 
Ctype_visit_with_default  Visit a type by constructing its default value 
Ctype_visit_with_tag  Visits a type by construct a template tag's default value 
CTypeSafeIndex  A typesafe nonnegative index class 
Cuhash  A hashing functor, somewhat like std::hash 
►NDrakeShapes  
CBox  
CCapsule  
CCylinder  
CElement  
CGeometry  
CMesh  
CMeshPoints  
CSphere  
CVisualElement  
►Nlcm  
►Nmanipulation  
►Nplanner  
►NMotionGenesis  
►NMGChaoticBabyboot_  
CMGChaoticBabyboot  
CMGIntegrator  
CMGKukaIIwaRobotAutoGenerated  
►Nstd  STL namespace 
Cequal_to< drake::symbolic::Expression >  
Cequal_to< drake::symbolic::Formula >  
Cequal_to< drake::symbolic::Variable >  
Chash< drake::geometry::Identifier< Tag > >  Enables use of the identifier to serve as a key in STL containers 
Chash< drake::maliput::api::TypeSpecificIdentifier< T > >  Specialization of std::hash for TypeSpecificIdentifier<T> 
Chash< drake::SortedPair< T > >  Provides std::hash<SortedPair<T>> 
Chash< drake::symbolic::Expression >  
Chash< drake::symbolic::Formula >  
Chash< drake::symbolic::Monomial >  
Chash< drake::symbolic::Variable >  
Chash< drake::symbolic::Variables >  
Chash< drake::systems::sensors::Color< T > >  
Cless< drake::maliput::api::TypeSpecificIdentifier< T > >  Specialization of std::less for TypeSpecificIdentifier<T> providing a strict weak ordering over TypeSpecificIdentifier<T> suitable for use with ordered containers 
Cless< drake::solvers::SolverId >  
Cless< drake::symbolic::Expression >  
Cless< drake::symbolic::Formula >  
Cless< drake::symbolic::Variable >  
Cnumeric_limits< Eigen::AutoDiffScalar< T > >  
CAllBodiesClosestDistanceConstraint  
CAttachment  
CBodyMotionData  
CBodyMotionParams  
CBounds  
CbtOverlapFilterCallback  
CConstraintMatrixSingularError  
CContinuityConstraint  
CDesiredBodyAcceleration  
CDHomogTrans  
CDrakeJoint  A joint defines a spatial relationship between two rigid bodies 
CDrakeRobotState  
CEulerConstraint  
CExponentialPlusPiecewisePolynomial  Y(t) = K * exp(A * (t  t_j)) * alpha.col(j) + piecewise_polynomial_part(t) 
CFixedAxisOneDoFJoint  
CFixedJoint  
CForceTorqueMeasurement  
CGazeConstraint  
CGazeDirConstraint  
CGazeOrientConstraint  
CGazeTargetConstraint  
CGravityCompensationTorqueConstraint  
CHardwareGains  
CHardwareParams  
CHelicalJoint  
CIKoptions  
CIKResults  Return type for simplified versions of IK functions 
CInstantaneousQPController  
CIntegratorParams  
CJointNames  
CJointSoftLimitParams  
CKinematicModifications  
CKinematicPath  
CKinematicsCache  
CKinematicsCacheElement  
CKneeSettings  
CMinDistanceConstraint  
CMultipleTimeKinematicConstraint  
CMultipleTimeLinearPostureConstraint  
CPIDOutput  
CPiecewiseFunction  
CPiecewisePolynomial  A scalar multivariate piecewise polynomial 
CPiecewisePolynomialBase  
CPoint  
CPoint2LineSegDistConstraint  
CPoint2PointDistanceConstraint  
►CPolynomial  A scalar multivariate polynomial, modeled after the msspoly in spotless 
CMonomial  An additive atom of a Polynomial: The product of any number of Terms and a coefficient 
CProduct  
CTerm  An individual variable raised to an integer power; e.g. x**2 
CPositionConstraint  
CPositionIndices  
CPostureChangeConstraint  
CPostureConstraint  
CPrismaticJoint  A prismatic joint moves linearly along one axis 
CQPControllerDebugData  
CQPControllerOutput  
CQPControllerParams  
CQPControllerState  
CQPLocomotionPlan  
CQPLocomotionPlanSettings  
CQuadraticLyapunovFunction  
CQuasiStaticConstraint  Center of Mass (CoM) is within the support polygon 
CQuatConstraint  
CQuaternionBallJoint  Defines a 3 dof tree joint (mobilizer) that uses a unit quaternion as the generalized orientation coordinates 
CQuaternionFloatingJoint  Defines a 6 dof tree joint (mobilizer) that uses a unit quaternion as the generalized orientation coordinates 
CRelativeGazeDirConstraint  
CRelativeGazeTargetConstraint  
CRelativePositionConstraint  
CRelativeQuatConstraint  
CRevoluteJoint  
CRigidBody  
CRigidBodyActuator  Defines a physical actuator (i.e., an electric motor and stepdown transmission) that operates on a joint 
CRigidBodyConstraint  Base class 
CRigidBodyFrame  Multibody systems typically have distinguished frames of interest that need to be monitored 
CRigidBodyLoop  Defines a "loop joint" that models a kinematic loop formed by a chain of rigid bodies and their regular joints 
CRigidBodySupportStateElement  
CRigidBodyTree  Maintains a vector of RigidBody objects that are arranged into a kinematic tree via DrakeJoint objects 
CRigidBodyTreeAliasGroups  This class provides a way to create aliases to groups of RigidBody or DrakeJoint objects 
CRigidBodyTreeConstants  Defines RigidBodyTree constants 
CRobotJointIndexMap  
CRobotPropertyCache  
CRollPitchYawFloatingJoint  
CSide  
CSingleTimeKinematicConstraint  
CSingleTimeLinearPostureConstraint  
CSplineInformation  
CSupportStateElement  
CTransformSpatial  
►CTrigPoly  A scalar multivariate polynomial containing sines and cosines 
CProduct  
CSinCosVars  
CTVLQRData  
CValueConstraint  
CVRefIntegratorParams  
CWholeBodyParams  
CWorldCoMConstraint  
CWorldEulerConstraint  
CWorldFixedBodyPoseConstraint  
CWorldFixedOrientConstraint  
CWorldFixedPositionConstraint  
CWorldGazeDirConstraint  
CWorldGazeOrientConstraint  
CWorldGazeTargetConstraint  
CWorldPositionConstraint  
CWorldPositionInFrameConstraint  Constrains the points Q on a body to be within a bounding box specified in a fixed frame F 
CWorldQuatConstraint 