Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345678]
 C QpOutputTranslatorSystem
 CAbstractValueA fully type-erased container class
 CAbstractValuesAbstractValues is a container for non-numerical state and parameters
 CAccelerationKinematicsCache< T >This class is one of the cache entries in MultibodyTreeContext
 CAcrobot< T >The Acrobot - a canonical underactuated system as described in Chapter 3 of Underactuated Robotics
 CAcrobot< double >
 CAcrobotParametersThis class is used to store the numerical parameters defining the model of an acrobot with the method MakeAcrobotPlant()
 CActionBase class for actions used by the pick and place demo
 CAddRotationMatrixBoxSphereIntersectionReturnSome of the newly added variables in function AddRotationMatrixBoxSphereIntersectionMilpConstraints
 CAllegroHandMotionStateDetecting 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 >
 CArcLengthParameterizedSplineAn extension for ignition::math::Splines that reparameterizes them by path length
 CArcOffsetSpecification 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 rigid-body 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
 CAssertionResultCollectorAssertionResultCollector helps with the creation of concise and well-traced testing subroutines when using googletest
 CAutoDiffToGradientMatrix< Derived >
 CAutoDiffToValueMatrix< Derived >
 CAutomotiveSimulator< T >AutomotiveSimulator is a helper class for constructing and running automotive-related simulations
 CBarycentricMesh< T >Represents a multi-linear 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
 CBodyAccelerationThis class holds spatial acceleration for a rigid body
 CBodyNodeTopologyData structure to store the topological information associated with a tree node
 CBodyOfInterestAn object that holds important kinematic properties
 CBodyTopologyData structure to store the topological information associated with a Body
 CBranchPointA BranchPoint is a node in the network of a RoadGeometry at which Lanes connect to one another
 CBuilderA class to ease the construction of a RoadGeometry from Connection and DirectedWaypoint objects
 CBuilderBaseDefines a builder interface for multilane
 CBuilderFactoryBaseFactory interface to construct BuilderBase instances
 CCacheStores all the CacheEntryValue objects owned by a particular Context, organized to allow fast access using a CacheIndex as an index
 CCacheEntryA CacheEntry belongs to a System and represents the properties of one of that System's cached computations
 CCacheEntryValueThis is the representation in the Context for the value of one of a System's CacheEntry objects
 CCameraInfoSimple 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
 CCodeGenVisitorVisitor 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 >
 CCompliantContactModelParametersThe set of parameters for the compliant contact model
 CCompliantMaterialThe set of per-object 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
 CCompositeEventCollection< AutoDiffXd >
 CCompositeEventCollection< double >
 CConditionTraits< symbolic::Formula >
 CConnectionA container that holds the information needed by a Builder to construct one or more Lane objects
 CConnectionRepresentation of a reference path connecting two endpoints
 CPidControlledSystem< T >::ConnectResultThe return type of ConnectController
 CMapKeyRange< K, V >::ConstIterator
 CConstrainedValuesBase class for specifying various desired objectives
 CConstraintAccelProblemData< T >Structure for holding constraint data for computing forces due to constraints and the resulting multibody accelerations
 CConstraintRelaxingIkA 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 velocity-level (i.e., impact problems)
 CContactDetail< T >The base class for defining a contact detail
 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:
 CContactInformationThis class describes contact related information for each body in contact with other bodies in the world
 CContactParamA struct for holding contact-related 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
 CContinuousState< T >ContinuousState is a view of, and optionally a container for, all the continuous state variables xc of a Drake System
 CContinuousState< AutoDiffXd >
 CContinuousState< double >
 CContinuousState< drake::symbolic::Expression >
 CCoulombFriction< T >Parameters for Coulomb's Law of Friction, namely:
 CCoulombFriction< double >
 CCubicPolynomialA cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3
 CCurve2< T >Curve2 represents a path through two-dimensional Cartesian space
 CKinematicsCache< T >::DataInCalcFrameSpatialVelocityJacobianInWorldFramePreallocated variables used in CalcFrameSpatialVelocityJacobianInWorldFrame
 CKinematicsCache< T >::DataInGeometricJacobianPreallocated variables used in GeometricJacobian
 CDataTypeTraits< DataType, false >
 CDelegatingHasherAn adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided 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)
 CDenseOutput< double >
 CDependencyGraphRepresents the portion of the complete dependency graph that is a subgraph centered on the owning subcontext, plus some edges leading to other subcontexts
 CDependencyTrackerManages value interdependencies for a particular value or set of values in a Context
 CDepthSensorSpecificationHolds a DepthSensor's specification
 CDescriptorTypeDescribes an descriptor field with a name and the descriptor's size
 CDesiredMotionParamStruct 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 >
 CDifferentialInverseKinematicsParametersContains parameters for differential inverse kinematics
 CDirectedEdgeIndexIndex for a directed edge in a GeoMesh
 CDirectedWaypointA 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 non-continuous state and parameters
 CDiscreteValues< AutoDiffXd >
 CDiscreteValues< double >
 CDiscreteValues< drake::symbolic::Expression >
 CDrakeJointA joint defines a spatial relationship between two rigid bodies
 CDrakeKukaIIwaRobot< T >This class is a MultibodyTree model for a 7-DOF Kuka iiwa robot arm
 CDrakeLcmInterfaceA pure virtual interface that enables LCM to be mocked
 Cdummy_value< T >Provides a "dummy" value for a ScalarType – a value that is unlikely to be mistaken for a purposefully-computed 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
 CDynamicProgrammingOptionsConsolidates the many possible options to be passed to the dynamic programming algorithms
 CEigenPtr< PlainObjectType >This wrapper class provides a way to write non-template 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 compile-time sizes a and b
 CEigenSizeMinPreferFixed< a, b >EigenSizeMinPreferFixed is a variant of EigenSizeMinPreferDynamic
 CEndLaneProvides methods to build an EndLane::Spec
 CEndpointComplete set of parameters for an endpoint of a connection, specified in the world frame
 CEndpointXyXY-plane-only parameters for an endpoint of a connection, specified in the world frame
 CEndpointZOut-of-plane parameters for an endpoint of a connection, specified in the world frame
 CEndReferenceProvides methods to build an EndReference::Spec
 CEnvironmentRepresents 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::EquivAn equivalence operation suitable for std::unordered_map
 CGeoNormal::EquivAn equivalence operation suitable for std::unordered_map
 CEvaluatorBaseProvides 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
 CEvent< T >Abstract base class that represents an 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)
 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 > >
 CEventDataBase class for storing trigger-specific data to be passed to event handlers
 CexceptionSTL class
 CExpressionRepresents a symbolic form of an expression
 CExpressionAddFactoryFactory class to help build ExpressionAdd expressions
 CExpressionCellRepresents an abstract class which is the base of concrete symbolic-expression classes
 CExpressionMulFactoryFactory class to help build ExpressionMul expressions
 CFaceEdgeIndexIndex for a face edge in a GeoMesh
 CFaceVertexIndexIndex of a face vertex in a GeoMesh
 CFieldsAllows combination of BaseField and DescriptorType for a PointCloud
 CFindResourceResultModels the outcome of drake::FindResource
 CFixedInputPortValueA FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports
 CFloatingJointConstantsDefines constants used by AddFloatingJoint()
 CFNV1aHasherThe FNV1a hash algorithm, used for hash_append generic hashing
 CForceElementTopologyData structure to store the topological information associated with a ForceElement
 CFormulaRepresents a symbolic form of a first-order logic formula
 CFormulaCellRepresents an abstract class which is the base of concrete symbolic-formula classes (i.e
 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
 CFrameTopologyData structure to store the topological information associated with a Frame
 CFreeBodyThe 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 torque-free rigid body B with axially symmetric inertia, in a Newtonian frame (World) N
 CFromDoubleTraitsA 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 > >
 CGenericPlan< T >This class represents a plan interpretor, which conceptually serves as a bridge between a high level planner (e.g
 CGenericPlan< double >
 CGeoFaceA world frame face: a sequence of vertices with corresponding normals
 CGeoMeshA world frame mesh: a collection of GeoFaces
 CGeometryFrameThis simple class carries the definition of a frame used in the SceneGraph
 CGeometryInstanceA 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
 CGeometryPropertiesThe base class for defining a set of geometry properties
 CGeometrySetThe GeometrySet, as its name implies, is a convenience class for defining a set of geometries
 CGeometryState< T >The context-dependent state of SceneGraph
 CGeometryState< double >
 CGeoNormalA world frame normal vector
 CGeoPositionT< T >A position in 3-dimensional geographical Cartesian space, i.e., in the world frame, consisting of three components x, y, and z
 CGeoPositionT< double >
 CGeoVertexA world frame vertex
 CGetSubMatrixGradientArray< QSubvectorSize, Derived, NRows, NCols >
 CGetSubMatrixGradientSingleElement< QSubvectorSize, Derived >
 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 >
 CGroupA group of Connections
 CGroupFactoryBaseFactory interface to construct Group instances
 CGyroscopeOutputConstantsDefines the semantics of each index in GyroscopeOutput's vector
 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>
 CHBoundsBounds 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::IdIndexAbstract 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
 CIdmPlanner< T >IdmPlanner implements the IDM (Intelligent Driver Model) equation governing longitudinal accelerations of a vehicle in single-lane traffic [1, 2]
 CConstraintRelaxingIk::IkCartesianWaypointCartesian waypoint
 CIKResultsReturn type for simplified versions of IK functions
 CIKTrajectoryHelperThis 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 >
 CIndexFaceA 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 >
 CInputPortBaseAn InputPort is a System resource that describes the kind of input a System accepts, on a given port
 CHermitianDenseOutput< T >::IntegrationStepAn 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
 CIntegratorBase< double >
 CInternalFrameThis is the internal representation of a GeometryFrame
 CInternalGeometryThe internal representation of the fixed portion of the scene graph geometry
 CInvalidDepthSet of constants used to represent invalid depth values
 CInverseFunctionInterpolatorA linear interpolator for arbitrary inverse functions
 CInverseKinematicsSolves an inverse kinematics (IK) problem on a MultibodyPlant, to find the postures of the robot satisfying certain constraints
 CIsoLaneVelocityIsometric velocity vector in a Lane-frame
 CIterationStatsStruct used to store information about the iteration process performed by ImplicitStribeckSolver
 CJointActuatorTopologyData 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
 CJunctionA 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
 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
 CKukaIiwaModelBuilder< T >
 CKukaRobotJointReactionForces< T >Utility struct to assist with returning joint torques/forces
 CLabelSet of labels used for label image
 CLaneA Lane represents a lane of travel in a road network
 CLaneDirectionLaneDirection holds the lane that a MaliputRailcar is traversing and the direction in which it is moving
 CLaneEndA specific endpoint of a specific Lane
 CLaneEndSetA set of LaneEnds
 CLaneLayoutWraps all the lane-related specifications in a Connection
 CLanePositionT< T >A 3-dimensional position in a Lane-frame, consisting of three components:
 CLanePositionT< double >
 CLaneSRangeDirected longitudinal range of a specific Lane, identified by a LaneId
 CLaneSRouteA longitudinal route, possibly spanning multiple (end-to-end) lanes
 CLcmAndVectorBaseTranslatorDefines an abstract parent class of all translators that convert between LCM message bytes and drake::systems::VectorBase objects
 CLcmDrivenLoopThis 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 >
 CLcmMessageToTimeInterfaceA generic translator interface that extracts time in seconds from an abstract type
 CLcmPixelTraits< PixelFormat >
 CLcmPixelTraits< PixelFormat::kBgr >
 CLcmPixelTraits< PixelFormat::kBgra >
 CLcmPixelTraits< PixelFormat::kDepth >
 CLcmPixelTraits< PixelFormat::kGrey >
 CLcmPixelTraits< PixelFormat::kLabel >
 CLcmPixelTraits< PixelFormat::kRgb >
 CLcmPixelTraits< PixelFormat::kRgba >
 CLcmReceiveThreadMaintains a thread that receives LCM messages and dispatches the messages to the appropriate message handlers
 CLcmTranslatorDictionaryA 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 >
 CLinearMatrixEqualityExampleFor 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
 CLinearSystemExample1Simple example x = b
 CLineOffsetSpecification 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 >
 CLowerBoundedProblemThis 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 mass-damper-spring system
 CMatGradMult< DerivedDA, DerivedB >
 CMatGradMultMat< DerivedA, DerivedB, DerivedDA >
 CMathematicalProgramMathematicalProgram stores the decision variables, the constraints and costs of an optimization problem
 CMathematicalProgramResultThe result returned by MathematicalProgram::Solve()
 CMathematicalProgramSolverInterfaceInterface used by implementations of individual solvers
 CMatlabRemoteVariableHolds a reference to a variable stored on the matlab client, which can be passed back into a future lcm_call_matlab call
 CMGKukaIIwaRobot< T >This class is Drake's interface to the MotionGenesis solution for a 7-DOF KUKA LBR iiwa robot (14 kg payload) which is described at: https://www.kuka.com/en-de/products/robot-systems/industrial-robots/lbr-iiwa Geometry, joint-types, and mass/inertia properties are contained in: drake/multibody/benchmarks/kuka_iiwa_robot/kuka_iiwa_robot.urdf
 CMinDistanceFromPlaneToOriginAn 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
 CMixedIntegerBranchAndBoundGiven a mixed-integer optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branch-and-bound process
 CMixedIntegerBranchAndBoundNodeA node in the branch-and-bound (bnb) tree
 CMixedIntegerRotationConstraintGeneratorWe relax the non-convex SO(3) constraint on rotation matrix R to mixed-integer linear constraints
 CConstraintSolver< T >::MlcpToLcpDataStructure used to convert a mixed linear complementarity problem to a pure linear complementarity problem (by solving for free variables)
 CMobilizerTopologyData structure to store the topological information associated with a Mobilizer object
 CMobyLcpSolverIdNon-template class for MobyLcpSolver<T> constants
 CModelModel is an abstract base class of a collision model
 CModelInstanceInfo< T >
 CModelValuesRepresents models for a sequence of AbstractValues (usually a sequence of either input or output ports)
 CPolynomial< _CoefficientType >::MonomialAn additive atom of a Polynomial: The product of any number of Terms and a coefficient
 CMonomialRepresents a monomial, a product of powers of variables with non-negative integer exponents
 CMovingAverageFilter< T >The implementation of a Moving Average Filter
 CMultibodyForces< T >A class to hold a set of forces applied to a MultibodyTree system
 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< ElementType< T >, ElementIndexType >A class representing an element or component of a MultibodyTree
 CMultibodyTreeTopologyData structure to store the topological information associated with an entire MultibodyTree
 CMultilaneOnrampMergeMultilaneOnrampMerge contains an example lane-merge scenario expressed as a maliput mulitilane road geometry
 CMultilaneRoadCharacteristicsMultilaneRoadCharacteristics 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==Eigen::Dynamic ? Eigen::Dynamic :Rows *(Rows+1)/2 >
 CNewVariableNames< Size >The type of the names for the newly added variables
 CRightOfWayPhaseProvider::Result::NextInformation about a subsequent phase
 CRightOfWayStateProvider::Result::NextInformation about a subsequent State
 CNiceTypeNameObtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types
 CNonConvexQPproblem1This test comes from Section 2.2 of Handbook of Test Problems in Local and Global Optimization
 CNonConvexQPproblem2This test comes from Section 2.3 of Handbook of Test Problems in Local and Global Optimization
 CNonSymbolicTraitsA concrete traits class providing sugar to disable support for symbolic evaluation (i.e., the symbolic::Expression scalar type)
 CObjFeaturesMultitude of parameters for generating an OBJ model of a road surface, with sensible defaults
 COptitrackConfigurationOptitrack information required for a pick-and-place scenario with multiple arms, tables, and manipulable objects
 COptitrackInfoInformation required to track a model from an Optitrack frame
 COutputPortBaseOutputPortBase handles the scalar type-independent aspects of an OutputPort
 Coverload_cast_impl< Return, Args >
 CPackageMapMaps ROS package names to their full path on the local file system
 CParametersThese 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 >
 CParamSetA class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller
 CParserParses SDF and URDF input files into a MultibodyPlant and (optionally) a SceneGraph
 CPasskey< T >Simple generic implementation of the "Passkey Idiom"
 CPendulumParametersThis 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::PeriodicBoundaryConditionFor algorithms that rely on approximations of the state-dynamics (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)
 CPeriodicEventDataComparatorStructure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method
 CPickAndPlaceStateMachineA class which controls the pick and place actions for moving a single target in the environment
 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 >
 CPlannerConfigurationInformation required to set up a planner for a pick-and-place task
 CPointCloudImplements 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 multi-variate polynomial, modeled after the msspoly in spotless
 CPolynomialRepresents symbolic polynomials
 CPolynomial< CoefficientType >
 CGlobalInverseKinematics::Polytope3DDescribes a polytope in 3D as 𝐀 * 𝐱 ≤ 𝐛 (a set of half-spaces), 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
 CPoseVelocityWraps 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
 CPositionKinematicsCache< T >This class is one of the cache entries in MultibodyTreeContext
 CCurve2< T >::PositionResultA 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 > >
 CPythonApi< PythonRemoteVariable >
 CQpInputInput to the QP inverse dynamics controller
 CQpOutputOutput of the QP inverse dynamics controller
 CQueryObject< T >The QueryObject serves as a mechanism to perform geometry queries on the world's geometry
 CRoadRulebook::QueryResultsResults of a FindRules() query
 CRandomClutterGeneratorGiven a RigidBodyTree containing a given scene, the RandomClutterGenerator can repeatedly generate bounded random poses/configurations on selected model instances within the tree
 CRandomSimulationResultA snapshot of the generator used to produce the random simulation
 CRandomState< Distribution, Generator >State for a given random distribution and generator
 CRationalFunctionRepresents symbolic rational function
 CRBoundsBounds 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::Arrays
 CRenderingConfigCommon configurations of rendering systems
 Creset_after_move< T >Type wrapper that performs value-initialization on the wrapped type, and guarantees that when moving from this type that the donor object is reset to its value-initialized value
 Creset_after_move< const std::type_info *>
 Creset_after_move< int >
 Creset_on_copy< T >Type wrapper that performs value-initialization 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 > >
 CResolvedContactThis class holds contact force related information, and works closely with ContactInformation
 CRightOfWayPhaseProvider::ResultResult returned by GetPhase()
 CRightOfWayStateProvider::ResultResult returned by GetState()
 CRewritingRuleA RewritingRule, lhs => rhs, consists of two Patterns lhs and rhs
 CRgbdRendererAbstract interface of RGB-D renderers, which render RGB, depth and label images using VisualElement
 CRightOfWayPhaseA group of RightOfWayRule instances and their states
 CRightOfWayPhaseBookAbstract interface for providing the mapping from RightOfWayRule::Id to RightOfWayPhaseRing
 CRightOfWayPhaseProviderAbstract interface for providing the dynamic states (RightOfWayPhase::Id) of a collection of RightOfWayPhaseRings
 CRightOfWayPhaseRingA set of mutually exclusive phases, e.g., that comprise the signalling cycle for an intersection
 CRightOfWayRuleRule describing right-of-way, a.k.a
 CRightOfWayStateProviderAbstract interface for the provider of the state of a dynamic (multiple state) RightOfWayRule
 CRigidBody< T >
 CRigidBody< double >
 CRigidBodyActuatorDefines a physical actuator (i.e., an electric motor and step-down transmission) that operates on a joint
 CRigidBodyConstraintAbstract base class
 CRigidBodyDistanceConstraintDefines 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 >
 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 >
 CRigidBodyTreeConstantsDefines RigidBodyTree constants
 CRigidTransform< T >This class represents a proper rigid transform between two frames which can be regarded in two ways
 CRigidTransform< double >
 CRoadCharacteristicsHolds common api::RoadGeometry characteristics needed to construct one
 CRoadCurveDefines an interface for a path in a Segment object surface
 CRoadGeometryAbstract API for the geometry of a road network, including both the network topology and the geometry of its embedding in 3-space
 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
 CRoadPositionA position in the road network, consisting of a pointer to a specific Lane and a Lane-frame position in that Lane
 CRoadRulebookAbstract interface for querying "rules of the road"
 CRobotKinematicState< T >A wrapper class around KinematicsCache and several useful matrices such as the inertia matrix, etc
 CRobotKinematicState< double >
 CRobotStateLcmMessageTranslatorThis 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 Space-fixed (extrinsic) X-Y-Z rotation by "roll-pitch-yaw" angles [r, p, y], which is equivalent to a Body-fixed (intrinsic) Z-Y-X rotation by "yaw-pitch-roll" angles [y, p, r]
 CRot3An R^3 rotation parameterized by roll, pitch, yaw
 CRotationA 3-dimensional rotation
 CRotationalInertia< T >This class helps describe the mass distribution (inertia properties) of a body or composite body about a particular point
 CRotationalInertia< 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 >
 CScsSolverDetailsThe SCS solver details after calling Solve function in ScsSolver
 CSegmentA Segment represents a bundle of adjacent Lanes which share a continuously traversable road surface
 CSerializerInterfaceSerializerInterface translates between LCM message bytes and drake::systems::AbstractValue objects that contain LCM messages, e.g., a Value<lcmt_drake_signal>
 CShapeThe base interface for all shape specifications
 CShapeReifierThe interface for converting shape descriptions to real shapes
 CShapeTag< ShapeType >Simple struct for instantiating the type-specific Shape functionality
 CSignalLog< T >This class serves as an in-memory cache of time-dependent 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
 CSimpleTreeVisualizerA utility to render a RigidBodyTree in a specified configuration
 CSimulatedPlantConfigurationInformation required to set up a simulation of a pick-and-place scenario with multiple arms, tables, and manipulable objects
 CSimulatePlantToRestGiven 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
 CSolverIdIdentifies a MathematicalProgramSolverInterface implementation
 CSolverOptionsStores options for multiple solvers
 CSolverResultThis class is used by implementations of the class MathematicalProgramSolverInterface to report their results to the mathematical program
 CSolverTypeConverterConverts between SolverType and SolverId
 CGurobiSolver::SolveStatusInfoContains 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 >
 CSpatialVector< SpatialForce, T >
 CSpatialVector< SpatialMomentum, T >
 CSpatialVector< SpatialVelocity, double >
 CSpatialVector< SpatialVelocity, T >
 CStartReference::SpecDefines how a Connection's reference curve starts
 CEndReference::SpecDefines how a Connection's reference curve ends
 CStartLane::SpecDefines how a Connection's lane curve starts
 CEndLane::SpecDefines how a Connection's lane curve ends
 CAntiderivativeFunction< T >::SpecifiedValuesThe set of values that, along with the function being integrated, partially specify the definite integral i.e
 CInitialValueProblem< T >::SpecifiedValuesA collection of values i.e
 CScalarInitialValueProblem< T >::SpecifiedValuesA collection of values i.e
 CSpeedLimitRuleRule describing speed limits
 CSRangeDirected, inclusive longitudinal (s value) range from s0 to s1
 CSrhFaceA Lane-frame face: a sequence of vertices expressed in the (s,r,h) coordinates of an api::Lane (which is not referenced here)
 CStartLaneProvides methods to build an StartLane::Spec
 CStartReferenceProvides methods to build an StartReference::Spec
 CRightOfWayRule::StateSemantic 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
 CState< AutoDiffXd >
 CState< double >
 CStateFeedbackControllerInterface< T >Interface for state feedback controllers
 CStateFeedbackControllerInterface< double >
 CStepInfo< T >Contains information about the independent variable including time and step number
 CStepInfo< AutoDiffXd >
 CStepInfo< double >
 CStepInfo< drake::symbolic::Expression >
 CLaneEnd::StrictOrderAn arbitrary strict complete ordering, useful for, e.g., std::map
 CSystemConstraint< T >A SystemConstraint is a generic base-class for constraints on Systems
 CSystemConstraint< AutoDiffXd >
 CSystemConstraint< double >
 CSystemIdentification< CoefficientType >Utility functions for system identification
 CSystemIdentification< CoefficientType >::SystemIdentificationResultA helper struct to hold System ID results
 CSystemOutput< T >Conveniently stores a snapshot of the values of every output port of a System
 CSystemOutput< double >
 CSystemOutput< drake::symbolic::Expression >
 CSystemScalarConverterHelper class to convert a System<U> into a System<T>, intended for internal use by the System framework, not directly by users
 CSystemSymbolicInspectorThe SystemSymbolicInspector uses symbolic::Expressions to analyze various properties of the System, such as time invariance and input-to-output 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 single-parameter templates
 CPolynomial< _CoefficientType >::TermAn individual variable raised to an integer power; e.g. x**2
 CTimeVaryingDataStores matrix data necessary to construct an affine 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 time-varying matrix, indexed by a single scalar double time
 CTrajectoryA class that wraps a piecewise trajectory instantiated from pose data
 CTrajectory< double >
 CTranslatorBase< DataType, MsgType >Base API for a translator between arbitrary data of DataType and a Lcm message of MsgType
 CTrigPoly< _CoefficientType >A scalar multi-variate polynomial containing sines and cosines
 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_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_defaultVisit 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 type-safe non-negative 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
 Cunique_ptr< T >STL class
 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 >
 CUnrevisedLemkeSolverIdNon-template class for UnrevisedLemkeSolver<T> constants
 CUseDefaultName(Advanced.) Tag type that indicates a system or port should use a default name, instead of a user-provided name
 CVariableRepresents a symbolic variable
 CVariablesRepresents a set of variables
 CVectorBase< T >VectorBase is an abstract base class that real-valued signals between Systems and real-valued System state vectors must implement
 CVectorBase< AutoDiffXd >
 CVectorBase< double >
 CVectorBase< drake::symbolic::Expression >
 CVectorSetpoint< Scalar >
 CVelocityKinematicsCache< T >This class is one of the cache entries in MultibodyTreeContext
 CVisualMaterialDefinition of material for simple visualization
 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
 CWorldStateA 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 pass-through
 Cwrap_arg_default< const std::function< Signature > & >
 Cwrap_arg_default< const T * >
 Cwrap_function_impl< wrap_arg_policy, use_functions >::wrap_arg_functions< const std::function< Return(Args...)> & >
 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 >
 CZMPPlannerGiven a desired two dimensional (X and Y) zero-moment point (ZMP) trajectory parameterized as a piecewise polynomial, an optimal center of mass (CoM) trajectory is planned using a linear inverted pendulum model (LIPM)
 CZMPTestTrajA structure for storing trajectories from simulating a linear inverted pendulum model (LIPM) using the policy from a ZMPPlanner
 Cconst int
 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 >
 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 >
 CVector3< double >
 CVector6< double >
 CVector6< T >
 CVectorX< double >