Drake

Atlas  
drake  NOTE: The contents of this class are for the most part direct ports of drake/systems/plants//inverseKinBackend.m from Matlab to C++; many methods and variables follow Matlab conventions and are documented in that file 
assert  
ConditionTraits< symbolic::Formula >  
automotive  
pose_selector  
RoadOdometry  Contains the position of the vehicle with respect to a lane in a road, along with its velocity vector in the world frame 
AutomotiveSimulator  AutomotiveSimulator is a helper class for constructing and running automotiverelated simulations 
BicycleCar  BicycleCar implements a nonlinear rigid body bicycle model from Althoff & Dolan (2014) [1] 
BoxCarVis  BoxCarVis displays a box as the visual representation of a vehicle 
CarVis  CarVis is a base class that provides visualization geometries and their poses 
CarVisApplicator  CarVisApplicator takes as input a PoseVector containing vehicle poses 
Curve2  Curve2 represents a path through twodimensional Cartesian space 
PositionResult  A result type for the GetPosition method 
BicycleCarParametersIndices  Describes the row indices of a BicycleCarParameters 
BicycleCarParameters  Specializes BasicVector with specific getters and setters 
BicycleCarParametersTranslator  Translates between LCM message objects and VectorBase objects for the BicycleCarParameters type 
BicycleCarStateIndices  Describes the row indices of a BicycleCarState 
BicycleCarState  Specializes BasicVector with specific getters and setters 
BicycleCarStateTranslator  Translates between LCM message objects and VectorBase objects for the BicycleCarState type 
DrivingCommandIndices  Describes the row indices of a DrivingCommand 
DrivingCommand  Specializes BasicVector with specific getters and setters 
DrivingCommandTranslator  Translates between LCM message objects and VectorBase objects for the DrivingCommand type 
EulerFloatingJointStateIndices  Describes the row indices of a EulerFloatingJointState 
EulerFloatingJointState  Specializes BasicVector with specific getters and setters 
EulerFloatingJointStateTranslator  Translates between LCM message objects and VectorBase objects for the EulerFloatingJointState type 
IdmPlannerParametersIndices  Describes the row indices of a IdmPlannerParameters 
IdmPlannerParameters  Specializes BasicVector with specific getters and setters 
MaliputRailcarParamsIndices  Describes the row indices of a MaliputRailcarParams 
MaliputRailcarParams  Specializes BasicVector with specific getters and setters 
MaliputRailcarParamsTranslator  Translates between LCM message objects and VectorBase objects for the MaliputRailcarParams type 
MaliputRailcarStateIndices  Describes the row indices of a MaliputRailcarState 
MaliputRailcarState  Specializes BasicVector with specific getters and setters 
MaliputRailcarStateTranslator  Translates between LCM message objects and VectorBase objects for the MaliputRailcarState type 
MobilPlannerParametersIndices  Describes the row indices of a MobilPlannerParameters 
MobilPlannerParameters  Specializes BasicVector with specific getters and setters 
PurePursuitParamsIndices  Describes the row indices of a PurePursuitParams 
PurePursuitParams  Specializes BasicVector with specific getters and setters 
SimpleCarParamsIndices  Describes the row indices of a SimpleCarParams 
SimpleCarParams  Specializes BasicVector with specific getters and setters 
SimpleCarParamsTranslator  Translates between LCM message objects and VectorBase objects for the SimpleCarParams type 
SimpleCarStateIndices  Describes the row indices of a SimpleCarState 
SimpleCarState  Specializes BasicVector with specific getters and setters 
SimpleCarStateTranslator  Translates between LCM message objects and VectorBase objects for the SimpleCarState type 
IdmController  An IdmController implements the IDM (Intelligent Driver Model) planner, computed based only on the nearest car ahead 
IdmPlanner  IdmPlanner (Intelligent Driver Model Planner) is a simple model governing longitudinal accelerations of a vehicle in singlelane traffic [1, 2] 
LaneDirection  LaneDirection holds the lane that a MaliputRailcar is traversing and the direction in which it is moving 
MaliputRailcar  MaliputRailcar models a vehicle that follows a maliput::api::Lane as if it were on rails and neglecting all physics 
MobilPlanner  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 
RoadCharacteristics  RoadCharacteristics computes and stores characteristics of a road network; i.e 
MonolaneOnrampMerge  MonolaneOnrampMerge contains an example lanemerge scenario expressed as a maliput monolane road geometry 
PriusVis  PriusVis displays a visualization of a 2015 Toyota Prius 
PurePursuit  PurePursuit computes the required steering angle to achieve a goal point on an continuous planar path 
PurePursuitController  PurePursuitController implements a pure pursuit controller 
RoadPath  RoadPath converts a sequence of Maliput Lanes into a PiecewisePolynomial for the purpose of generating a path for a car to follow 
SimpleCar  SimpleCar models an idealized response to driving commands, neglecting all physics 
SimpleCarToEulerFloatingJoint  Converts SimpleCarState to a full 6DOF EulerFloatingJointState 
SimplePowertrain  SimplePowertrain models a powertrain with firstorder lag 
TrajectoryCar  TrajectoryCar models a car that follows a preestablished trajectory, neglecting all physics 
PositionHeading  Data structure returned by CalcRawPose containing raw pose information 
benchmarks  
cylinder_torque_free_analytical_solution  
bouncing_ball  
Ball  Dynamical system representation of the onedimensional equations of motion for a ball in flight, dropped with an initial position (height) and velocity 
BouncingBall  Dynamical representation of the idealized hybrid dynamics of a ball dropping from a height and bouncing on a surface 
common  
internal  
test  
MatlabRemoteVariable  Holds a reference to a variable stored on the matlab client, which can be passed back into a future lcm_call_matlab call 
core  
test  
detail  
examples  
acrobot  
AcrobotStateReceiver  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 
AcrobotCommandSender  Receives the output of an acrobot controller, and outputs it as an LCM message with type lcm_acrobot_u 
AcrobotCommandReceiver  Receives the output of an LcmSubsriberSystem that subsribes to the acrobot input channel with LCM type lcmt_acrobot_u, and outputs the acrobot input as a BasicVector 
AcrobotStateSender  Receives the output of an acrobot_plant, and outputs it as an LCM message with type lcm_acrobot_x 
MessageHandler  Handles received LCM messages of type lcmt_acrobot_x 
AcrobotPlant  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
AcrobotWEncoder  Constructs the Acrobot with (only) encoder outputs 
AcrobotSpongController  
AcrobotInputVectorIndices  Describes the row indices of a AcrobotInputVector 
AcrobotInputVector  Specializes BasicVector with specific getters and setters 
AcrobotOutputVectorIndices  Describes the row indices of a AcrobotOutputVector 
AcrobotOutputVector  Specializes BasicVector with specific getters and setters 
AcrobotStateVectorIndices  Describes the row indices of a AcrobotStateVector 
AcrobotStateVector  Specializes BasicVector with specific getters and setters 
bead_on_a_wire  
BeadOnAWire  Dynamical system of a point (unit) mass constrained to lie on a wire 
kuka_iiwa_arm  
monolithic_pick_and_place  
ActionPrimitive  This class is the base of an ActionPrimitive 
IiwaActionInput  A struct that contains all the variables needed for the abstract input of the ActionPrimitive of type IiwaMove 
GripperAction  An ActionPrimitive for commanding the Schunk WSG Gripper 
IiwaMove  An ActionPrimitive for commanding the joint angles of the Kuka IIWA Arm 
StateMachineAndPrimitives  A systems::Diagram that encapsulates a PickAndPlaceStateMachineSystem and a IiwaMove and a GripperAction 
IiwaWsgPlantGeneratorsEstimatorsAndVisualizer  A systems::Diagram that encapsulates a IiwaAndWsgPlanGeneratorsEstimatorsAndVisualizer , a systems::DrakeVisualizer , IiwaPlanSource , SchunkWsgTrajectoryGenerator and a SchunkWsgStatusSender 
PickAndPlaceStateMachineSystem  A class that implements the FiniteStateMachine logic for the PickAndPlace demo 
SynchronousWorldState  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 
pick_and_place  
Action  Base class for actions used by the pick and place demo 
IiwaMove  A class that represents an action that sends a sequence of desired joint positions through LCM to move the KUKA iiwa arm 
WsgAction  An Action that closes / open the gripper 
WorldState  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 
tools  
SimpleTreeVisualizer  A utility to render a RigidBodyTree in a specified configuration in the drakevisualizer 
IiwaIkPlanner  A wrapper class around the IK planner 
IkCartesianWaypoint  Cartesian waypoint 
IiwaCommandReceiver  Handles lcmt_iiwa_command messages from a LcmSubscriberSystem 
IiwaCommandSender  Creates and outputs lcmt_iiwa_command messages 
IiwaStatusReceiver  Handles lcmt_iiwa_status messages from a LcmSubscriberSystem 
IiwaStatusSender  Creates and outputs lcmt_iiwa_status messages 
IiwaPlanSource  This class implements a source of joint positions for an iiwa arm 
IiwaAndWsgPlantWithStateEstimator  A custom systems::Diagram composed of a systems::RigidBodyPlant , and a systems::InverseDynamicsController , systems::PidController , and two OracularStateEstimation systems 
PlantAndVisualizerDiagram  A custom systems::Diagram composed of a systems::RigidBodyPlant and a systems::DrakeVisualizer 
PassiveVisualizedPlant  A custom Diagram consisting of a ConstantVectorSource of 0 magnitude connected to a VisualizedPlant 's input port zero 
PositionControlledPlantWithRobot  A custom systems::Diagram consisting of a systems::PidControlledSystem wrapping a RigidBodyPlant with a systems::GravityCompensator attached in feedback and a systems::DrakeVisualizer attached to the output 
ModelInstanceInfo  
WorldSimTreeBuilder  A helper class to construct robot world RigidBodyTree objects from model (URDF/SDF) files 
OracularStateEstimation  A class that takes state vector and output a bot_core::robot_state_t message 
SimDiagramBuilder  A wrapper class around DiagramBuilder that facilitates diagram building for controlled simulation 
particles  
Particle  A linear 1DOF particle system 
pendulum  
PendulumStateVectorIndices  Describes the row indices of a PendulumStateVector 
PendulumStateVector  Specializes BasicVector with specific getters and setters 
PendulumPlant  A model of a simple pendulum
\[ ml^2 \ddot\theta + b\dot\theta + mgl\sin\theta = u \] 
qp_inverse_dynamics  
param_parsers  
DesiredMotionParam  Struct for storing parameters for generating a desired acceleration objective \( \dot{v}_d \) for the QP inverse dynamics controller 
ContactParam  A struct for holding contactrelated parameters such as local offsets of the contact points, friction coefficient, etc 
ParamSet  A class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller 
RigidBodyTreeAliasGroups  This class provides a way to create aliases to groups of RigidBody or DrakeJoint objects 
CartesianSetpoint  This is used to compute target spatial acceleration, which is the input to the inverse dynamics controller 
VectorSetpoint  
BodyOfInterest  An object that holds important kinematic properties 
HumanoidStatus  Mostly a thin wrapper on RigidBodyTree 
GenericPlan  This class represents a plan interpretor, which conceptually serves as a bridge between a high level planner (e.g 
ManipulatorMoveEndEffectorPlan  A concrete plan that sets up a Cartesian tracking objective for the end effector assuming no contacts 
PiecewiseCubicTrajectory  A wrapper class that stores a PiecewisePolynomial and its first and second derivatives 
PiecewiseCartesianTrajectory  A wrapper class that represents a Cartesian trajectory, whose position part is a PiecewiseCubicTrajectory, and the rotation part is a PiecewiseQuaternionSlerp 
GenericPlanTest  
QPController  
ConstrainedValues  Base class for specifying various desired objectives 
ContactInformation  This class describes contact related information for each body in contact with other bodies in the world 
DesiredBodyMotion  A wrapper class specifying desired body motion (acceleration) for a rigid body and their corresponding weights for the QP 
DesiredDofMotions  A wrapper class specifying desired DoF (degree of freedom) motions (acceleration) and their corresponding weights for the QP 
DesiredCentroidalMomentumDot  A wrapper class specifying desired centroidal momentum change and their corresponding weights for the QP 
QpInput  Input to the QP inverse dynamics controller 
ResolvedContact  This class holds contact force related information, and works closely with ContactInformation 
BodyAcceleration  This class holds spatial acceleration for a rigid body 
QpOutput  Output of the QP inverse dynamics controller 
AtlasJointLevelControllerSystem  A class that extends JointLevelControllerBaseSystem to output an additional bot_core::atlas_command_t 
HumanoidPlanEvalSystem  This class extends PlanEvalBaseSystem 
HumanoidStatusTranslatorSystem  An abstract base class for systems that translate various types of state into HumanoidStatus 
StateToHumanoidStatusSystem  Translates a state vector to HumanoidStatus 
RobotStateMsgToHumanoidStatusSystem  Translates a bot_core::robot_state_t message to HumanoidStatus 
JointLevelControllerBaseSystem  An abstract base class that translates a QpOutput to a vector of torque commands in the actuator order within the RigidBodyTree 
TrivialJointLevelControllerSystem  Translates a QpOutput to a vector of torque commands in the actuator order within the RigidBodyTree 
ManipulatorInverseDynamicsController  This class implements an example of a general purpose controller for a fixed based manipulator based on qp inverse dynamics 
ManipulatorPlanEvalSystem  This class extends PlanEvalBaseSystem 
PlanEvalBaseSystem  A base class that outputs QpInput for the qp inverse dynamics controller 
QpControllerSystem  A discrete time system block for an inverse dynamics controller 
ValkyrieController  A controller for humanoid balancing built on top of HumanoidPlanEvalSystem and QpControllerSystem 
quadrotor  
QuadrotorPlant  The Quadrotor  an underactuated aerial vehicle 
rod2d  
Rod2D  Dynamical system representation of a rod contacting a halfspace in two dimensions 
schunk_wsg  
SchunkWsgTrajectoryGeneratorStateVectorIndices  Describes the row indices of a SchunkWsgTrajectoryGeneratorStateVector 
SchunkWsgTrajectoryGeneratorStateVector  Specializes BasicVector with specific getters and setters 
SchunkWsgTrajectoryGenerator  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 
SchunkWsgStatusSender  Sends lcmt_schunk_wsg_status messages for a Schunk WSG 
valkyrie  
ValkyrieSimulationDiagram  
zmp  
ZMPTestTraj  A structure for storing trajectories from simulating a linear inverted pendulum model (LIPM) using the policy from a drake::systems::ZMPPlanner 
geometry  
Identifier  A simple identifier class 
internal  
TupleToMexHelper  
TupleToMexHelper< 0 >  
lcm  
DrakeLcm  A wrapper around a real LCM instance 
DrakeLcmInterface  A pure virtual interface that enables LCM to be mocked 
DrakeLcmMessageHandlerInterface  Defines a message handler interface that must be implemented by all LCM subscribers within Drake 
DrakeMockLcm  A mock LCM instance 
LcmReceiveThread  Maintains a thread that receives LCM messages and dispatches the messages to the appropriate message handlers 
logging  
logger  A stubbedout version of spdlog::logger 
maliput  
api  
BranchPointId  
LaneEndSet  A set of LaneEnds 
BranchPoint  A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another 
JunctionId  Persistent identifier for a Junction element 
Junction  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 
LaneId  Persistent identifier for a Lane element 
Lane  A Lane represents a lane of travel in a road network 
LaneEnd  A specific endpoint of a specific Lane 
StrictOrder  An arbitrary strict complete ordering, useful for, e.g., std::map 
Rotation  A 3dimensional rotation, expressed as a roll around X, followed by pitch around Y, followed by yaw around Z 
GeoPosition  A position in 3dimensional geographical Cartesian space 
LanePosition  A 3dimensional position in LANEspace, consisting of three components: 
IsoLaneVelocity  Isometric velocity vector in LANEspace 
RoadPosition  A position in the road network, consisting of a pointer to a specific Lane and a LANEspace position on that Lane 
RBounds  Bounds in the lateral dimension (r component) of LANEspace, consisting of a pair of minimum and maximum r value 
RoadGeometryId  Persistent identifier for a RoadGeometry element 
RoadGeometry  Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3space 
SegmentId  Persistent identifier for a Segment element 
Segment  A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface 
dragway  
LaneEndSet  Dragway's implementation of api::LaneEndSet 
BranchPoint  Dragway's implementation of api::BranchPoint 
Junction  Dragway's implementation of api::Junction 
Lane  Dragway's implementation of api::Lane 
RoadGeometry  Dragway's implementation of api::RoadGeometry 
Segment  Dragway's implementation of api::Segment 
monolane  
ArcLane  Specialization of Lane with a circular arc as its reference curve in the xyplane (the ground plane) of the world frame 
LaneEndSet  An implementation of LaneEndSet 
BranchPoint  An implementation of api::BranchPoint 
EndpointXy  XYplaneonly parameters for an endpoint of a connection, specified in the world frame 
EndpointZ  Outofplane parameters for an endpoint of a connection, specified in the world frame 
Endpoint  Complete set of parameters for an endpoint of a connection, specified in the world frame 
ArcOffset  Specification for path offset along a circular arc 
Connection  Representation of a reference path connecting two endpoints 
Group  A group of Connections 
Builder  Convenient builder class which makes it easy to construct a monolane road network 
Junction  An api::Junction implementation 
Rot3  An R^3 rotation parameterized by roll, pitch, yaw 
CubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
Lane  Base class for the monolane implementation of api::Lane 
LineLane  Specialization of Lane with a line segment as its reference curve in the xyplane (the ground plane) of the world frame 
RoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
Segment  An api::Segment implementation 
rndf  
utility  
ObjFeatures  Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults 
manipulation  
math  
internal  
ResizeDerivativesToMatchScalarImpl  
ResizeDerivativesToMatchScalarImpl< Derived, Eigen::AutoDiffScalar< DerivType > >  
TotalSizeAtCompileTime  Helper for totalSizeAtCompileTime function (recursive) 
TotalSizeAtCompileTime< Head >  Helper for totalSizeAtCompileTime function (base case) 
InitializeAutoDiffTupleHelper  Helper for initializeAutoDiffTuple function (recursive) 
InitializeAutoDiffTupleHelper< 0 >  Helper for initializeAutoDiffTuple function (base case) 
quaternion_test  
test  
AutoDiffToValueMatrix  
AutoDiffToGradientMatrix  
Gradient  
Gradient< Derived, Nq, 1 >  
MatGradMultMat  
MatGradMult  
GetSubMatrixGradientArray  
GetSubMatrixGradientSingleElement  
multibody  
benchmarks  
Acrobot  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
joints  
math  
rigid_body_plant  
test  
test  
rigid_body  
rigid_body_actuator  
rigid_body_frame  
rigid_body_loop  
rigid_body_tree  
KukaTest  
GlobalInverseKinematics  Solves the inverse kinematics problem as a mixed integer convex optimization problem 
Body  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 
BodyFrame  A BodyFrame is a material Frame that serves as the unique reference frame for a Body 
MultibodyTree  MultibodyTree provides a representation for a physical system consisting of a collection of interconnected rigid and deformable bodies 
RigidBody  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 
FixedOffsetFrame  FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P 
Frame  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 
FrameBase  FrameBase is an abstract representation of the concept of a frame in multibody dynamics 
SpatialVelocity  This class is used to represent a spatial velocity (also called a twist) that combines rotational (angular) and translational (linear) velocity components 
SpatialForce  This class is used to represent a spatial force (also called a wrench) that combines both rotational (torque) and translational force components 
SpatialVector  This class is used to represent physical quantities that correspond to spatial vectors such as spatial velocities, spatial accelerations and spatial forces 
MultibodyTreeElement< ElementType< T >, ElementIndexType >  A class representing an element or component of a MultibodyTree 
BodyTopology  Data structure to store the topological information associated with a Body 
FrameTopology  Data structure to store the topological information associated with a Frame 
MultibodyTreeTopology  Data structure to store the topological information associated with an entire MultibodyTree 
RotationalInertia  This class provides an abstraction for the physical concept of the mass distribution of a body (or a collection of bodies forming a composite body), about a particular point 
SpatialInertia  This class represents the physical concept of a Spatial Inertia 
UnitInertia  This class is used to represent rotational inertias for unit mass bodies 
nice_type_name_test  
parsers  
sdf  
urdf  
PackageMap  Maps ROS package names to their full path on the local file system 
FloatingJointConstants  Defines constants used by AddFloatingJoint() 
solvers  
detail  
is_convertible_workaround  
is_convertible_workaround< std::unique_ptr< A >, std::shared_ptr< B > >  
is_binding_compatible  Enables us to catch and provide a meaningful assertion if a Constraint is passed in, when we should have a Cost 
is_cost_functor_candidate  Template condition to check if F is a candidate to be used to construct a FunctionCost object for generic costs 
assert_if_is_constraint  Template condition to only catch when Constraints are inadvertently passed as an argument 
FunctionTraits  FunctionTraits 
FunctionTraits< std::reference_wrapper< F > >  
FunctionTraits< std::shared_ptr< F > >  
FunctionTraits< std::unique_ptr< F > >  
internal  
test  
GenericTrivialCost1  
GenericTrivialCost2  
LinearFeasibilityProgram  Test a simple linear programming problem with zero cost, i.e 
LinearProgram0  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 
LinearProgram1  
LinearProgram2  
LinearProgram3  
LinearProgramTest  
InfeasibleLinearProgramTest0  An infeasible linear program 
UnboundedLinearProgramTest0  An unbounded linear program 
OptimizationProgram  
LinearSystemExample1  Simple example x = b 
LinearSystemExample2  Simple linear system x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
LinearSystemExample3  Simple linear system 3 * x = b 2 * y(0) = b(0) 2 * y(1) = b(1) 
LinearMatrixEqualityExample  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 
NonConvexQPproblem1  This test comes from Section 2.2 of Handbook of Test Problems in Local and Global Optimization 
NonConvexQPproblem2  This test comes from Section 2.3 of Handbook of Test Problems in Local and Global Optimization 
LowerBoundedProblem  This test comes from Section 3.4 of Handbook of Test Problems in Local and Global Optimization 
GloptiPolyConstrainedMinimizationProblem  GloptiPolyConstrainedMinimization 
MinDistanceFromPlaneToOrigin  An SOCP with Lorentz cone and rotated Lorentz cone constraints 
ConvexCubicProgramExample  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 
QuadraticProgramTest  
QuadraticProgram0  
QuadraticProgram1  Adapt from the simple test on the Gurobi documentation 
QuadraticProgram2  
QuadraticProgram3  
QuadraticProgram4  
Binding  A binding on constraint type C is a mapping of the decision variables onto the inputs of C 
EvaluatorBase  An evaluator base provides an abstract interface to store an expression and then evaluate it, either on a double or a AutoDiff Scalar type 
Constraint  A constraint is a function + lower and upper bounds 
QuadraticConstraint  Lb <= .5 x'Qx + b'x <= ub 
LorentzConeConstraint  Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone 
RotatedLorentzConeConstraint  Constraining that the linear expression \( z=Ax+b \) lies within rotated Lorentz cone 
PolynomialConstraint  Lb[i] <= Pi <= ub[i], where each P[i] is a multivariate polynomial in x, y.. 
LinearConstraint  Implements a constraint of the form lb <= Ax <= ub 
LinearEqualityConstraint  Implements a constraint of the form Ax = b 
BoundingBoxConstraint  Implements a constraint of the form lb <= x <= ub 
LinearComplementarityConstraint  Implements a constraint of the form: 
PositiveSemidefiniteConstraint  Implements a positive semidefinite constraint on a symmetric matrix S
\[\text{ S is p.s.d }\] namely, all eigen values of S are nonnegative 
LinearMatrixInequalityConstraint  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 
Cost  Stopgap definition that permits Cost to use functionality in Constraint 
CostShimBase  Stopgap definition that permits CostShim to pass a constructed Constraint instance, and propogate the information to the Costwrapped Constraint 
CostShim  Stopgap class to provide functionality as constraint, but allow templates to detect a difference from results from CreateConstraint and CreateCost 
LinearCost  Implements a cost of the form Ax 
QuadraticCost  Implements a cost of the form .5 x'Qx + b'x 
PolynomialCost  Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y.. 
FunctionConstraint  A constraint that may be specified using a callable object 
FunctionCost  A cost that may be specified using a callable object 
DrealSolver  
EqualityConstrainedQPSolver  
GurobiSolver  
IpoptSolver  
LinearSystemSolver  
MathematicalProgram  
SolverData  
MathematicalProgramSolverInterface  Interface used by implementations of individual solvers 
MobyLCPSolver  A class for solving Linear Complementarity Problems (LCPs) 
MosekSolver  
NloptSolver  
SnoptSolver  
SystemIdentification  Utility functions for system identification 
SystemIdentificationResult  A helper struct to hold System ID results 
symbolic  
detail  
RelationalOpTraits  Provides a return type of relational operations (=, ≠, ≤, <, ≥, >) between Eigen::Array s 
test  
Monomial  Represents a monomial, a product of powers of variables with nonnegative integer exponents 
GradedReverseLexOrder  Implements Graded reverse lexicographic order 
Environment  Represents a symbolic environment (mapping from a variable to a value) 
Expression  Represents a symbolic form of an expression 
ExpressionCell  Represents an abstract class which is the base of concrete symbolicexpression classes 
UnaryExpressionCell  Represents the base class for unary expressions 
BinaryExpressionCell  Represents the base class for binary expressions 
ExpressionVar  Symbolic expression representing a variable 
ExpressionConstant  Symbolic expression representing a constant 
ExpressionNaN  Symbolic expression representing NaN (notanumber) 
ExpressionAdd  Symbolic expression representing an addition which is a sum of products 
ExpressionAddFactory  Factory class to help build ExpressionAdd expressions 
ExpressionMul  Symbolic expression representing a multiplication of powers 
ExpressionMulFactory  Factory class to help build ExpressionMul expressions 
ExpressionDiv  Symbolic expression representing division 
ExpressionLog  Symbolic expression representing logarithms 
ExpressionAbs  Symbolic expression representing absolute value function 
ExpressionExp  Symbolic expression representing exponentiation using the base of natural logarithms 
ExpressionSqrt  Symbolic expression representing squareroot 
ExpressionPow  Symbolic expression representing power function 
ExpressionSin  Symbolic expression representing sine function 
ExpressionCos  Symbolic expression representing cosine function 
ExpressionTan  Symbolic expression representing tangent function 
ExpressionAsin  Symbolic expression representing arcsine function 
ExpressionAcos  Symbolic expression representing arccosine function 
ExpressionAtan  Symbolic expression representing arctangent function 
ExpressionAtan2  Symbolic expression representing atan2 function (arctangent function with two arguments) 
ExpressionSinh  Symbolic expression representing hyperbolic sine function 
ExpressionCosh  Symbolic expression representing hyperbolic cosine function 
ExpressionTanh  Symbolic expression representing hyperbolic tangent function 
ExpressionMin  Symbolic expression representing min function 
ExpressionMax  Symbolic expression representing max function 
ExpressionIfThenElse  Symbolic expression representing ifthenelse expression 
ExpressionUninterpretedFunction  Symbolic expression representing an uninterpreted function 
Formula  Represents a symbolic form of a firstorder logic formula 
FormulaCell  Represents an abstract class which is the base of concrete symbolicformula classes (i.e 
RelationalFormulaCell  Represents the base class for relational operators (==, !=, <, <=, >, >=) 
NaryFormulaCell  Represents the base class for Nary logic operators (∧ and ∨) 
FormulaTrue  Symbolic formula representing true 
FormulaFalse  Symbolic formula representing false 
FormulaEq  Symbolic formula representing equality (e1 = e2) 
FormulaNeq  Symbolic formula representing disequality (e1 ≠ e2) 
FormulaGt  Symbolic formula representing 'greaterthan' (e1 > e2) 
FormulaGeq  Symbolic formula representing 'greaterthanorequalto' (e1 ≥ e2) 
FormulaLt  Symbolic formula representing 'lessthan' (e1 < e2) 
FormulaLeq  Symbolic formula representing 'lessthanorequalto' (e1 ≤ e2) 
FormulaAnd  Symbolic formula representing conjunctions (f1 ∧ .. 
FormulaOr  Symbolic formula representing disjunctions (f1 ∨ .. 
FormulaNot  Symbolic formula representing negations (¬f) 
FormulaForall  Symbolic formula representing universal quantifications (∀ x₁, ..., * xn 
FormulaIsnan  Symbolic formula representing isnan predicate 
FormulaPositiveSemidefinite  Symbolic formula representing positivesemidefinite (PSD) constraint 
Variable  Represents a symbolic variable 
Variables  Represents a set of variables 
systems  
analysis_test  
MySpringMassSystem  
detail  
InputPortEvaluatorInterface  InputPortEvaluatorInterface is implemented by classes that are able to evaluate the OutputPortValue connected to a particular InputPortValue 
ModelValues  Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) 
OutputPortListenerInterface  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 
estimators  
LuenbergerObserver  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 
internal  
CacheEntry  A single cached piece of data, its validity bit, and the set of other cache entries that depend on it 
DiagramOutput  DiagramOutput is an implementation of SystemOutput that holds unowned OutputPortValue pointers 
DiagramTimeDerivatives  DiagramTimeDerivatives is a version of DiagramContinuousState that owns the constituent continuous states 
DiagramDiscreteVariables  DiagramDiscreteVariables is a version of DiscreteState that owns the constituent discrete states 
mean_zero_uniform_real_distribution  Defines a version of the std::uniform_real_distribution that uses the interval [1,1] with the default parameters 
lcm  
LcmAndVectorBaseTranslator  Defines an abstract parent class of all translators that convert between LCM message bytes and drake::systems::VectorBase objects 
LcmMessageToTimeInterface  A generic translator interface that extracts time in seconds from an abstract type 
UtimeMessageToSeconds  A translator class for Lcm message types that have a "utime" field, which is in micro seconds 
LcmDrivenLoop  This class implements a loop that's driven by a Lcm message 
LcmPublisherSystem  Publishes an LCM message containing information from its input port 
LcmSubscriberSystem  Receives LCM messages from a given channel and outputs them to a System<double>'s port 
LcmTranslatorDictionary  A dictionary that maps between LCM channel names and translators that convert between LCM message objects and VectorBase objects 
LcmtDrakeSignalTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_drake_signal 
SerializerInterface  SerializerInterface translates between LCM message bytes and drake::systems::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal> 
Serializer  Serializer is specific to a single LcmMessage type, and translates between LCM message bytes and drake::systems::Value<LcmMessage> objects 
plants  
joints  
rigid_body_plant  
test  
test  
rigid_body_tree  
KinematicsCacheHelper  Helper class to avoid recalculating a kinematics cache which is going to be used repeatedly by multiple other classes 
SingleTimeKinematicConstraintWrapper  
QuasiStaticConstraintWrapper  
IKTrajectoryHelper  This class is a helper for backend implementations of inverse kinematics trajectory planning 
rendering  
pose_aggregator_detail  
FrameVelocity  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 
PoseAggregator  PoseAggregator is a multiplexer for heterogeneous sources of poses and the velocities of those poses 
PoseBundle  PoseBundle is a container for a set of poses, represented by an Isometry3, and corresponding velocities, represented by a FrameVelocity 
PoseBundleToDrawMessage  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 
PoseVector  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 
sensors  
Accelerometer  A simulated ideal accelerometer that measures the linear acceleration of a frame associated with a RigidBodyPlant 
AccelerometerOutputConstants  
AccelerometerOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Accelerometer's output 
CameraInfo  Simple data structure for camera information that includes the image size and camera intrinsic parameters 
DepthSensor  A simple model of an ideal depth sensor 
DepthSensorOutput  Specializes BasicVector with specific getters and setters that are useful for consumers of DepthSensor's output 
DepthSensorSpecification  Holds a DepthSensor's specification 
DepthSensorToLcmPointCloudMessage  A DepthSensorToLcmPointCloudMessage takes as input a DepthSensorOutput and the pose of the depth sensor in the world (X_WS ) 
Gyroscope  A simulated ideal gyroscope 
GyroscopeOutputConstants  Defines the semantics of each index in GyroscopeOutput's vector 
GyroscopeOutput  Specializes BasicVector with accessors and setters that are useful for consumers of Gyroscope's output 
Image  Simple data format for Image that takes an arbitrary type for the each channel in a pixel 
RgbdCamera  The RgbdCamera provides both RGB and depth images 
InvalidDepth  Set of constants used to represent invalid depth values 
Label  Set of labels used for label image 
RotaryEncoders  Simple model to capture the quantization and calibration offset effects of a rotary encoder 
AccelerometerExampleDiagram  Implements the Diagram shown below, which demonstrates how an accelerometer can be used 
AccelerometerXdotHack  Implements a system with one input port and one output port, both vector valued 
VtkUtil  Utility class for the VTK library 
ActuatorEffortToRigidBodyPlantInputConverter  
RobotCommandToDesiredEffortConverter  Converts an atlas_command_t message into desired efforts, presented on one output port per actuator 
RobotStateDecoder  Converts a robot_state_t LCM message into a KinematicsCache object 
RobotStateEncoder  Assembles information from various input ports into a robot_state_t LCM message, presented on an output port 
ValkyriePDAndFeedForwardController  
ContactDetail  The base class for defining a contact detail 
ContactForce  The data for a single contact force applied to one body of a contacting pair 
ContactInfo  A class containing information regarding contact response between two bodies including: 
ContactResultantForceCalculator  This is a utility class for replacing a set of force/torques by an equivalent force/torque (defined by the ContactForce class) 
RigidBodyPlant  This class provides a System interface around a multibody dynamics model of the world represented by a RigidBodyTree 
ContactResults  A class containg the contact results (contact points and response spatial forces for each colliding pair of collision elements) 
ContactResultsToLcmSystem  A System that encodes ContactResults into a lcmt_contact_results_for_viz message 
DrakeVisualizer  This is a Drake System block that takes a RigidBodyTree and publishes LCM messages that are intended for the DrakeVisualizer 
KinematicsResults  A class containing the kinematics results from a RigidBodyPlant system 
PointContactDetail  An implementation of the ContactDetail where the contact details consist of a single ContactForce 
RigidBodyPlantThatPublishesXdot  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 
ViewerDrawTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_viewer_draw 
ExplicitEulerIntegrator  A firstorder, explicit Euler integrator 
IntegratorBase  An abstract class for an integrator for ODEs and DAEs 
RungeKutta2Integrator  A secondorder, explicit Runge Kutta integrator 
RungeKutta3Integrator  A thirdorder Runge Kutta integrator with a third order error estimate 
SemiExplicitEulerIntegrator  A firstorder, semiexplicit Euler integrator 
Simulator  A forward dynamics solver for hybrid dynamic systems represented by System<T> objects 
PidControlledSpringMassSystem  A model of a onedimensional springmass system controlled to achieve a given target position using a PID controller 
InverseDynamics  Solves inverse dynamics with no consideration for external wrenches, under actuation, joint torque limits or closed kinematic chains 
InverseDynamicsController  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
LinearQuadraticRegulatorResult  
ModelBasedController  Interface for model based state feedback controllers 
PidControlledSystem  A system that encapsulates a PidController and a controlled System (a.k.a the "plant") 
ConnectResult  The return type of ConnectController 
PidController  Implements the PID controller 
StateFeedbackController  Interface for state feedback controllers 
ZMPPlanner  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) 
AbstractValues  AbstractValues is a container for nonnumerical state and parameters 
BasicVector  BasicVector is a semanticsfree wrapper around an Eigen vector that satisfies VectorBase 
Cache  Cache is a keyvalue store used within the System2 framework to avoid computing intermediate data multiple times during simulation or analysis 
StepInfo  Contains information about the independent variable including time and step number 
Context  Context is an abstract base class template that represents all the inputs to a System: time, state, and input vectors 
ContinuousState  The ContinuousState is a container for all the State variables that are unique to continuous Systems, i.e 
DiagramBuilder  DiagramBuilder is a factory class for Diagram 
Diagram  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 
DiagramState  DiagramState is a State, annotated with pointers to all the mutable substates that it spans 
DiagramContext  The DiagramContext is a container for all of the data necessary to uniquely determine the computations performed by a Diagram 
DiagramContinuousState  DiagramContinuousState is a ContinuousState consisting of Supervectors over a set of constituent ContinuousStates 
DiscreteValues  The DiscreteValues is a container for numerical but noncontinuous state and parameters 
InputPortValue  InputPortValue identifies the value source for a single System input port 
DependentInputPortValue  A DependentInputPortValue wraps a pointer to an OutputPortValue associated with one System for use as an input to another System 
FreestandingInputPortValue  A FreestandingInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports 
LeafContext  LeafContext is a container for all of the data necessary to uniquely determine the computations performed by a leaf System 
PeriodicEvent  A token describing an event that recurs on a fixed period 
LeafSystem  A superclass template that extends System with some convenience utilities that are not applicable to Diagrams 
OutputPortValue  OutputPortValue contains the value of a single System output port 
SystemOutput  An abstract base class template for the values of the output ports of a System 
LeafSystemOutput  A container for the values of all output ports of a leaf System 
Parameters  Parameters is a container for variables that parameterize a System so that it can represent a family of related models 
SingleOutputVectorSource  A base class that specializes LeafSystem for use with no input ports, and only a single output port 
SisoVectorSystem  A base class that specializes LeafSystem for use with only a single input port, and only a single output port 
SparsityMatrix  The SparsityMatrix reports the connectivity between fields in a System's Context, and outputs computed by that System 
State  The State is a container for all the data comprising the complete state of a particular System at a particular moment 
Subvector  Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase 
Supervector  Supervector is a concrete class template that implements VectorBase by concatenating multiple VectorBases, which it does not own 
DiscreteEvent  A description of a discretetime event, which is passed from the Simulator to the recipient System's appropriate event handling method 
UpdateActions  A token that identifies the next sample time at which a System must perform some actions, and the actions that must be performed 
System  A superclass template for systems that receive input, maintain state, and produce output of a given mathematical type T 
InputPortDescriptor  InputPortDescriptor is a notation for specifying the kind of input a System accepts, on a given port 
OutputPortDescriptor  OutputPortDescriptor is a notation for specifying the kind of output a System produces, on a given port 
MyVector  A simple subclass of BasicVector<T> for testing, particularly for cases where BasicVector subtyping must be preserved through the framework 
Value  A container class for an arbitrary type T 
AbstractValue  A fully typeerased container class 
VectorValue  A container class for BasicVector<T> 
VectorBase  VectorBase is an abstract base class that realvalued signals between Systems and realvalued System state vectors must implement 
SpringMassStateVector  The state of a onedimensional springmass system, consisting of the position and velocity of the mass, in meters and meters/s 
SpringMassSystem  A model of a onedimensional springmass system 
Adder  An adder for arbitrarily many inputs of equal size 
TimeVaryingAffineSystem  Base class for a discrete or continuoustime, timevarying affine system, with potentially timevarying coefficients 
AffineSystem  A discrete OR continuous affine system (with constant coefficients) 
ConstantValueSource  A source block that always outputs a constant value 
ConstantVectorSource  A source block with a constant output port at all times 
Demultiplexer  This system splits a vector valued signal in its inputs of size size into size output scalar valued signals 
FirstOrderLowPassFilter  An elementwise first order low pass filter system that filters the ith input uᵢ into the ith output zᵢ 
Gain  An elementwise gain block with input u and output y = k * u with k a constant vector 
Integrator  An integrator for a continuous vector input 
LinearSystem  A discrete OR continuous linear system 
MatrixGain  A system that specializes LinearSystem by setting coefficient matrices A , B , and C to all be zero 
Multiplexer  This system combines multiple vectorvalued inputs into a vectorvalued output 
PassThrough  A pass through system with input u and output y = u 
RandomSource  A source block which generates random numbers at a fixed sampling interval, with a zeroorder hold between samples 
Saturation  An elementwise hard saturation block with inputs signal u , saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: 
SignalLog  This class serves as an inmemory cache of timedependent vector values 
SignalLogger  A sink block which logs its input to memory 
AffineLinearSystemTest  
TrajectorySource  A source block that generates the value of a Trajectory for a given time 
ZeroOrderHold  A ZeroOrderHold block with input u , which may be discrete or continuous, and discrete output y , where the y is sampled from u with a fixed period 
AccelerometerTestLogger  A sink block that logs the most recent plant state and the accelerometer reading 
DircolTrajectoryOptimization  DircolTrajectoryOptimization implements a direct colocation approach to trajectory optimization, as described in C 
DirectCollocationConstraint  Provides a base implementation and interface for a dynamic constraint (which is intended to be used with trajectory optimization, but is not specific to that purpose) 
SystemDirectCollocationConstraint  Implements a dynamic constraint which uses the continuous dynamics of a system 
DirectTrajectoryOptimization  DirectTrajectoryOptimization is an abstract class for direct method approaches to trajectory optimization 
test  
tools  
test  
SampleIndices  Describes the row indices of a Sample 
Sample  Specializes BasicVector with specific getters and setters 
SampleTranslator  Translates between LCM message objects and VectorBase objects for the Sample type 
util  
internal  
dummy_value< Eigen::AutoDiffScalar< DerType > >  Specializes common/dummy_value.h 
copyable_unique_ptr  A smart pointer with deep copy semantics 
dummy_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 
dummy_value< int >  
EigenSizeMinPreferDynamic  EigenSizeMinPreferDynamic<a, b>::value gives the min between compiletime sizes a and b 
EigenSizeMinPreferFixed  EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic 
MultiplyEigenSizes  MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes 
FunctionalForm  Represent an abstract form of a function of zero or more variables 
Variable  Represent a variable in a FunctionalForm 
Variables  Represent a set of Variable instances 
dummy_value< FunctionalForm >  
hash_value  Computes the hash value of v using std::hash 
hash_value< std::pair< T1, T2 > >  Computes the hash value of a pair p 
hash_value< std::vector< T > >  Computes the hash value of a vector vec 
hash_value< std::set< T > >  Computes the hash value of a set s 
hash_value< std::map< T1, T2 > >  Computes the hash value of a map map 
hash_value< symbolic::Monomial >  Computes the hash value of a Monomial 
never_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 
NiceTypeName  Obtains canonicalized, platformindependent, humanreadable names for arbitrarilycomplicated C++ types 
is_numeric  Is_numeric is true for types that are on the real line 
reinit_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 
dummy_value< symbolic::Expression >  Specializes common/dummy_value.h 
hash_value< symbolic::Expression >  Computes the hash value of a symbolic expression 
is_numeric< symbolic::Expression >  Specializes is_numeric to be false for symbolic::Expression type 
hash_value< symbolic::Formula >  Computes the hash value of a symbolic formula 
hash_value< symbolic::Variable >  Computes the hash value of a variable 
hash_value< symbolic::Variables >  Computes the hash value of a symbolic variables 
PiecewisePolynomialTrajectory  A PiecewisePolynomialTrajectory is a Trajectory that is represented by (implemented in terms of) a PiecewisePolynomial 
PiecewiseQuaternionSlerp  A class representing a trajectory for quaternions that are interpolated using piecewise slerp (spherical linear interpolation) 
Trajectory  A Trajectory represents a timevarying matrix of doubles 
TypeSafeIndex  A typesafe nonnegative index class 
DrakeCollision  
test  
OverlapFilterCallback  
BulletCollisionWorldWrapper  
UnknownShapeException  
BulletModel  
CollisionFilterGroup  The specification of a collision filter group: its name, bodies that belong to it, and the names of collision filter groups that it ignores 
CollisionFilterGroupManager  This class provides management utilities for the definition of collision filter groups for RigidBodyTree instances 
Element  The underyling primitive class used for collision analysis 
FCLModel  
Model  Model is an abstract base class of a collision model 
PointPair  Structure containing the results of a collision query 
UnusableModel  An unusable model, used when no collision detection backend is available 
DrakeRigidBodyConstraint  
DrakeShapes  
Element  
Geometry  
Sphere  
Box  
Cylinder  
Capsule  
Mesh  
MeshPoints  
VisualElement  
Eigen  
lcm  
DrakeLcm  
snopt  
std  STL namespace 
numeric_limits< Eigen::AutoDiffScalar< T > >  
less< drake::symbolic::Expression >  
equal_to< drake::symbolic::Expression >  
less< drake::symbolic::Formula >  
equal_to< drake::symbolic::Formula >  
less< drake::symbolic::Variable >  
equal_to< drake::symbolic::Variable >  
hash< drake::geometry::Identifier< Tag > >  Enables use of the identifier to serve as a key in STL containers 
tinyxml2  
YAML  
AllBodiesClosestDistanceConstraint  
Attachment  
BodyMotionData  
BodyMotionParams  
Bounds  
btOverlapFilterCallback  
ConstraintMatrixSingularError  
ContinuityConstraint  
DesiredBodyAcceleration  
DHomogTrans  
DrakeJoint  A joint defines a spatial relationship between two rigid bodies 
DrakeMexPointerTypeId  
DrakeMexPointerTypeId< KinematicsCache< double > >  
DrakeMexPointerTypeId< KinematicsCache< DrakeJoint::AutoDiffFixedMaxSize > >  
DrakeMexPointerTypeId< KinematicsCache< Eigen::AutoDiffScalar< Eigen::VectorXd > > >  
DrakeMexPointerTypeId< RigidBodyTree< double > >  
DrakeRobotState  
EulerConstraint  
ExponentialPlusPiecewisePolynomial  Y(t) = K * exp(A * (t  t_j)) * alpha.col(j) + piecewise_polynomial_part(t) 
FixedAxisOneDoFJoint  
FixedJoint  
ForceTorqueMeasurement  
GazeConstraint  
GazeDirConstraint  
GazeOrientConstraint  
GazeTargetConstraint  
GravityCompensationTorqueConstraint  
HardwareGains  
HardwareParams  
HelicalJoint  
IKoptions  
IKResults  Return type for simplified versions of IK functions 
InstantaneousQPController  
IntegratorParams  
JointNames  
JointSoftLimitParams  
KinematicModifications  
KinematicPath  
KinematicsCache  
KinematicsCacheElement  
KneeSettings  
LCMScope  
MexWrapper  
MinDistanceConstraint  
MultipleTimeKinematicConstraint  
MultipleTimeLinearPostureConstraint  
PIDOutput  
PiecewiseFunction  
PiecewisePolynomial  A scalar multivariate piecewise polynomial 
PiecewisePolynomialBase  
Point  
Point2LineSegDistConstraint  
Point2PointDistanceConstraint  
Polynomial  A scalar multivariate polynomial, modeled after the msspoly in spotless 
Monomial  An additive atom of a Polynomial: The product of any number of Terms and a coefficient 
Product  
Term  An individual variable raised to an integer power; e.g. x**2 
PositionConstraint  
PositionIndices  
PostureChangeConstraint  
PostureConstraint  
PrismaticJoint  A prismatic joint moves linearly along one axis 
QPControllerDebugData  
QPControllerOutput  
QPControllerParams  
QPControllerState  
QPLocomotionPlan  
QPLocomotionPlanSettings  
QuadraticLyapunovFunction  
QuasiStaticConstraint  Center of Mass (CoM) is within the support polygon 
QuatConstraint  
QuaternionFloatingJoint  Defines a 6 dof tree joint (mobilizer) that uses a unit quaternion as the generalized orientation coordinates 
RelativeGazeDirConstraint  
RelativeGazeTargetConstraint  
RelativePositionConstraint  
RelativeQuatConstraint  
RevoluteJoint  
RigidBody  
RigidBodyActuator  Defines a physical actuator (i.e., an electric motor and stepdown transmission) that operates on a joint 
RigidBodyConstraint  Base class 
RigidBodyFrame  Multibody systems typically have distinguished frames of interest that need to be monitored 
RigidBodyLoop  Defines a "loop joint" that models a kinematic loop formed by a chain of rigid bodies and their regular joints 
RigidBodySupportStateElement  
RigidBodyTree  Maintains a vector of RigidBody objects that are arranged into a kinematic tree via DrakeJoint objects 
RigidBodyTreeConstants  Defines RigidBodyTree constants 
RobotJointIndexMap  
RobotPropertyCache  
RollPitchYawFloatingJoint  
Side  
SingleTimeKinematicConstraint  
SingleTimeLinearPostureConstraint  
SplineInformation  
SupportStateElement  
TransformSpatial  
TrigPoly  A scalar multivariate polynomial containing sines and cosines 
Product  
SinCosVars  
TVLQRData  
ValueConstraint  
VRefIntegratorParams  
WholeBodyParams  
WorldCoMConstraint  
WorldEulerConstraint  
WorldFixedBodyPoseConstraint  
WorldFixedOrientConstraint  
WorldFixedPositionConstraint  
WorldGazeDirConstraint  
WorldGazeOrientConstraint  
WorldGazeTargetConstraint  
WorldPositionConstraint  
WorldPositionInFrameConstraint  
WorldQuatConstraint 