►C QpOutputTranslatorSystem  
CAtlasCommandTranslatorSystem  A class that extends QpOutputTranslatorSystem to output an additional bot_core::atlas_command_t 
►CAbstractValue  A fully typeerased container class 
CValue< T >  A container class for an arbitrary type T 
CAbstractValues  AbstractValues is a container for nonnumerical state and parameters 
CAccelerationKinematicsCache< T >  This class is one of the cache entries in MultibodyTreeContext 
CAccelerometerOutputConstants  
CAcrobot< T >  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
CAcrobot< double >  
CAcrobotParameters  This class is used to store the numerical parameters defining the model of an acrobot with the method MakeAcrobotPlant() 
►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 
CWsgAction  An Action that closes / opens the gripper 
CAddRotationMatrixBoxSphereIntersectionReturn  Some of the newly added variables in function AddRotationMatrixBoxSphereIntersectionMilpConstraints 
CAllegroHandMotionState  Detecting the state of the fingers: whether the joints are moving, or reached the destination, or got stuck by external collisions in the midway 
CAntiderivativeFunction< T >  A thin wrapper of the ScalarInitialValueProblem class that, in concert with Drake's ODE initial value problem solvers ("integrators"), provide the ability to perform quadrature on an arbitrary scalar integrable function 
CAntiderivativeFunction< double >  
CArcLengthParameterizedSpline  An extension for ignition::math::Splines that reparameterizes them by path length 
CArcOffset  Specification for path offset along a circular arc 
CArticulatedBodyInertia< T >  Articulated Body Inertia is the inertia that a body appears to have when it is the base (or root) of a rigidbody system, also referred to as Articulated Body in the context of articulated body algorithms 
CArticulatedBodyInertiaCache< T >  This class is one of the cache entries in MultibodyTreeContext 
Cassert_default_constructible< T >  
Cassert_if_is_constraint< F >  Template condition to only catch when Constraints are inadvertently passed as an argument 
CAssertionResultCollector  AssertionResultCollector helps with the creation of concise and welltraced testing subroutines when using googletest 
CAttachment  
CAutoDiffToGradientMatrix< Derived >  
CAutoDiffToValueMatrix< Derived >  
CAutomotiveSimulator< T >  AutomotiveSimulator is a helper class for constructing and running automotiverelated simulations 
CBarycentricMesh< T >  Represents a multilinear function (from vector inputs to vector outputs) by interpolating between points on a mesh using (triangular) barycentric interpolation 
CBinding< C >  A binding on constraint type C is a mapping of the decision variables onto the inputs of C 
CBinding< drake::solvers::BoundingBoxConstraint >  
CBinding< drake::solvers::Constraint >  
CBinding< drake::solvers::Cost >  
CBinding< drake::solvers::LinearComplementarityConstraint >  
CBinding< drake::solvers::LinearConstraint >  
CBinding< drake::solvers::LinearCost >  
CBinding< drake::solvers::LinearEqualityConstraint >  
CBinding< drake::solvers::LinearMatrixInequalityConstraint >  
CBinding< drake::solvers::LorentzConeConstraint >  
CBinding< drake::solvers::PositiveSemidefiniteConstraint >  
CBinding< drake::solvers::QuadraticCost >  
CBinding< drake::solvers::RotatedLorentzConeConstraint >  
CBinding< drake::solvers::VisualizationCallback >  
CJoint< T >::BluePrint  (Advanced) Structure containing all the information needed to build the MultibodyTree implementation for a Joint 
CBodyAcceleration  This class holds spatial acceleration for a rigid body 
CBodyMotionData  
CBodyMotionParams  
CBodyNodeTopology  Data structure to store the topological information associated with a tree node 
CBodyOfInterest  An object that holds important kinematic properties 
CBodyTopology  Data structure to store the topological information associated with a Body 
CBounds  
►CBranchPoint  A BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another 
CBranchPoint  Dragway's implementation of api::BranchPoint 
►CBranchPoint  Geometry_base's implementation of api::BranchPoint 
CMockBranchPoint  Mock api::BranchPoint implementation; see mock_geometry.h 
CBranchPoint  An implementation of api::BranchPoint 
CBranchPoint  An implementation of api::BranchPoint for RNDF 
►CbtOverlapFilterCallback  
COverlapFilterCallback  
CBuilder  A class to ease the construction of a RoadGeometry from Connection and DirectedWaypoint objects 
►CBuilderBase  Defines a builder interface for multilane 
CBuilder  Convenient builder class which makes it easy to construct a multilane road network 
►CBuilderFactoryBase  Factory interface to construct BuilderBase instances 
CBuilderFactory  Implements a BuilderFactoryBase to construct Builder objects 
CBulletCollisionWorldWrapper  
CCache  Stores all the CacheEntryValue objects owned by a particular Context, organized to allow fast access using a CacheIndex as an index 
CCacheEntry  A CacheEntry belongs to a System and represents the properties of one of that System's cached computations 
CCacheEntryValue  This is the representation in the Context for the value of one of a System's CacheEntry objects 
CCameraInfo  Simple data structure for camera information that includes the image size and camera intrinsic parameters 
CCartesianSetpoint< Scalar >  This is used to compute target spatial acceleration, which is the input to the inverse dynamics controller 
CClosestPose< T >  ClosestPose bundles together the RoadOdometry of a particular target along with its distance measure relative to the ego vehicle 
CCodeGenVisitor  Visitor class for code generation 
CCollisionFilterGroup< T >  The specification of a collision filter group: its name, bodies that belong to it, and the names of collision filter groups that it ignores 
CCollisionFilterGroup< double >  
CCollisionFilterGroupManager< T >  This class provides management utilities for the definition of collision filter groups for RigidBodyTree instances 
CCollisionFilterGroupManager< double >  
CColor< T >  Holds r, g, b values to represent a color pixel 
CColorPalette< IdType >  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) 
CColorPalette< int >  
CCompliantContactModel< T >  This class encapsulates the compliant contact model force computations as described in detail in Compliant Contact in Drake 
CCompliantContactModel< double >  
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< T >  This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection 
CDiagramCompositeEventCollection< T >  CompositeEventCollection for a Diagram 
CLeafCompositeEventCollection< T >  A CompositeEventCollection for a LeafSystem 
►CCompositeEventCollection< AutoDiffXd >  
CLeafCompositeEventCollection< AutoDiffXd >  
►CCompositeEventCollection< double >  
CLeafCompositeEventCollection< double >  
CConditionTraits< symbolic::Formula >  
CConnection  A container that holds the information needed by a Builder to construct one or more Lane objects 
CConnection  Representation of a reference path connecting two endpoints 
CPidControlledSystem< T >::ConnectResult  The return type of ConnectController 
CMapKeyRange< K, V >::ConstIterator  
►CConstrainedValues  Base class for specifying various desired objectives 
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 
CConstraintAccelProblemData< T >  Structure for holding constraint data for computing forces due to constraints and the resulting multibody accelerations 
CConstraintRelaxingIk  A wrapper class around the IK planner 
CConstraintSolver< T >  Solves constraint problems for constraint forces 
CConstraintSolver< double >  
CConstraintVelProblemData< T >  Structure for holding constraint data for computing constraint forces at the velocitylevel (i.e., impact problems) 
►CContactDetail< T >  The base class for defining a contact detail 
CPointContactDetail< T >  An implementation of the ContactDetail where the contact details consist of a single ContactForce 
CContactForce< T >  The data for a single contact force applied to one body of a contacting pair 
CContactInfo< T >  A class containing information regarding contact response between two bodies including: 
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 
CContactResultantForceCalculator< T >  This is a utility class for replacing a set of force/torques by an equivalent force/torque (defined by the ContactForce class) 
CContactResults< T >  A class containing the contact results (contact points and response spatial forces for each colliding pair of collision elements) as well as the sum of all JᵀF for all contact, where J is the contact point Jacobian, and F is the contact force 
CContactResults< T >  A container class storing the contact results information for each contact pair for a given state of the simulation 
►CContextMessageInterface  
►CContextBase  Provides nontemplatized Context functionality shared by the templatized derived classes 
►CContext< AutoDiffXd >  
►CLeafContext< AutoDiffXd >  
CMultibodyTreeContext< AutoDiffXd >  
►CContext< double >  
CDiagramContext< double >  
►CLeafContext< double >  
CMultibodyTreeContext< double >  
CContext< drake::symbolic::Expression >  
►CContext< T >  Context is an abstract class template that represents all the typed values that are used in a System's computations: time, numericvalued input ports, numerical state, and numerical parameters 
CDiagramContext< T >  The DiagramContext is a container for all of the data necessary to uniquely determine the computations performed by a Diagram 
►CLeafContext< T >  LeafContext contains all prerequisite data necessary to uniquely determine the results of computations performed by the associated LeafSystem 
CGeometryContext< T >  The custom leaf context type for SceneGraph 
CMultibodyTreeContext< T >  MultibodyTreeContext is an object that contains all the information needed to uniquely determine the state of a MultibodyTree 
►CContinuousState< T >  ContinuousState is a view of, and optionally a container for, all the continuous state variables xc of a Drake System 
CDiagramContinuousState< T >  DiagramContinuousState is a ContinuousState consisting of Supervectors xc, q, v, z over the corresponding entries in a set of referenced ContinuousState objects, which may or may not be owned by this DiagramContinuousState 
CContinuousState< AutoDiffXd >  
CContinuousState< double >  
CContinuousState< drake::symbolic::Expression >  
CCoulombFriction< T >  Parameters for Coulomb's Law of Friction, namely: 
CCoulombFriction< double >  
CCubicPolynomial  A cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3 
CCurve2< T >  Curve2 represents a path through twodimensional Cartesian space 
CKinematicsCache< T >::DataInCalcFrameSpatialVelocityJacobianInWorldFrame  Preallocated variables used in CalcFrameSpatialVelocityJacobianInWorldFrame 
CKinematicsCache< T >::DataInGeometricJacobian  Preallocated variables used in GeometricJacobian 
CDataTypeTraits< DataType, false >  
CDelegatingHasher  An adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtimeprovided std::function of the same signature 
►CDenseOutput< T >  An interface for dense output of ODE solutions, to efficiently approximate them at arbitrarily many points when solving them numerically (see IntegratorBase class documentation) 
►CScalarDenseOutput< T >  A DenseOutput class interface extension to deal with scalar ODE solutions 
CScalarViewDenseOutput< T >  A ScalarDenseOutput class implementation that wraps a DenseOutput class instance and behaves as a view to one of its elements 
►CStepwiseDenseOutput< T >  A DenseOutput class interface extension, geared towards stepwise construction procedures 
CHermitianDenseOutput< T >  A StepwiseDenseOutput class implementation using Hermitian interpolators, and therefore a continuous extension of the solution 𝐱(t) (see [Engquist, 2105]) 
►CDenseOutput< double >  
CStepwiseDenseOutput< double >  
CDependencyGraph  Represents the portion of the complete dependency graph that is a subgraph centered on the owning subcontext, plus some edges leading to other subcontexts 
CDependencyTracker  Manages value interdependencies for a particular value or set of values in a Context 
CDepthSensorSpecification  Holds a DepthSensor's specification 
CDescriptorType  Describes an descriptor field with a name and the descriptor's size 
CDesiredBodyAcceleration  
CDesiredMotionParam  Struct for storing parameters for generating a desired acceleration objective \( \dot{v}_d \) for the QP inverse dynamics controller 
CDHomogTrans< DerivedQdotToV >  
CDiagramBuilder< T >  DiagramBuilder is a factory class for Diagram 
CDiagramBuilder< double >  
CDifferentialInverseKinematicsParameters  Contains parameters for differential inverse kinematics 
CDifferentialInverseKinematicsResult  
CDirectedEdgeIndex  Index for a directed edge in a GeoMesh 
CDirectedWaypoint  A container that holds the information needed by a Builder to construct a Lane from a sequence of ignition::rndf::Waypoint objects 
CDirectionChangeLimiter< T >  This struct implements an internal (thus within internal:: ) detail of the implicit Stribeck solver 
►CDiscreteValues< T >  DiscreteValues is a container for numerical but noncontinuous state and parameters 
CDiagramDiscreteValues< T >  DiagramDiscreteValues is a DiscreteValues container comprised recursively of a sequence of child DiscreteValues objects 
CDiscreteValues< AutoDiffXd >  
CDiscreteValues< double >  
CDiscreteValues< drake::symbolic::Expression >  
CDrakeJoint  A joint defines a spatial relationship between two rigid bodies 
►CDrakeJointImpl  
CFixedAxisOneDoFJoint< Derived >  
►CFixedAxisOneDoFJoint< HelicalJoint >  
CHelicalJoint  
►CFixedAxisOneDoFJoint< PrismaticJoint >  
CPrismaticJoint  A prismatic joint moves linearly along one axis 
►CFixedAxisOneDoFJoint< RevoluteJoint >  
CRevoluteJoint  
CFixedJoint  
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 
CRollPitchYawFloatingJoint  
CDrakeKukaIIwaRobot< T >  This class is a MultibodyTree model for a 7DOF Kuka iiwa robot arm 
►CDrakeLcmInterface  A pure virtual interface that enables LCM to be mocked 
CDrakeLcm  A wrapper around a real LCM instance 
CDrakeLcmLog  A LCM interface for logging LCM messages to a file or playing back from a existing log 
CDrakeMockLcm  A mock LCM instance 
CDrakeRobotState  
Cdummy_value< T >  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 
CDynamicProgrammingOptions  Consolidates the many possible options to be passed to the dynamic programming algorithms 
CEigenPtr< PlainObjectType >  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 
CEigenPtr< const MatrixX< T > >  
CEigenPtr< const VectorX< T > >  
CEigenSizeMinPreferDynamic< a, b >  EigenSizeMinPreferDynamic<a, b>::value gives the min between compiletime sizes a and b 
CEigenSizeMinPreferFixed< a, b >  EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic 
►CElement  
CElement  The underyling primitive class used for collision analysis 
CVisualElement  
CEndLane  Provides methods to build an EndLane::Spec 
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 
CEndReference  Provides methods to build an EndReference::Spec 
CEnvironment  Represents a symbolic environment (mapping from a variable to a value) 
Cequal_to< drake::symbolic::Expression >  
Cequal_to< drake::symbolic::Formula >  
Cequal_to< drake::symbolic::Variable >  
CGeoVertex::Equiv  An equivalence operation suitable for std::unordered_map 
CGeoNormal::Equiv  An equivalence operation suitable for std::unordered_map 
►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 
►CConstraint  A constraint is a function + lower and upper bounds 
CAngleBetweenVectorsConstraint  
CGazeTargetConstraint  
COrientationConstraint  
CPositionConstraint  
CEvaluatorConstraint< EvaluatorType >  A constraint that may be specified using another (potentially nonlinear) evaluator 
CExpressionConstraint  Impose a generic (potentially nonlinear) constraint represented as a vector of symbolic Expression 
CLinearComplementarityConstraint  Implements a constraint of the form: 
►CLinearConstraint  Implements a constraint of the form \( lb <= Ax <= ub \) 
CBoundingBoxConstraint  Implements a constraint of the form \( lb <= x <= ub \) 
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 
CLorentzConeConstraint  Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone 
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 
CRotatedLorentzConeConstraint  Constraining that the linear expression \( z=Ax+b \) lies within rotated Lorentz cone 
CGenericTrivialConstraint1  
CQuasiStaticConstraintWrapper  
CSingleTimeKinematicConstraintWrapper  
CDirectCollocationConstraint  Implements the direct collocation constraints for a firstorder hold on the input and a cubic polynomial representation of the state trajectories 
►CEvaluatorConstraint< PolynomialEvaluator >  
CPolynomialConstraint  Lb[i] <= Pi <= ub[i], where each P[i] is a multivariate polynomial in x, y.. 
►CCost  Provides an abstract base for all costs 
CEvaluatorCost< EvaluatorType >  A cost that may be specified using another (potentially nonlinear) evaluator 
CLinearCost  Implements a cost of the form
\[ a'x + b \]

CQuadraticCost  Implements a cost of the form
\[ .5 x'Qx + b'x + c \]

CGenericTrivialCost1  
►CEvaluatorCost< PolynomialEvaluator >  
CPolynomialCost  Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y, .. 
CFunctionEvaluator< F >  An evaluator that may be specified using a callable object 
CPolynomialEvaluator  Implements an evaluator of the form P(x, y...) where P is a multivariate polynomial in x, y, .. 
CVisualizationCallback  Defines a simple evaluator with no outputs that takes a callback function pointer 
►CGeneralizedConstraintForceEvaluator  This evaluator computes the generalized constraint force Jᵀλ ∈ ℝ ᴺᵛ, where Nᵥ is the size of the generalized velocities 
CJointLimitConstraintForceEvaluator  Evaluates the joint limit constraint force 
CPositionConstraintForceEvaluator  Evaluates the generalized constraint force from RigidBodyTree::positionConstraint 
►CEvent< T >  Abstract base class that represents an event 
CDiscreteUpdateEvent< T >  This class represents a discrete update event 
CPublishEvent< T >  This class represents a publish event 
CUnrestrictedUpdateEvent< T >  This class represents an unrestricted update event 
CEvent< double >  
►CEventCollection< EventType >  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) 
CDiagramEventCollection< EventType >  A concrete class that holds all simultaneous homogeneous events for a Diagram 
CLeafEventCollection< EventType >  A concrete class that holds all simultaneous homogeneous events for a LeafSystem 
CEventCollection< drake::systems::DiscreteUpdateEvent< AutoDiffXd > >  
CEventCollection< drake::systems::DiscreteUpdateEvent< double > >  
CEventCollection< drake::systems::DiscreteUpdateEvent< T > >  
CEventCollection< drake::systems::PublishEvent< AutoDiffXd > >  
CEventCollection< drake::systems::PublishEvent< double > >  
CEventCollection< drake::systems::PublishEvent< T > >  
CEventCollection< drake::systems::UnrestrictedUpdateEvent< AutoDiffXd > >  
CEventCollection< drake::systems::UnrestrictedUpdateEvent< double > >  
CEventCollection< drake::systems::UnrestrictedUpdateEvent< T > >  
►CEventData  Base class for storing triggerspecific data to be passed to event handlers 
CPeriodicEventData  A token describing an event that recurs on a fixed period 
CWitnessTriggeredEventData< T >  Class for storing data from a witness function triggering to be passed to event handlers 
►Cexception  STL class 
►Cruntime_error  STL class 
Cassertion_error  This is what DRAKE_ASSERT and DRAKE_DEMAND throw when our assertions are configured to throw 
CUnknownShapeException  
CSymbolicError  
CExpression  Represents a symbolic form of an expression 
CExpressionAddFactory  Factory class to help build ExpressionAdd expressions 
►CExpressionCell  Represents an abstract class which is the base of concrete symbolicexpression classes 
►CBinaryExpressionCell  Represents the base class for binary expressions 
CExpressionAtan2  Symbolic expression representing atan2 function (arctangent function with two arguments) 
CExpressionDiv  Symbolic expression representing division 
CExpressionMax  Symbolic expression representing max function 
CExpressionMin  Symbolic expression representing min function 
CExpressionPow  Symbolic expression representing power function 
CExpressionAdd  Symbolic expression representing an addition which is a sum of products 
CExpressionConstant  Symbolic expression representing a constant 
CExpressionIfThenElse  Symbolic expression representing ifthenelse expression 
CExpressionMul  Symbolic expression representing a multiplication of powers 
CExpressionNaN  Symbolic expression representing NaN (notanumber) 
CExpressionUninterpretedFunction  Symbolic expression representing an uninterpreted function 
CExpressionVar  Symbolic expression representing a variable 
►CUnaryExpressionCell  Represents the base class for unary expressions 
CExpressionAbs  Symbolic expression representing absolute value function 
CExpressionAcos  Symbolic expression representing arccosine function 
CExpressionAsin  Symbolic expression representing arcsine function 
CExpressionAtan  Symbolic expression representing arctangent function 
CExpressionCeiling  Symbolic expression representing ceil function 
CExpressionCos  Symbolic expression representing cosine function 
CExpressionCosh  Symbolic expression representing hyperbolic cosine function 
CExpressionExp  Symbolic expression representing exponentiation using the base of natural logarithms 
CExpressionFloor  Symbolic expression representing floor function 
CExpressionLog  Symbolic expression representing logarithms 
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 
CExpressionMulFactory  Factory class to help build ExpressionMul expressions 
CFaceEdgeIndex  Index for a face edge in a GeoMesh 
CFaceVertexIndex  Index of a face vertex in a GeoMesh 
CFields  Allows combination of BaseField and DescriptorType for a PointCloud 
CFindResourceResult  Models the outcome of drake::FindResource 
CFixedInputPortValue  A FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports 
CFloatingJointConstants  Defines constants used by AddFloatingJoint() 
CFNV1aHasher  The FNV1a hash algorithm, used for hash_append generic hashing 
CForceElementTopology  Data structure to store the topological information associated with a ForceElement 
CForceTorqueMeasurement  
CFormula  Represents a symbolic form of a firstorder logic formula 
►CFormulaCell  Represents an abstract class which is the base of concrete symbolicformula classes (i.e 
CFormulaFalse  Symbolic formula representing false 
CFormulaForall  Symbolic formula representing universal quantifications (∀ x₁, ..., * xn 
CFormulaIsnan  Symbolic formula representing isnan predicate 
CFormulaNot  Symbolic formula representing negations (¬f) 
CFormulaPositiveSemidefinite  Symbolic formula representing positivesemidefinite (PSD) constraint 
CFormulaTrue  Symbolic formula representing true 
CFormulaVar  Symbolic formula representing a Boolean variable 
►CNaryFormulaCell  Represents the base class for Nary logic operators (∧ and ∨) 
CFormulaAnd  Symbolic formula representing conjunctions (f1 ∧ .. 
CFormulaOr  Symbolic formula representing disjunctions (f1 ∨ .. 
►CRelationalFormulaCell  Represents the base class for relational operators (==, !=, <, <=, >, >=) 
CFormulaEq  Symbolic formula representing equality (e1 = e2) 
CFormulaGeq  Symbolic formula representing 'greaterthanorequalto' (e1 ≥ e2) 
CFormulaGt  Symbolic formula representing 'greaterthan' (e1 > e2) 
CFormulaLeq  Symbolic formula representing 'lessthanorequalto' (e1 ≤ e2) 
CFormulaLt  Symbolic formula representing 'lessthan' (e1 < e2) 
CFormulaNeq  Symbolic formula representing disequality (e1 ≠ e2) 
CFrameCache< T >  Keeps a set of frames and the transforms that relate them, using a root or fixed frame to conjoin them all 
CFramedIsometry3< T >  An isometric transform along with the frame in which it is defined 
CFrameKinematicsVector< KinematicsValue >  A FrameKinematicsVector is used to report kinematics data for registered frames (identified by unique FrameId values) to SceneGraph 
CFrameTopology  Data structure to store the topological information associated with a Frame 
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 torquefree rigid body B with axially symmetric inertia, in a Newtonian frame (World) N 
CFromDoubleTraits  A concrete traits class providing sugar to support for converting only from the double scalar type 
Cfunction_info< Func, Return, Args >  
CFunctionTraits< F >  FunctionTraits 
CFunctionTraits< std::reference_wrapper< F > >  
CFunctionTraits< std::shared_ptr< F > >  
CFunctionTraits< std::unique_ptr< F > >  
Cfunctor_helpers  
►CGenericPlan< T >  This class represents a plan interpretor, which conceptually serves as a bridge between a high level planner (e.g 
CManipulatorMoveEndEffectorPlan< T >  A concrete plan that sets up a Cartesian tracking objective for the end effector assuming no contacts 
CGenericPlan< double >  
CGenericTrivialCost2  
CGeoFace  A world frame face: a sequence of vertices with corresponding normals 
CGeoMesh  A world frame mesh: a collection of GeoFaces 
►CGeometry  
CBox  
CCapsule  
CCylinder  
CMesh  
CMeshPoints  
CSphere  
CGeometryFrame  This simple class carries the definition of a frame used in the SceneGraph 
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 
►CGeometryProperties  The base class for defining a set of geometry properties 
CIllustrationProperties  The set of properties for geometry used in an "illustration" role 
CProximityProperties  The set of properties for geometry used in a proximity role 
CGeometrySet  The GeometrySet, as its name implies, is a convenience class for defining a set of geometries 
CGeometryState< T >  The contextdependent state of SceneGraph 
CGeometryState< double >  
CGeoNormal  A world frame normal vector 
CGeoPositionT< T >  A position in 3dimensional geographical Cartesian space, i.e., in the world frame, consisting of three components x, y, and z 
CGeoPositionT< double >  
CGeoVertex  A world frame vertex 
CGetSubMatrixGradientArray< QSubvectorSize, Derived, NRows, NCols >  
CGetSubMatrixGradientSingleElement< QSubvectorSize, Derived >  
CGloptiPolyConstrainedMinimizationProblem  GloptiPolyConstrainedMinimization 
CGradedReverseLexOrder< VariableOrder >  Implements Graded reverse lexicographic order 
CGradient< Derived, Nq, DerivativeOrder >  
CGradient< Derived, Nq, 1 >  
CGrayCodesMatrix< NumDigits >  GrayCodesMatrix::type returns an Eigen matrix of integers 
CGrayCodesMatrix< Eigen::Dynamic >  
CGroup  A group of Connections 
►CGroupFactoryBase  Factory interface to construct Group instances 
CGroupFactory  Implements a GroupFactoryBase to construct Group objects 
CGurobiSolverDetails  
CGyroscopeOutputConstants  Defines the semantics of each index in GyroscopeOutput's vector 
CHardwareGains  
CHardwareParams  
Chash< drake::geometry::Identifier< Tag > >  Enables use of the identifier to serve as a key in STL containers 
Chash< drake::TypeSafeIndex< Tag > >  Specialization of std::hash for drake::TypeSafeIndex<Tag> 
CHBounds  Bounds in the elevation dimension (h component) of a Lane frame, consisting of a pair of minimum and maximum h value 
CIdentifier< Tag >  A simple identifier class 
CIdentifier< class FrameTag >  
CIdentifier< class GeometryTag >  
CIdentifier< class SourceTag >  
►CRoadGeometry::IdIndex  Abstract interface for a collection of methods which allow accessing objects in a RoadGeometry's object graph (Lanes, Segments, Junctions, BranchPoints) by their unique id's 
CBasicIdIndex  Basic generalpurpose concrete implementation of the RoadGeometry::IdIndex interface 
CIdmPlanner< T >  IdmPlanner implements the IDM (Intelligent Driver Model) equation governing longitudinal accelerations of a vehicle in singlelane traffic [1, 2] 
CConstraintRelaxingIk::IkCartesianWaypoint  Cartesian waypoint 
CIKoptions  
CIKResults  Return type for simplified versions of IK functions 
CIKTrajectoryHelper  This class is a helper for backend implementations of inverse kinematics trajectory planning 
CImage< kPixelType >  Simple data format for Image 
CImage< PixelType::kDepth32F >  
CImage< PixelType::kLabel16I >  
CImage< PixelType::kRgba8U >  
CImageTraits< PixelType >  Traits class for Image 
CImageTraits< PixelType::kBgr8U >  
CImageTraits< PixelType::kBgra8U >  
CImageTraits< PixelType::kDepth16U >  
CImageTraits< PixelType::kDepth32F >  
CImageTraits< PixelType::kExpr >  
CImageTraits< PixelType::kGrey8U >  
CImageTraits< PixelType::kLabel16I >  
CImageTraits< PixelType::kRgb8U >  
CImageTraits< PixelType::kRgba8U >  
CImplicitStribeckSolver< T >  
CIndexFace  A face — a sequence of vertices with normals — in which the vertices and normals are represented by integer indices into some other container/dictionary 
CInitializeAutoDiffTupleHelper< Index >  Helper for initializeAutoDiffTuple function (recursive) 
CInitializeAutoDiffTupleHelper< 0 >  Helper for initializeAutoDiffTuple function (base case) 
CInitialValueProblem< T >  A general initial value problem (or IVP) representation class, that allows evaluating the 𝐱(t; 𝐤) solution function to the given ODE d𝐱/dt = f(t, 𝐱; 𝐤), where f : t ⨯ 𝐱 → ℝⁿ, t ∈ ℝ, 𝐱 ∈ ℝⁿ, 𝐤 ∈ ℝᵐ, provided an initial condition 𝐱(t₀; 𝐤) = 𝐱₀ 
CInitialValueProblem< double >  
►CInputPortBase  An InputPort is a System resource that describes the kind of input a System accepts, on a given port 
CInputPort< T >  This extends InputPortBase with some scalar typedependent methods 
CInputPort< double >  
CInstantaneousQPController  
►Cintegral_constant  
Cis_eigen_nonvector_expression_double_pair< DerivedV, DerivedB >  
Cis_eigen_nonvector_of< Derived, Scalar >  
Cis_eigen_scalar_same< Derived, Scalar >  
Cis_eigen_vector< Derived >  
Cis_eigen_vector_expression_double_pair< DerivedV, DerivedB >  
Cis_eigen_vector_of< Derived, Scalar >  
Cis_binding_compatible< F, C >  Enables us to catch and provide a meaningful assertion if a Constraint is passed in, when we should have a Cost 
Cis_cost_functor_candidate< F >  Template condition to check if F is a candidate to be used to construct a FunctionCost object for generic costs 
CHermitianDenseOutput< T >::IntegrationStep  An integration step representation class, holding just enough for Hermitian interpolation: three (3) related sets containing step times {t₀, ..., tᵢ₋₁, tᵢ} where tᵢ ∈ ℝ, step states {𝐱₀, ..., 𝐱ᵢ₋₁, 𝐱ᵢ} where 𝐱ᵢ ∈ ℝⁿ, and state derivatives {d𝐱/dt₀, ..., d𝐱/dtᵢ₋₁, d𝐱/dtᵢ} where d𝐱/dtᵢ ∈ ℝⁿ 
►CIntegratorBase< T >  An abstract class for an integrator for ODEs and DAEs as represented by a Drake System 
CExplicitEulerIntegrator< T >  A firstorder, explicit Euler integrator 
CImplicitEulerIntegrator< T >  A firstorder, fully implicit integrator with second order error estimation 
CRungeKutta2Integrator< T >  A secondorder, explicit Runge Kutta integrator 
CRungeKutta3Integrator< T >  A thirdorder Runge Kutta integrator with a third order error estimate 
CSemiExplicitEulerIntegrator< T >  A firstorder, semiexplicit Euler integrator 
CIntegratorBase< double >  
CIntegratorParams  
CInternalFrame  This is the internal representation of a GeometryFrame 
CInternalGeometry  The internal representation of the fixed portion of the scene graph geometry 
CInvalidDepth  Set of constants used to represent invalid depth values 
CInverseFunctionInterpolator  A linear interpolator for arbitrary inverse functions 
CInverseKinematics  Solves an inverse kinematics (IK) problem on a MultibodyPlant, to find the postures of the robot satisfying certain constraints 
►Cis_base_of  
Cis_eigen_type< Derived >  
►Cis_convertible  
Cis_convertible_workaround< A, B >  
Cis_convertible_workaround< std::unique_ptr< A >, std::shared_ptr< B > >  
CIsoLaneVelocity  Isometric velocity vector in a Lane frame 
CIterationStats  Struct used to store information about the iteration process performed by ImplicitStribeckSolver 
CJointActuatorTopology  Data structure to store the topological information associated with a JointActuator 
CJoint< T >::JointImplementation  (Advanced) A Joint is implemented in terms of MultibodyTree elements such as bodies, mobilizers, force elements and constraints 
CJointNames  
CJointSoftLimitParams  
►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 
CJunction  Dragway's implementation of api::Junction 
►CJunction  Geometry_base's implementation of api::Junction 
CMockJunction  Mock api::Junction implementation; see mock_geometry.h 
CJunction  An api::Junction implementation 
CJunction  An api::Junction implementation for RNDF 
CKinematicModifications  
CKinematicPath  
CKinematicsCache< T >  
CKinematicsCache< double >  
CKinematicsCache< Scalar >  
CKinematicsCacheElement< T >  
CKinematicsCacheElement< double >  
CKinematicsCacheElement< Scalar >  
CKinematicsCacheHelper< Scalar >  Helper class to avoid recalculating a kinematics cache which is going to be used repeatedly by multiple other classes 
CKinematicsCacheHelper< double >  
CKinematicsCacheWithVHelper< Scalar >  Stores and updates the kinematics cache for the rigid body tree 
CKinematicsResults< T >  A class containing the kinematics results from a RigidBodyPlant system 
CKneeSettings  
CKukaIiwaModelBuilder< T >  
CKukaRobotJointReactionForces< T >  Utility struct to assist with returning joint torques/forces 
CLabel  Set of labels used for label image 
►CLane  A Lane represents a lane of travel in a road network 
CLane  Dragway's implementation of api::Lane 
►CLane  Geometry_base's implementation of api::Lane 
CMockLane  Mock api::Lane implementation; see mock_geometry.h 
CLane  Base class for the multilane implementation of api::Lane 
►CLane  Base class for the RNDF implementation of api::Lane 
CSplineLane  Specialization of drake::maliput::rndf::Lane with a spline curve as its reference path 
CLaneDirection  LaneDirection holds the lane that a MaliputRailcar is traversing and the direction in which it is moving 
CLaneEnd  A specific endpoint of a specific Lane 
►CLaneEndSet  A set of LaneEnds 
CLaneEndSet  Dragway's implementation of api::LaneEndSet 
CLaneEndSet  Geometry_base's implementation of api::LaneEndSet 
CLaneEndSet  An implementation of LaneEndSet 
CLaneEndSet  An implementation of LaneEndSet for RNDF 
CLaneLayout  Wraps all the lanerelated specifications in a Connection 
CLanePositionT< T >  A 3dimensional position in a Lane frame, consisting of three components: 
CLanePositionT< double >  
CLaneSRange  Directed longitudinal range of a specific Lane, identified by a LaneId 
CLaneSRoute  A longitudinal route, possibly spanning multiple (endtoend) lanes 
►CLcmAndVectorBaseTranslator  Defines an abstract parent class of all translators that convert between LCM message bytes and drake::systems::VectorBase objects 
CIiwaCommandTranslator  A translator between the LCM message type lcmt_iiwa_command and its vectorized representation, IiwaCommand<double> 
CSchunkWsgCommandTranslator  A translator between the LCM message type lcmt_schunk_wsg_command and its vectorized representation, SchunkWsgCommand 
CLcmtDrakeSignalTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_drake_signal 
CPoseStampedTPoseVectorTranslator  The translator that converts from/to rendering::PoseVector<double> to/from lcm message bytes which encodes robotlocomotion::pose_stamped_t 
CViewerDrawTranslator  Specializes LcmAndVectorBaseTranslator to handle LCM messages of type drake::lcmt_viewer_draw 
CLcmDrivenLoop  This class implements a loop that's driven by a Lcm message 
CLcmImageTraits< PixelType >  
CLcmImageTraits< PixelType::kBgr8U >  
CLcmImageTraits< PixelType::kBgra8U >  
CLcmImageTraits< PixelType::kDepth16U >  
CLcmImageTraits< PixelType::kDepth32F >  
CLcmImageTraits< PixelType::kGrey8U >  
CLcmImageTraits< PixelType::kLabel16I >  
CLcmImageTraits< PixelType::kRgb8U >  
CLcmImageTraits< PixelType::kRgba8U >  
►CLcmMessageToTimeInterface  A generic translator interface that extracts time in seconds from an abstract type 
CUtimeMessageToSeconds< MessageType >  A translator class for Lcm message types that have a "utime" field, which is in micro seconds 
CLcmPixelTraits< PixelFormat >  
CLcmPixelTraits< PixelFormat::kBgr >  
CLcmPixelTraits< PixelFormat::kBgra >  
CLcmPixelTraits< PixelFormat::kDepth >  
CLcmPixelTraits< PixelFormat::kGrey >  
CLcmPixelTraits< PixelFormat::kLabel >  
CLcmPixelTraits< PixelFormat::kRgb >  
CLcmPixelTraits< PixelFormat::kRgba >  
CLcmReceiveThread  Maintains a thread that receives LCM messages and dispatches the messages to the appropriate message handlers 
CLcmTranslatorDictionary  A dictionary that maps between LCM channel names and translators that convert between LCM message objects and VectorBase objects 
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 >  
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 
CLinearQuadraticRegulatorResult  
►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) 
CLineOffset  Specification for path offset along a line 
CLogarithmicSos2NewBinaryVariables< NumLambda >  The size of the new binary variables in the compile time, for Special Ordered Set of type 2 (SOS2) constraint 
CLogarithmicSos2NewBinaryVariables< Eigen::Dynamic >  
CLowerBoundedProblem  This test comes from Section 3.4 of Handbook of Test Problems in Local and Global Optimization 
CMapKeyRange< K, V >  A const range iterator through the keys of an unordered map 
CMassDamperSpringAnalyticalSolution< T >  This class provides an analytical solution to a massdamperspring system 
►CMatcherInterface  
CArcOffsetMatcher  Wraps an ArcOffset comparison into a MatcherInterface 
CEndLaneSpecMatcher  Wraps a EndLane::Spec comparison into a MatcherInterface 
CEndReferenceSpecMatcher  Wraps a EndReference::Spec comparison into a MatcherInterface 
CHBoundsMatcher  Wraps api::HBounds comparison into a MatcherInterface 
CLaneLayoutMatcher  Wraps a LineOffset comparison into a MatcherInterface 
CLineOffsetMatcher  Wraps a LineOffset comparison into a MatcherInterface 
CStartLaneSpecMatcher  Wraps a StartLane::Spec comparison into a MatcherInterface 
CStartReferenceSpecMatcher  Wraps a StartReference::Spec comparison into a MatcherInterface 
CMatGradMult< DerivedDA, DerivedB >  
CMatGradMultMat< DerivedA, DerivedB, DerivedDA >  
►CMathematicalProgram  MathematicalProgram stores the decision variables, the constraints and costs of an optimization problem 
CGlobalInverseKinematics  Solves the inverse kinematics problem as a mixed integer convex optimization problem 
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 
CDistanceToTetrahedronExample  
CUnitLengthProgramExample  A simple nonconvex problem with a quadratic equality constraint min 0 s.t xᵀx = 1 This test is meant to verify that we can add a quadratic constraint to a program, and solve it through nonlinear optimization 
►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 
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 
CMathematicalProgramResult  The result returned by MathematicalProgram::Solve() 
►CMathematicalProgramSolverInterface  Interface used by implementations of individual solvers 
CDrealSolver  
CEqualityConstrainedQPSolver  
CGurobiSolver  
CIpoptSolver  
CLinearSystemSolver  
CMobyLCPSolver< T >  A class for solving Linear Complementarity Problems (LCPs) 
CMosekSolver  
CNloptSolver  
COsqpSolver  
CScsSolver  
CSnoptSolver  
CUnrevisedLemkeSolver< T >  A class for the Unrevised Implementation of Lemke Algorithm's for solving Linear Complementarity Problems (LCPs) 
CMobyLCPSolver< double >  
CUnrevisedLemkeSolver< double >  
CMatlabRemoteVariable  Holds a reference to a variable stored on the matlab client, which can be passed back into a future lcm_call_matlab call 
CMatrixData  
►CMGIntegrator  
CMGChaoticBabyboot  
CMGKukaIIwaRobot< T >  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 
CMGKukaIIwaRobotAutoGenerated  
CMinDistanceFromPlaneToOrigin  An SOCP with Lorentz cone and rotated Lorentz cone constraints 
CMirrorDef< A, B >  Defines a function in object a and mirrors def calls to object b 
CMixedIntegerBranchAndBound  Given a mixedinteger optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branchandbound process 
CMixedIntegerBranchAndBoundNode  A node in the branchandbound (bnb) tree 
CMixedIntegerRotationConstraintGenerator  We relax the nonconvex SO(3) constraint on rotation matrix R to mixedinteger linear constraints 
CConstraintSolver< T >::MlcpToLcpData  Structure used to convert a mixed linear complementarity problem to a pure linear complementarity problem (by solving for free variables) 
CMobilizerTopology  Data structure to store the topological information associated with a Mobilizer object 
CMobyLcpSolverId  Nontemplate class for MobyLcpSolver<T> constants 
►CModel  Model is an abstract base class of a collision model 
CBulletModel  
CFclModel  
CUnusableModel  An unusable model, used when no collision detection backend is available 
CModelInstanceInfo< T >  
CModelValues  Represents models for a sequence of AbstractValues (usually a sequence of either input or output ports) 
CPolynomial< _CoefficientType >::Monomial  An additive atom of a Polynomial: The product of any number of Terms and a coefficient 
CMonomial  Represents a monomial, a product of powers of variables with nonnegative integer exponents 
CMosekSolverDetails  
CMovingAverageFilter< T >  The implementation of a Moving Average Filter 
CMultibodyForces< T >  A class to hold a set of forces applied to a MultibodyTree system 
►CMultibodyPlant  
CAxiallySymmetricFreeBodyPlant< T >  This plant models the free motion of a torque free body in space 
CMultibodyTree< T >  MultibodyTree provides a representation for a physical system consisting of a collection of interconnected rigid and deformable bodies 
CMultibodyTree< AutoDiffXd >  
CMultibodyTree< double >  
►CMultibodyTreeElement  
►CBody< AutoDiffXd >  
CRigidBody< AutoDiffXd >  
►CBody< double >  
CRigidBody< double >  
CBodyNode< AutoDiffXd >  
CBodyNode< double >  
►CBody< T >  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 
CRigidBody< T >  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 
►CForceElement< T >  A ForceElement allows modeling state and time dependent forces in a MultibodyTree model 
CLinearSpringDamper< T >  This ForceElement models a springdamper attached between two points on two different bodies 
CUniformGravityFieldElement< T >  This ForceElement allows modeling the effect of a uniform gravity field as felt by bodies on the surface of the Earth 
►CFrameBase< T >  FrameBase is an abstract representation of the concept of a frame in multibody dynamics 
►CFrame< T >  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 
CBodyFrame< T >  A BodyFrame is a material Frame that serves as the unique reference frame for a Body 
CFixedOffsetFrame< T >  FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P 
►CBodyNode< T >  For internal use only of the MultibodyTree implementation 
CBodyNodeImpl< T, num_positions, num_velocities >  For internal use only of the MultibodyTree implementation 
CBodyNodeWelded< T >  This class represents a BodyNode for nodes with zero degrees of freedom 
CModelInstance< T >  
►CJoint< T >  A Joint models the kinematical relationship which characterizes the possible relative motion between two bodies 
CPrismaticJoint< T >  This Joint allows two bodies to translate relative to one another along a common axis 
CRevoluteJoint< T >  This Joint allows two bodies to rotate relatively to one another around a common axis 
CWeldJoint< T >  This Joint fixes the relative pose between two frames as if "welding" them together 
CJointActuator< T >  The JointActuator class is mostly a simple bookkeeping structure to represent an actuator acting on a given Joint 
►CMobilizer< T >  Mobilizer is a fundamental object within Drake's multibody engine used to specify the allowed motions between two Frame objects within a MultibodyTree 
CMobilizerImpl< T, compile_time_num_positions, compile_time_num_velocities >  Base class for specific Mobilizer implementations with the number of generalized positions and velocities resolved at compile time as template parameters 
►CMobilizerImpl< T, 0, 0 >  
CWeldMobilizer< T >  This mobilizer fixes the relative pose X_FM of an outboard frame M in an inboard frame F as if "welding" them together at this fixed relative pose 
►CMobilizerImpl< T, 1, 1 >  
CPrismaticMobilizer< T >  This Mobilizer allows two frames to translate relative to one another along an axis whose direction is constant when measured in either this mobilizer's inboard frame or its outboard frame 
CRevoluteMobilizer< T >  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 
CMobilizerImpl< T, 2, 2 >  
►CMobilizerImpl< T, 3, 3 >  
CSpaceXYZMobilizer< T >  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) 
►CMobilizerImpl< T, 7, 6 >  
CQuaternionFloatingMobilizer< T >  This Mobilizer allows two frames to move freely relatively to one another 
CForceElement< AutoDiffXd >  
CForceElement< double >  
►CFrameBase< AutoDiffXd >  
►CFrame< AutoDiffXd >  
CBodyFrame< AutoDiffXd >  
►CFrameBase< double >  
►CFrame< double >  
CBodyFrame< double >  
CJoint< AutoDiffXd >  
CJoint< double >  
CJointActuator< AutoDiffXd >  
CJointActuator< double >  
CMobilizer< AutoDiffXd >  
CMobilizer< double >  
CModelInstance< AutoDiffXd >  
CModelInstance< double >  
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 
CMultilaneOnrampMerge  MultilaneOnrampMerge contains an example lanemerge scenario expressed as a maliput mulitilane road geometry 
CMultilaneRoadCharacteristics  MultilaneRoadCharacteristics computes and stores characteristics of a multilane road network; i.e 
CMultiplyEigenSizes< a, b >  MultiplyEigenSizes<a, b> gives a * b if both of a and b are fixed sizes 
Cnever_destroyed< T >  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 
CNewVariableNames<... >  
CNewVariableNames< Eigen::Dynamic >  
►CNewVariableNames< MultiplyEigenSizes< Rows, Cols >::value >  
CNewVariableNames< Rows, Cols >  
►CNewVariableNames< Rows==Eigen::Dynamic ? Eigen::Dynamic :Rows *(Rows+1)/2 >  
CNewSymmetricVariableNames< Rows >  
CNewVariableNames< Size >  The type of the names for the newly added variables 
CRightOfWayPhaseProvider::Result::Next  Information about a subsequent phase 
CRightOfWayStateProvider::Result::Next  Information about a subsequent State 
CNiceTypeName  Obtains canonicalized, platformindependent, humanreadable names for arbitrarilycomplicated C++ types 
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 
►CNonSymbolicTraits  A concrete traits class providing sugar to disable support for symbolic evaluation (i.e., the symbolic::Expression scalar type) 
CTraits< automotive::IdmController >  
CTraits< automotive::PurePursuitController >  
CTraits< automotive::TrajectoryCar >  
CTraits< drake::multibody::MultibodyPlant >  
CTraits< drake::multibody::MultibodyTreeSystem >  
CTraits< examples::quadrotor::QuadrotorPlant >  
CTraits< examples::rimless_wheel::RimlessWheel >  
CTraits< PiecewisePolynomialAffineSystem >  
CTraits< PiecewisePolynomialLinearSystem >  
CTraits< RigidBodyPlant >  
CObjFeatures  Multitude of parameters for generating an OBJ model of a road surface, with sensible defaults 
►COptimizationProgram  
CLinearFeasibilityProgram  Test a simple linear programming problem with zero cost, i.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  
CQuadraticProgram0  
CQuadraticProgram1  
CQuadraticProgram2  
CQuadraticProgram3  
CQuadraticProgram4  
CGlobalInverseKinematics::Options  
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 
►COutputPortBase  OutputPortBase handles the scalar typeindependent aspects of an OutputPort 
►COutputPort< T >  An OutputPort belongs to a System and represents the properties of one of that System's output ports 
CDiagramOutputPort< T >  Holds information about a subsystem output port that has been exported to become one of this Diagram's output ports 
CLeafOutputPort< T >  Implements an output port whose value is managed by a cache entry in the same LeafSystem as the port 
COutputPort< double >  
Coverload_cast_impl< Return, Args >  
CPackageMap  Maps ROS package names to their full path on the local file system 
CParameters  These are the parameters controlling the iteration process of the ImplicitStribeckSolver solver 
CParameters< T >  Parameters is a container for variables that parameterize a System so that it can represent a family of related models 
CParameters< AutoDiffXd >  
CParameters< double >  
CParameters< drake::symbolic::Expression >  
CParamSet  A class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller 
CParser  Parses SDF and URDF input files into a MultibodyPlant and (optionally) a SceneGraph 
CPasskey< T >  Simple generic implementation of the "Passkey Idiom" 
CPendulumParameters  This class is used to store the numerical parameters defining the model of a simple pendulum with the method MakePendulumPlant() 
CPenetrationAsPointPair< T >  A characterization of the intersection of two penetrating geometries 
CDynamicProgrammingOptions::PeriodicBoundaryCondition  For algorithms that rely on approximations of the statedynamics (as in FittedValueIteration), this is a list of state dimensions for which the state space maximum value should be "wrapped around" to ensure that all values are in the range [low, high) 
CPeriodicEventDataComparator  Structure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method 
CPickAndPlaceStateMachine  A class which controls the pick and place actions for moving a single target in the environment 
CPIDOutput  
CPiecewiseCartesianTrajectory< T >  A wrapper class that represents a Cartesian trajectory, whose position part is a PiecewiseCubicTrajectory, and the rotation part is a PiecewiseQuaternionSlerp 
CPiecewiseCartesianTrajectory< double >  
CPiecewiseCubicTrajectory< T >  A wrapper class that stores a PiecewisePolynomial and its first and second derivatives 
CPiecewiseCubicTrajectory< double >  
CPlannerConfiguration  Information required to set up a planner for a pickandplace task 
CPoint  
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 
CPointPair< T >  Structure containing the results of a collision query 
CPointPairContactInfo< T >  A class containing information regarding contact response between two bodies including: 
CPolynomial< _CoefficientType >  A scalar multivariate polynomial, modeled after the msspoly in spotless 
CPolynomial  Represents symbolic polynomials 
CPolynomial< CoefficientType >  
CGlobalInverseKinematics::Polytope3D  Describes a polytope in 3D as 𝐀 * 𝐱 ≤ 𝐛 (a set of halfspaces), where 𝐀 ∈ ℝⁿˣ³, 𝐱 ∈ ℝ³, 𝐛 ∈ ℝⁿ 
CPoseBundle< T >  PoseBundle is a container for a set of poses, represented by an Isometry3, and corresponding velocities, represented by a FrameVelocity 
CPoseSelector< T >  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 
CPoseVelocity  Wraps the raw data contained in a trajectory expressed in terms of pose and velocity values 
CPoseVelocityInputPorts< T >  A container with references to the input port for the pose input, and a reference to the input port for the velocity input 
CPositionIndices  
CPositionKinematicsCache< T >  This class is one of the cache entries in MultibodyTreeContext 
CCurve2< T >::PositionResult  A result type for the GetPosition method 
CTrigPoly< _CoefficientType >::Product< Rhs, Lhs >  
CPolynomial< _CoefficientType >::Product< Rhs, Lhs >  
CProximityEngine< T >  The underlying engine for performing geometric proximity queries 
CProximityEngine< double >  
CPurePursuit< T >  PurePursuit computes the required steering angle to achieve a goal point on an continuous planar path 
CPythonApi< Derived >  
►CPythonApi< PythonAccessor< Policy > >  
CPythonAccessor< Policy >  
►CPythonApi< PythonRemoteVariable >  
CPythonRemoteVariable  Presents variable stored in Python side 
CPythonAttrPolicy  
CPythonItemPolicy  
CQPControllerDebugData  
CQPControllerOutput  
CQPControllerParams  
CQPControllerState  
CQpInput  Input to the QP inverse dynamics controller 
CQpInverseDynamics  
CQPLocomotionPlan  
CQPLocomotionPlanSettings  
CQpOutput  Output of the QP inverse dynamics controller 
CQuadraticLyapunovFunction  
CQueryObject< T >  The QueryObject serves as a mechanism to perform geometry queries on the world's geometry 
CRoadRulebook::QueryResults  Results of a FindRules() query 
CRandomClutterGenerator  Given a RigidBodyTree containing a given scene, the RandomClutterGenerator can repeatedly generate bounded random poses/configurations on selected model instances within the tree 
CRandomSimulationResult  A snapshot of the generator used to produce the random simulation 
CRandomState< Distribution, Generator >  State for a given random distribution and generator 
CRationalFunction  Represents symbolic rational function 
CRBounds  Bounds in the lateral dimension (r component) of a Lane frame, consisting of a pair of minimum and maximum r value 
CRelationalOpTraits< DerivedA, DerivedB, typename >  Provides a return type of relational operations (=, ≠, ≤, <, ≥, >) between Eigen::Array s 
CRenderingConfig  Common configurations of rendering systems 
Creset_after_move< T >  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 
Creset_after_move< const std::type_info *>  
Creset_after_move< int >  
Creset_on_copy< T >  Type wrapper that performs valueinitialization on copy construction or assignment 
Creset_on_copy< const internal::ContextMessageInterface *>  
Creset_on_copy< drake::systems::ContextBase *>  
CResizeDerivativesToMatchScalarImpl< Derived, Scalar >  
CResizeDerivativesToMatchScalarImpl< Derived, Eigen::AutoDiffScalar< DerivType > >  
CResolvedContact  This class holds contact force related information, and works closely with ContactInformation 
CRightOfWayPhaseProvider::Result  Result returned by GetPhase() 
CRightOfWayStateProvider::Result  Result returned by GetState() 
CMixedIntegerRotationConstraintGenerator::ReturnType  
CRewritingRule  A RewritingRule , lhs => rhs , consists of two Patterns lhs and rhs 
►CRgbdRenderer  Abstract interface of RGBD renderers, which render RGB, depth and label images using VisualElement 
CRgbdRendererOSPRay  An RgbdRenderer implementation using OSPRay via VTK 
CRgbdRendererVTK  An RgbdRenderer implementation using VTK 
CRightOfWayPhase  A group of RightOfWayRule instances and their states 
►CRightOfWayPhaseBook  Abstract interface for providing the mapping from RightOfWayRule::Id to RightOfWayPhaseRing 
CSimpleRightOfWayPhaseBook  A simple concrete implementation of the api::rules::RightOfWayPhaseBook abstract interface 
►CRightOfWayPhaseProvider  Abstract interface for providing the dynamic states (RightOfWayPhase::Id) of a collection of RightOfWayPhaseRings 
CSimpleRightOfWayPhaseProvider  A simple concrete implementation of the api::rules::RightOfWayPhaseProvider abstract interface 
CRightOfWayPhaseRing  A set of mutually exclusive phases, e.g., that comprise the signalling cycle for an intersection 
CRightOfWayRule  Rule describing rightofway, a.k.a 
►CRightOfWayStateProvider  Abstract interface for the provider of the state of a dynamic (multiple state) RightOfWayRule 
CPhaseBasedRightOfWayStateProvider  Provides the state of maliput::api::rules::RightOfWayRule instances based on the current maliput::api::rules::RightOfWayPhase 
CTrivialRightOfWayStateProvider  A trivial implementation of an api::rules::RightOfWayStateProvider 
CRigidBody< T >  
CRigidBody< double >  
CRigidBodyActuator  Defines a physical actuator (i.e., an electric motor and stepdown transmission) that operates on a joint 
►CRigidBodyConstraint  Abstract base class 
►CMultipleTimeKinematicConstraint  
CWorldFixedBodyPoseConstraint  
CWorldFixedOrientConstraint  
CWorldFixedPositionConstraint  
►CMultipleTimeLinearPostureConstraint  Constrain the posture such that lb(t(1), t(2),..., t(n)) <= A_mat(t(1), t(2), t(n))*[q(t(1));q(t(2));...;q(t(n))] <= ub(t(1), t(2),..., t(n)) where A_mat is a sparse matrix that only depends on t(1), t(2),..., t(n) 
CPostureChangeConstraint  
CPostureConstraint  Constrain the joint limits 
CQuasiStaticConstraint  Constrain the Center of Mass (CoM) within the support polygon 
►CSingleTimeKinematicConstraint  
CAllBodiesClosestDistanceConstraint  
►CEulerConstraint  
CWorldEulerConstraint  
►CGazeConstraint  
►CGazeDirConstraint  
CRelativeGazeDirConstraint  
CWorldGazeDirConstraint  
►CGazeOrientConstraint  
CWorldGazeOrientConstraint  
►CGazeTargetConstraint  
CRelativeGazeTargetConstraint  
CWorldGazeTargetConstraint  
CGravityCompensationTorqueConstraint  
CMinDistanceConstraint  
CPoint2LineSegDistConstraint  
CPoint2PointDistanceConstraint  
►CPositionConstraint  
CRelativePositionConstraint  
CWorldCoMConstraint  
►CWorldPositionConstraint  
CWorldPositionInFrameConstraint  Constrain the points Q on a body to be within a bounding box specified in a fixed frame F 
►CQuatConstraint  
CRelativeQuatConstraint  
CWorldQuatConstraint  
CSingleTimeLinearPostureConstraint  Constrain the posture satisfies lb <= A_mat * q <= ub at any time, where A_mat is a sparse matrix 
CRigidBodyDistanceConstraint  Defines a "relative distance constraint" that models a constraint between points on two different rigid bodies 
CRigidBodyFrame< T >  Multibody systems typically have distinguished frames of interest that need to be monitored 
CRigidBodyFrame< double >  
CRigidBodyLoop< T >  Defines a "loop joint" that models a kinematic loop formed by a chain of rigid bodies and their regular joints 
CRigidBodyLoop< double >  
CRigidBodySupportStateElement  
CRigidBodyTree< T >  Maintains a vector of RigidBody objects that are arranged into a kinematic tree via DrakeJoint objects 
CRigidBodyTree< double >  
CRigidBodyTreeAliasGroups< T >  This class provides a way to create aliases to groups of RigidBody or DrakeJoint objects 
CRigidBodyTreeAliasGroups< double >  
CRigidBodyTreeConstants  Defines RigidBodyTree constants 
CRigidTransform< T >  This class represents a proper rigid transform between two frames which can be regarded in two ways 
CRigidTransform< double >  
CRoadCharacteristics  Holds common api::RoadGeometry characteristics needed to construct one 
►CRoadCurve  Defines an interface for a path in a Segment object surface 
CArcRoadCurve  RoadCurve specification for a reference curve that describes a piece of an arc 
CLineRoadCurve  RoadCurve specification for a reference curve that describes a line 
►CRoadGeometry  Abstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3space 
CRoadGeometry  Dragway's implementation of api::RoadGeometry 
►CRoadGeometry  Geometry_base's implementation of api::RoadGeometry 
CMockRoadGeometry  Mock api::RoadGeometry implementation; see mock_geometry.h 
CRoadGeometry  A simple api::RoadGeometry implementation that only supports a single lane per segment 
CRoadGeometry  An api::RoadGeometry implementation for RNDF specification 
CRoadOdometry< T >  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< T >  RoadPath converts a sequence of Maliput Lanes into a PiecewisePolynomial for the purpose of generating a path for a car to follow 
CRoadPosition  A position in the road network, consisting of a pointer to a specific Lane and a Lane frame position in that Lane 
►CRoadRulebook  Abstract interface for querying "rules of the road" 
CSimpleRulebook  SimpleRulebook is a simple concrete implementation of the api::rules::RoadRulebook abstract interface 
CRobotJointIndexMap  
CRobotKinematicState< T >  A wrapper class around KinematicsCache and several useful matrices such as the inertia matrix, etc 
►CRobotKinematicState< double >  
CHumanoidStatus  Mostly a thin wrapper on RigidBodyTree 
CRobotPropertyCache  
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 
CRollPitchYaw< T >  This class represents the orientation between two arbitrary frames A and D associated with a Spacefixed (extrinsic) XYZ rotation by "rollpitchyaw" angles [r, p, y] , which is equivalent to a Bodyfixed (intrinsic) ZYX rotation by "yawpitchroll" angles [y, p, r] 
CRot3  An R^3 rotation parameterized by roll, pitch, yaw 
CRotation  A 3dimensional rotation 
►CRotationalInertia< T >  This class helps describe the mass distribution (inertia properties) of a body or composite body about a particular point 
CUnitInertia< T >  This class is used to represent rotational inertias for unit mass bodies 
►CRotationalInertia< double >  
CUnitInertia< double >  
CRotationMatrix< T >  This class represents a 3x3 rotation matrix between two arbitrary frames A and B and helps ensure users create valid rotation matrices 
CRotationMatrix< double >  
Ctype_visit_impl< VisitWith, Visitor >::runner< T, execute >  
Ctype_visit_impl< VisitWith, Visitor >::runner< T, false >  
Cscalar_predicate< T >  A traits struct that describes the return type of predicates over a scalar type (named T ) 
CScalarInitialValueProblem< T >  A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e 
CScalarInitialValueProblem< double >  
CSceneGraphInspector< T >  The SceneGraphInspector serves as a mechanism to query the topological structure of a SceneGraph instance 
CSceneGraphInspector< double >  
CScreenCoord  
CScsSolverDetails  The SCS solver details after calling Solve function in ScsSolver 
►CSegment  A Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface 
CSegment  Dragway's implementation of api::Segment 
►CSegment  Geometry_base's implementation of api::Segment 
CMockSegment  Mock api::Segment implementation; see mock_geometry.h 
CSegment  An api::Segment implementation 
CSegment  An api::Segment implementation for RNDF 
►CSerializerInterface  SerializerInterface translates between LCM message bytes and drake::systems::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal> 
CSerializer< LcmMessage >  Serializer is specific to a single LcmMessage type, and translates between LCM message bytes and drake::systems::Value<LcmMessage> objects 
►CShape  The base interface for all shape specifications 
CBox  Definition of a box 
CConvex  Support for convex shapes 
CCylinder  Definition of a cylinder 
CHalfSpace  Definition of a half space 
CMesh  Limited support for meshes 
CSphere  Definition of sphere 
CShapeReifier  The interface for converting shape descriptions to real shapes 
CShapeTag< ShapeType >  Simple struct for instantiating the typespecific Shape functionality 
CSide  
CSignalLog< T >  This class serves as an inmemory cache of timedependent vector values 
CSignalLog< double >  
CSignedDistancePair< T >  The data for reporting the signed distance between two geometries, A and B 
CSignedDistanceToPoint< T >  The data for reporting the signed distance from a query point to a geometry 
CSimDiagramBuilder< T >  A wrapper class around DiagramBuilder that facilitates diagram building for controlled simulation 
CSimpleTreeVisualizer  A utility to render a RigidBodyTree in a specified configuration 
CSimulatedPlantConfiguration  Information required to set up a simulation of a pickandplace scenario with multiple arms, tables, and manipulable objects 
CSimulatePlantToRest  Given a RigidBodyPlant, this class allows the construction and execution of a simulation which enables the state of the plant to come to a rest from a specified initial condition 
CSimulator< T >  A class for advancing the state of hybrid dynamic systems, represented by System<T> objects, forward in time 
CSimulator< double >  
CTrigPoly< _CoefficientType >::SinCosVars  
CMathematicalProgram::SolverData  
CSolverId  Identifies a MathematicalProgramSolverInterface implementation 
CSolverOptions  Stores options for multiple solvers 
CSolverResult  This class is used by implementations of the class MathematicalProgramSolverInterface to report their results to the mathematical program 
CSolverTypeConverter  Converts between SolverType and SolverId 
CGurobiSolver::SolveStatusInfo  Contains info returned to a user function that handles a Node or Solution callback 
CSortedPair< T >  This class is similar to the std::pair class 
CSpatialInertia< T >  This class represents the physical concept of a Spatial Inertia 
CSpatialInertia< double >  
CSpatialKinematicsPVA< T >  Utility class containing the transform and spatial velocity/acceleration of an arbitrary frame B in another arbitrary frame N (e.g., the world) 
CSpatialVector< SV, T >  This class is used to represent physical quantities that correspond to spatial vectors such as spatial velocities, spatial accelerations and spatial forces 
►CSpatialVector< SpatialAcceleration, T >  
CSpatialAcceleration< T >  This class is used to represent a spatial acceleration that combines rotational (angular acceleration) and translational (linear acceleration) components 
►CSpatialVector< SpatialForce, T >  
CSpatialForce< T >  This class is used to represent a spatial force (also called a wrench) that combines both rotational (torque) and translational force components 
►CSpatialVector< SpatialMomentum, T >  
CSpatialMomentum< T >  This class is used to represent the spatial momentum of a particle, system of particles or body (whether rigid or soft.) The linear momentum l_NS of a system of particles S in a reference frame N is defined by: 
►CSpatialVector< SpatialVelocity, double >  
CSpatialVelocity< double >  
►CSpatialVector< SpatialVelocity, T >  
CSpatialVelocity< T >  This class is used to represent a spatial velocity (also called a twist) that combines rotational (angular) and translational (linear) velocity components 
CStartReference::Spec  Defines how a Connection's reference curve starts 
CEndReference::Spec  Defines how a Connection's reference curve ends 
CStartLane::Spec  Defines how a Connection's lane curve starts 
CEndLane::Spec  Defines how a Connection's lane curve ends 
CAntiderivativeFunction< T >::SpecifiedValues  The set of values that, along with the function being integrated, partially specify the definite integral i.e 
CInitialValueProblem< T >::SpecifiedValues  A collection of values i.e 
CScalarInitialValueProblem< T >::SpecifiedValues  A collection of values i.e 
CSpeedLimitRule  Rule describing speed limits 
CSRange  Directed, inclusive longitudinal (s value) range from s0 to s1 
CSrhFace  A Lane frame face: a sequence of vertices expressed in the (s,r,h) coordinates of an api::Lane (which is not referenced here) 
CStartLane  Provides methods to build an StartLane::Spec 
CStartReference  Provides methods to build an StartReference::Spec 
CRightOfWayRule::State  Semantic state of a RightOfWayRule 
►CState< T >  State is a container for all the data comprising the complete state of a particular System at a particular moment 
CDiagramState< T >  DiagramState is a State, annotated with pointers to all the mutable substates that it spans 
CState< AutoDiffXd >  
►CState< double >  
CDiagramState< double >  
►CStateFeedbackControllerInterface< T >  Interface for state feedback controllers 
CKukaTorqueController< T >  Controller that take emulates the kuka_iiwa_arm when operated in torque control mode 
CInverseDynamicsController< T >  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
CPidController< T >  Implements the PID controller 
CInverseDynamicsController< T >  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
►CStateFeedbackControllerInterface< double >  
CManipulatorJointSpaceController  This class implements an example of a general purpose controller for a fixed based manipulator based on qp inverse dynamics 
CSchunkWsgPlainController  This class implements a controller for a Schunk WSG gripper as a systems::Diagram 
CStepInfo< T >  Contains information about the independent variable including time and step number 
CStepInfo< AutoDiffXd >  
CStepInfo< double >  
CStepInfo< drake::symbolic::Expression >  
CLaneEnd::StrictOrder  An arbitrary strict complete ordering, useful for, e.g., std::map 
CSupportStateElement  
CSystemConstraint< T >  A SystemConstraint is a generic baseclass for constraints on Systems 
CSystemConstraint< AutoDiffXd >  
CSystemConstraint< double >  
CSystemIdentification< CoefficientType >  Utility functions for system identification 
CSystemIdentification< CoefficientType >::SystemIdentificationResult  A helper struct to hold System ID results 
►CSystemMessageInterface  
►CSystemBase  Provides nontemplatized functionality shared by the templatized System classes 
►CSystem< T >  Base class for all System functionality that is dependent on the templatized scalar type T for input, state, parameters, and outputs 
►CDiagram< T >  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 
CAcrobotWEncoder< T >  Constructs the Acrobot with (only) encoder outputs 
CIiwaAndWsgPlantWithStateEstimator< T >  A custom systems::Diagram composed of a systems::RigidBodyPlant, a systems::controllers::InverseDynamicsController, and a number of OracularStateEstimation systems 
CKukaTorqueController< T >  Controller that take emulates the kuka_iiwa_arm when operated in torque control mode 
CManipulationStation< T >  A system that represents the complete manipulation station, including exactly one robotic arm (a Kuka IIWA LWR), one gripper (a Schunk WSG 50), and anything a user might want to load into the model 
CInverseDynamicsController< T >  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
CPidControlledSystem< T >  A system that encapsulates a PidController and a controlled System (a.k.a the "plant") 
CInverseDynamicsController< T >  A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics 
CPidControlledSpringMassSystem< T >  A model of a onedimensional springmass system controlled to achieve a given target position using a PID controller 
CStateInterpolatorWithDiscreteDerivative< T >  Supports the common pattern of combining a (feedthrough) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked 
►CLeafSystem< T >  A superclass template that extends System with some convenience utilities that are not applicable to Diagrams 
CBicycleCar< T >  BicycleCar implements a nonlinear rigid body bicycle model from Althoff & Dolan (2014) [1] 
CDrivingCommandMux< T >  A specialpurpose multiplexer that packs two scalar inputs, steering angle (in units rad) and acceleration (in units m/s^2), into a vectorvalued output of type DrivingCommand<T>, where the inputs feed directly through to the output 
CDynamicBicycleCar< T >  DynamicBicycleCar implements a planar rigid body bicycle model of an automobile with a nonlinear brush tire model from Bobier (2012) [1] 
CIdmController< T >  IdmController implements the IDM (Intelligent Driver Model) planner, computed based only on the nearest car ahead 
CMaliputRailcar< T >  MaliputRailcar models a vehicle that follows a maliput::api::Lane as if it were on rails and neglecting all physics 
CMobilPlanner< T >  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 
CPurePursuitController< T >  PurePursuitController implements a pure pursuit controller 
CSimpleCar< T >  SimpleCar models an idealized response to driving commands, neglecting all physics 
CTrajectoryCar< T >  TrajectoryCar models a car that follows a preestablished trajectory 
CTrajectoryFollower< T >  TrajectoryFollower simply moves along a preestablished trajectory 
CBouncingBall< T >  Dynamical representation of the idealized hybrid dynamics of a ball dropping from a height and bouncing on a surface 
CAcrobotPlant< T >  The Acrobot  a canonical underactuated system as described in Chapter 3 of Underactuated Robotics 
CAcrobotSpongController< T >  The Spong acrobot swingup controller as described in: Spong, Mark W 
CBeadOnAWire< T >  Dynamical system of a point (unit) mass constrained to lie on a wire 
CCompassGait< T >  Dynamical representation of the idealized hybrid dynamics of a "compass
gait", as described in http://underactuated.mit.edu/underactuated.html?chapter=simple_legs with a few small differences 
COracularStateEstimation< T >  A System block that takes state vector and output a bot_core::robot_state_t message 
CParticle< T >  A linear 1DOF particle system 
CPendulumPlant< T >  A model of a simple pendulum
\[ ml^2 \ddot\theta + b\dot\theta + mgl\sin\theta = \tau \]

CQuadrotorPlant< T >  The Quadrotor  an underactuated aerial vehicle 
CRimlessWheel< T >  Dynamical representation of the idealized hybrid dynamics of a "rimless
wheel", as described in http://underactuated.mit.edu/underactuated.html?chapter=simple_legs In addition, this model has two additional (discrete) state variables that are not required in the mathematical model: 
CRod2D< T >  Dynamical system representation of a rod contacting a halfspace in two dimensions 
CBouncingBallPlant< T >  A model of a bouncing ball with HuntCrossley compliant contact model 
CSolarSystem< T >  A model of an orrery – a simple mechanical model of the solar system 
CVanDerPolOscillator< T >  Van der Pol oscillator 
CSceneGraph< T >  SceneGraph serves as the nexus for all geometry (and geometrybased operations) in a Diagram 
CContactResultsToLcmSystem< T >  A System that encodes ContactResults into a lcmt_contact_results_for_viz message 
►CMultibodyTreeSystem< T >  This is a bare Drake System providing just enough functionality to allow standalone exercise of a MultibodyTree 
CFreeRotatingBodyPlant< T >  This plant models the rotational motion of a torque free body in space 
CMultibodyPlant< T >  MultibodyPlant is a Drake system framework representation (see systems::System) for the model of a physical system consisting of a collection of interconnected bodies 
CActuatorEffortToRigidBodyPlantInputConverter< T >  
CAdder< T >  An adder for arbitrarily many inputs of equal size 
CRobertsonSystem< T >  Robertson's stiff chemical reaction problem 
CStiffDoubleMassSpringSystem< T >  A coupled, mass spring system taken from the SD/FAST user's manual 
CLogisticSystem< T >  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 
CStatelessSystem< T >  System with no state for testing a simplistic witness function 
CConstantValueSource< T >  A source block that always outputs a constant value 
CInverseDynamics< T >  Solves inverse dynamics with no consideration for joint actuator force limits 
CLinearModelPredictiveController< T >  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 
CPidController< T >  Implements the PID controller 
CRobotKinematicStateTranslatorSystem< T >  Provides transformation from a state vector to RobotKinematicState 
CInverseDynamics< T >  Solves inverse dynamics with no consideration for joint actuator force limits 
CDemultiplexer< T >  This system splits a vector valued signal on its input into multiple outputs 
CODESystem< T >  A LeafSystem subclass used to describe parameterized ODE systems i.e 
CDiscreteDerivative< T >  System that outputs the discretetime derivative of its input: y(t) = (u[n]  u[n1])/h, where n = floor(t/h), where h is the time period 
CLuenbergerObserver< T >  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 
CMultiplexer< T >  This system combines multiple vectorvalued inputs into a vectorvalued output 
CPassThrough< T >  A pass through system with input u and output y = u 
CMultibodyPositionToGeometryPose< T >  A directfeedthrough system that converts a vector of joint positions directly to a geometry::FramePoseVector<T> to behave like a MultibodyPlant::get_geometry_pose_output_port() 
CPoseAggregator< T >  PoseAggregator is a multiplexer for heterogeneous sources of poses and the velocities of those poses 
CRenderPoseToGeometryPose< T >  A directfeedthrough system that converts the C++ type of poses from rendering::PoseVector<T> on the input to geometry::FramePoseVector<T> on the output 
CRigidBodyPlant< T >  This class provides a System interface around a multibody dynamics model of the world represented by a RigidBodyTree 
CRigidBodyPlantBridge< T >  This class provides backwards compatibility between the old RigidBodyPlant and the new SceneGraph 
CSaturation< T >  An elementwise hard saturation block with inputs signal u , saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: 
CBeamModel< T >  Implements the "Beam Models of Range Finders" from section 6.3 of Probabilistic Robotics (2006), by Thrun, Burgard, and Fox 
CSignalLogger< T >  A sink block which logs its input to memory 
CSine< T >  A sine system which outputs y = a * sin(f * t + p) and first and second derivatives w.r.t 
►CSingleOutputVectorSource< T >  A base class that specializes LeafSystem for use with no input ports, and only a single, vector output port 
CConstantVectorSource< T >  A source block with a constant output port at all times 
CTrajectorySource< T >  A source block that generates the value of a Trajectory for a given time 
►CSpringMassSystem< T >  A model of a onedimensional springmass system 
CMySpringMassSystem< T >  
►CSpringMassDamperSystem< T >  
CDiscontinuousSpringMassDamperSystem< T >  
►CTimeVaryingAffineSystem< T >  Base class for a discrete or continuoustime, timevarying affine system, with potentially timevarying coefficients 
►CAffineSystem< T >  A discrete OR continuous affine system (with constant coefficients) 
►CLinearSystem< T >  A discrete OR continuous linear system 
CSimplePowertrain< T >  SimplePowertrain models a powertrain with firstorder lag 
CMatrixGain< T >  A system that specializes LinearSystem by setting coefficient matrices A , B , and C to all be zero 
CPiecewisePolynomialAffineSystem< T >  A continuous or discretetime Affine TimeVarying system described by a piecewise polynomial trajectory of system matrices 
►CTimeVaryingLinearSystem< T >  Base class for a discrete or continuous linear timevarying (LTV) system 
CPiecewisePolynomialLinearSystem< T >  A continuous or discretetime Linear TimeVarying system described by a piecewise polynomial trajectory of system matrices 
►CVectorSystem< T >  A base class that specializes LeafSystem for use with only zero or one vector input ports, and only zero or one vector output ports 
CMultibodyForceToWsgForceSystem< T >  
CBarycentricMeshSystem< T >  A (stateless) vector system implemented as a multilinear (barycentric) interpolation on a mesh over the inputs 
CFirstOrderLowPassFilter< T >  An elementwise first order low pass filter system that filters the ith input uᵢ into the ith output zᵢ 
CGain< T >  An elementwise gain block with input u and output y = k * u with k a constant vector 
CIntegrator< T >  An integrator for a continuous vector input 
CRotaryEncoders< T >  Simple model to capture the quantization and calibration offset effects of a rotary encoder 
CWrapToSystem< T >  An elementwise wrapping block that transforms the specified indices of the input signal u into the interval [low, high) 
CZeroOrderHold< T >  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 
►CSystem< AutoDiffXd >  
►CLeafSystem< AutoDiffXd >  
CMultibodyTreeSystem< AutoDiffXd >  
►CSystem< double >  
►CDiagram< double >  
CHumanoidController  A controller for humanoid balancing built on top of HumanoidPlanEvalSystem and QpInverseDynamicsSystemSystem 
CLcmPlanInterpolator  
CManipulationStationHardwareInterface  A System that connects via messagepassing to the hardware manipulation station 
CManipulatorJointSpaceController  This class implements an example of a general purpose controller for a fixed based manipulator based on qp inverse dynamics 
CValkyrieSimulationDiagram  
CSchunkWsgController  This class implements a controller for a Schunk WSG gripper 
CSchunkWsgPlainController  This class implements a controller for a Schunk WSG gripper as a systems::Diagram 
CSchunkWsgPositionController  This class implements a controller for a Schunk WSG gripper in position control mode adding a discretederivative to estimate the desired velocity from the desired position commands 
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 
CAccelerometerExampleDiagram  Implements the Diagram shown below, which demonstrates how an accelerometer can be used 
CRgbdCameraDiscrete  Wraps a continuous RgbdCamera with zero order holds to have it function as a discrete sensor 
CStateInterpolatorWithDiscreteDerivative< double >  
►CLeafSystem< double >  
CAdder< double >  
CDiscreteDerivative< double >  
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 
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 AcrobotState 
CAcrobotStateSender  Receives the output of an acrobot_plant, and outputs it as an LCM message with type lcm_acrobot_x 
CAllegroCommandReceiver  Handles lcmt_allegro_command messages from a LcmSubscriberSystem 
CAllegroStatusSender  Creates and outputs lcmt_allegro_status messages 
CRobotStateMsgToHumanoidStatusSystem  Translates a bot_core::robot_state_t message to HumanoidStatus 
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 
CIiwaCommandReceiver  Handles IIWA commands from a LcmSubscriberSystem 
CIiwaCommandSender  Creates and outputs lcmt_iiwa_command messages 
CIiwaContactResultsToExternalTorque  A translator class that converts the contact force field in systems::ContactResults to external joint torque for a set of specified model instances in RigidBodyTree 
CIiwaStatusReceiver  Handles lcmt_iiwa_status messages from a LcmSubscriberSystem 
CIiwaStatusSender  Creates and outputs lcmt_iiwa_status messages 
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 
CRobotPlanInterpolator  This class implements a source of joint positions for a robot 
CSchunkWsgCommandReceiver  Handles the command for the Schunk WSG gripper from a LcmSubscriberSystem 
CSchunkWsgCommandSender  Send lcmt_schunk_wsg_command messages for a Schunk WSG gripper 
CSchunkWsgPdController  This class implements a controller for a Schunk WSG gripper in position control mode 
CSchunkWsgStatusReceiver  Handles lcmt_schunk_wsg_status messages from a LcmSubscriberSystem 
CSchunkWsgStatusSender  Sends lcmt_schunk_wsg_status messages for a Schunk WSG 
CSchunkWsgTrajectoryGenerator  This system defines input ports for the desired finger position represented as the desired distance between the fingers in meters and the desired force limit in newtons, and emits target position/velocity for the actuated finger to reach the commanded target, expressed as the negative of the distance between the two fingers in meters 
CFramePoseTracker  Implements a class that maintains pose information for a set of specified RigidBodyFrames 
CDepthImageToPointCloud  Converts a depth image to a point cloud 
CRigidBodyPointCloudFilter  Removes known geometries from point clouds 
CTransformPointCloud  Transforms a point cloud to the world frame or to an arbitrary frame 
CAccelerometerTestLogger  A sink block that logs the most recent plant state and the accelerometer reading 
CContactResultsToLcmSystem< T >  A System that encodes ContactResults into a lcmt_contact_results_for_viz message 
►CPlanEvalBaseSystem  A base class that outputs QpInput for the qp inverse dynamics controller 
CHumanoidPlanEvalSystem  This class extends PlanEvalBaseSystem to interpret plans for humanoid robots 
CManipulatorMoveJointPlanEvalSystem  This class extends PlanEvalBaseSystem 
CQpInverseDynamicsSystem  A discrete time system block for an 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 
CDrakeVisualizer  This is a Drake System block that takes a RigidBodyTree and publishes LCM messages that are intended for drakevisualizer 
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 
CRandomSource< Distribution, Generator >  A source block which generates random numbers at a fixed sampling interval, with a zeroorder hold between samples 
CLcmLogPlaybackSystem  Advances the cursor of a drake::lcm::DrakeLcmLog based on the timestamps seen the Context that is used to simulate this System 
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 
CLcmDecoderSystem< DataType, MsgType >  A decoding system that converts a Lcm message of MsgTypedata to data of DataType 
CLcmEncoderSystem< DataType, MsgType >  An encoding system that converts data of DataType to a Lcm message of MsgType 
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 
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 
CAccelerometer  A simulated ideal accelerometer that measures the linear acceleration of a frame associated with a RigidBodyPlant 
CDepthSensor  A simple model of an ideal depth sensor 
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 
CImageToLcmImageArrayT  An ImageToLcmImageArrayT takes as input an ImageRgba8U, ImageDepth32F and ImageLabel16I 
CImageWriter  A system for periodically writing images to the file system 
CLcmImageArrayToImages  An LcmImageArrayToImages takes as input an AbstractValue containing a Value<robotlocomotion::image_array_t> LCM message that defines an array of images (image_t) 
COptitrackLcmFrameSender  The system has one abstractvalued input port and one abstractvalued output port 
CRgbdCamera  An RGBD camera system that provides RGB, depth and label images using visual elements of RigidBodyTree 
CValkyriePDAndFeedForwardController  
CMultibodyTreeSystem< double >  
CRigidBodyPlant< double >  
CRod2D< double >  
CSceneGraph< double >  
►CSpringMassSystem< double >  
CMySpringMassSystem< double >  
►CTimeVaryingAffineSystem< double >  
►CAffineSystem< double >  
CLinearSystem< double >  
►CVectorSystem< double >  
CIntegrator< double >  
CSystemOutput< T >  Conveniently stores a snapshot of the values of every output port of a System 
CSystemOutput< double >  
CSystemOutput< drake::symbolic::Expression >  
►CSystemParentServiceInterface  
CDiagram< double >  
CDiagram< T >  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 
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< S >  A tag object that denotes a System subclass S in function signatures 
Ctemplate_single_tag< Tpl >  Provides a tag for singleparameter templates 
CPolynomial< _CoefficientType >::Term  An individual variable raised to an integer power; e.g. x**2 
►CTest  
CIiwaKinematicConstraintTest  
CTwoFreeBodiesConstraintTest  
CMobilizerTester  
CInfeasibleLinearProgramTest0  An infeasible linear program 
CUnboundedLinearProgramTest0  An unbounded linear program 
CUnboundedLinearProgramTest1  An unbounded linear program 
CAffineLinearSystemTest  
CExplicitErrorControlledIntegratorTest< T >  
CGenericPlanTest  
CContactResultTestCommon< T >  
CRgbdRendererTest< Renderer >  
CAutoDiffXdTest  
►CTestWithParam  
CLinearProgramTest  
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 
►CTimeVaryingData  Stores matrix data necessary to construct an affine time varying system as a piecewise polynomial trajectory 
CLinearTimeVaryingData  Stores matrix data necessary to construct a linear time varying system as a piecewise polynomial trajectory 
CTotalSizeAtCompileTime< Head, Tail >  Helper for totalSizeAtCompileTime function (recursive) 
CTotalSizeAtCompileTime< Head >  Helper for totalSizeAtCompileTime function (base case) 
CTraits< S >  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< geometry::SceneGraph >  
►CTrajectory< T >  A Trajectory represents a timevarying matrix, indexed by a single scalar double time 
►CPiecewiseTrajectory< T >  Abstract class that implements the basic logic of maintaining consequent segments of time (delimited by breaks ) to implement a trajectory that is represented by simpler logic in each segment or "piece" 
CExponentialPlusPiecewisePolynomial< T >  Y(t) = K * exp(A * (t  t_j)) * alpha.col(j) + piecewise_polynomial_part(t) 
CPiecewisePolynomial< T >  A scalar multivariate piecewise polynomial 
CPiecewiseQuaternionSlerp< T >  A class representing a trajectory for quaternions that are interpolated using piecewise slerp (spherical linear interpolation) 
CTrajectory  A class that wraps a piecewise trajectory instantiated from pose data 
►CTrajectory< double >  
►CPiecewiseTrajectory< double >  
CExponentialPlusPiecewisePolynomial< double >  
CPiecewisePolynomial< double >  
CPiecewiseQuaternionSlerp< double >  
CTranslatorBase< DataType, MsgType >  Base API for a translator between arbitrary data of DataType and a Lcm message of MsgType 
CTrigPoly< _CoefficientType >  A scalar multivariate polynomial containing sines and cosines 
CTVLQRData  
Ctype_at< I, Ts >  Extracts the Ith type from a sequence of types 
Ctype_at_impl< N, K, T, Ts >  
Ctype_at_impl< N, N, T, Ts... >  
Ctype_caster_wrapped< Wrapper >  
►Ctype_caster_wrapped< drake::pydrake::detail::wrapper_eigen_translation< T, Dim > >  
Ctype_caster< Eigen::Translation< T, Dim > >  
Ctype_check_different_from< T >  Provides a check which returns whether T is different than U 
Ctype_pack< Ts >  Provides a tag to pass a parameter packs for ease of inference 
Ctype_pack_extract_impl< T >  
Ctype_pack_extract_impl< Tpl< Ts... > >  
Ctype_tag< T >  Provides a tag to pass a type for ease of inference 
Ctype_visit_impl< VisitWith, Visitor >  
Ctype_visit_with_default  Visit a type by constructing its default value 
Ctype_visit_with_tag< Tag >  Visits a type by construct a template tag's default value 
CTypeSafeIndex< Tag >  A typesafe nonnegative index class 
CTypeSafeIndex< class BodyNodeTag >  
CTypeSafeIndex< class BodyTag >  
CTypeSafeIndex< class CacheTag >  
CTypeSafeIndex< class DependencyTag >  
CTypeSafeIndex< class ForceElementTag >  
CTypeSafeIndex< class FrameTag >  
CTypeSafeIndex< class GeometryTag >  
CTypeSafeIndex< class InputPortTag >  
CTypeSafeIndex< class JointActuatorElementTag >  
CTypeSafeIndex< class JointElementTag >  
CTypeSafeIndex< class MobilizerTag >  
CTypeSafeIndex< class ModelInstanceTag >  
CTypeSafeIndex< class OutputPortTag >  
CTypeSafeIndex< class ProximityTag >  
CTypeSafeIndex< class RobotBaseTag >  
CTypeSafeIndex< class TargetTag >  
CTypeSpecificIdentifier< T >  TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T 
CTypeSpecificIdentifier< class BranchPoint >  
CTypeSpecificIdentifier< class Junction >  
CTypeSpecificIdentifier< class Lane >  
CTypeSpecificIdentifier< class RightOfWayPhaseRing >  
CTypeSpecificIdentifier< class RightOfWayRule >  
CTypeSpecificIdentifier< class RoadGeometry >  
CTypeSpecificIdentifier< class Segment >  
CTypeSpecificIdentifier< class SpeedLimitRule >  
CTypeSpecificIdentifier< class State >  
CTypeSpecificIdentifier< RightOfWayPhase >  
►Cuhash< HashAlgorithm >  A hashing functor, somewhat like std::hash 
Chash< drake::maliput::api::TypeSpecificIdentifier< T > >  Specialization of std::hash for TypeSpecificIdentifier<T> 
Chash< drake::solvers::SolverId >  
Chash< drake::SortedPair< T > >  Provides std::hash<SortedPair<T>> 
Chash< drake::symbolic::Expression >  
Chash< drake::symbolic::Formula >  
Chash< drake::symbolic::Monomial >  
Chash< drake::symbolic::Polynomial >  
Chash< drake::symbolic::Variable >  
Chash< drake::symbolic::Variables >  
Chash< drake::systems::sensors::Color< T > >  
Chash< drake::systems::sensors::PixelType >  
►Cunique_ptr< T >  STL class 
Ccopyable_unique_ptr< drake::geometry::internal::ProximityEngine< double > >  
Ccopyable_unique_ptr< drake::geometry::internal::ProximityEngine< T > >  
Ccopyable_unique_ptr< drake::geometry::Shape >  
Ccopyable_unique_ptr< drake::systems::AbstractValue >  
Ccopyable_unique_ptr< drake::systems::CacheEntryValue >  
Ccopyable_unique_ptr< drake::systems::ContactDetail< T > >  
Ccopyable_unique_ptr< drake::systems::FixedInputPortValue >  
Ccopyable_unique_ptr< drake::systems::Parameters< AutoDiffXd > >  
Ccopyable_unique_ptr< drake::systems::Parameters< double > >  
Ccopyable_unique_ptr< drake::systems::Parameters< drake::symbolic::Expression > >  
Ccopyable_unique_ptr< drake::systems::Parameters< T > >  
Ccopyable_unique_ptr< T >  A smart pointer with deep copy semantics 
CUniqueIndexer< T, Hash, KeyEqual >  A container for a set of unique objects which keeps track of the original insertion order 
CUniqueIndexer< drake::maliput::utility::mesh::GeoNormal, drake::uhash, drake::maliput::utility::mesh::GeoNormal::Equiv >  
CUniqueIndexer< drake::maliput::utility::mesh::GeoVertex, drake::uhash, drake::maliput::utility::mesh::GeoVertex::Equiv >  
CUnrevisedLemkeSolverId  Nontemplate class for UnrevisedLemkeSolver<T> constants 
CUseDefaultName  (Advanced.) Tag type that indicates a system or port should use a default name, instead of a userprovided name 
CVariable  Represents a symbolic variable 
CVariables  Represents a set of variables 
►Cvariant_caster  
Ctype_caster< stx::variant< Types... > >  
►CVectorBase< T >  VectorBase is an abstract base class that realvalued signals between Systems and realvalued System state vectors must implement 
►CBasicVector< T >  BasicVector is a semanticsfree wrapper around an Eigen vector that satisfies VectorBase 
CIiwaCommand< T >  A vectorized representation of lcmt_iiwa_command 
CMyVector< N, T >  A simple subclass of BasicVector<T> for testing, particularly for cases where BasicVector subtyping must be preserved through the framework 
CFrameVelocity< T >  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 
CPoseVector< T >  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 
CAccelerometerOutput< T >  Specializes BasicVector with accessors and setters that are useful for consumers of Accelerometer's output 
CDepthSensorOutput< T >  Specializes BasicVector with specific getters and setters that are useful for consumers of DepthSensor's output 
CGyroscopeOutput< T >  Specializes BasicVector with accessors and setters that are useful for consumers of Gyroscope's output 
CSpringMassStateVector< T >  The state of a onedimensional springmass system, consisting of the position and velocity of the mass, in meters and meters/s 
CSubvector< T >  Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase 
CSupervector< T >  Supervector is a concrete class template that implements VectorBase by concatenating multiple VectorBases, which it does not own 
►CVectorBase< AutoDiffXd >  
CBasicVector< AutoDiffXd >  
►CVectorBase< double >  
►CBasicVector< double >  
CPoseVector< double >  
►CVectorBase< drake::symbolic::Expression >  
CBasicVector< drake::symbolic::Expression >  
CVectorSetpoint< Scalar >  
CVelocityKinematicsCache< T >  This class is one of the cache entries in MultibodyTreeContext 
CIndexFace::Vertex  
CVisualMaterial  Definition of material for simple visualization 
CVRefIntegratorParams  
CWholeBodyParams  
CWitnessFunction< T >  Class that stores a function that is able to help determine the time and state at which a step of the initial value problem integration of a System should end, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling) 
CWitnessFunction< double >  
CWorldSimTreeBuilder< T >  A helper class to construct robot world RigidBodyTree objects from model (URDF/SDF) files 
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 
►Cwrap_arg_default< T >  Default case for argument wrapping, with pure passthrough 
Cwrap_callback< T, typename >  
Cwrap_ref_ptr< T, typename >  
►Cwrap_arg_default< const std::function< Signature > & >  
►Cwrap_callback< const std::function< Signature > &>  
Cwrap_callback< std::function< Signature > >  
Cwrap_arg_default< const T * >  
►Cwrap_arg_function  
Cwrap_callback< const std::function< Signature > & >  
Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_arg_functions< const std::function< Return(Args...)> & >  
►Cwrap_arg_policy  
Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_arg_functions< T >  
►Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_arg_functions< const std::function< Signature > &>  
Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_arg_functions< std::function< Signature > >  
Cwrap_function_impl< wrap_arg_policy, use_functions >  
Cwrap_ref_ptr< T &, std::enable_if_t< is_generic_pybind< T >::value > >  
Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_type< T, Extra >  
Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_type< void, Extra >  
Cwrapper_eigen_translation< T, Dim >  
CZMPPlanner  Given a desired two dimensional (X and Y) zeromoment point (ZMP) trajectory parameterized 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 
CBodyCollisions  
Cbool  
Cconst int  
Cdouble  
CInputPortLocator  
Cint  
CMatrix3< double >  
CMatrix6X< double >  
CMatrix< double, drake::kTwistSize, Eigen::Dynamic, 0, drake::kTwistSize, DrakeJoint::MAX_NUM_VELOCITIES >  
CMatrix< double, Eigen::Dynamic, 1 >  
CMatrix< double, Eigen::Dynamic, Eigen::Dynamic, 0, DrakeJoint::MAX_NUM_POSITIONS, DrakeJoint::MAX_NUM_VELOCITIES >  
CMatrix< double, Eigen::Dynamic, Eigen::Dynamic, 0, DrakeJoint::MAX_NUM_VELOCITIES, DrakeJoint::MAX_NUM_POSITIONS >  
CMatrixX< double >  
►Cnumeric_limits  
Cnumeric_limits< drake::symbolic::Expression >  
Cnumeric_limits< Eigen::AutoDiffScalar< T > >  
COutputPortLocator  
Cpair< drake::systems::PeriodicEventData, std::unique_ptr< drake::systems::Event< double > > >  
Cshared_ptr< PolynomialEvaluator >  
Cshared_ptr< RigidBodyFrame< double > >  
CSquareTwistMatrix< double >  
CTransform< double, drake::kSpaceDimension, Eigen::Isometry >  
CTwistVector< double >  
CType  
CVector3< double >  
CVector6< double >  
CVector6< T >  
CVectorX< double >  