Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 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 >
 CActionBase class for actions used by the pick and place demo
 CAddRotationMatrixBilinearMcCormickMilpConstraintsReturn< kNumIntervalsPerHalfAxis >The return types from AddRotationMatrixBilinearMcComickMilpConstraints
 CArcLengthParameterizedSplineAn extension for ignition::math::Splines that reparameterizes them by path length
 CArcOffsetSpecification for path offset along a circular arc
 CArcOffsetSpecification for path offset along a circular arc
 CArticulatedBodyInfluenceDescription on how the optimization affects a body
 CArticulatedIcpBodyPointsContains a group of points to be rendered in a linearized ICP cost
 CArticulatedIcpErrorCostAccumulate errors and render the cost into an appropriate format
 CArticulatedIcpErrorSetA set of Cartesian errors and their gradients: {(eᵢ, Jᵢ)}ᵢ₌₁..ₙ
 Cassert_if_is_constraint< F >Template condition to only catch when Constraints are inadvertently passed as an argument
 CAutoDiffToGradientMatrix< Derived >
 CAutoDiffToValueMatrix< Derived >
 CAutomotiveSimulator< T >AutomotiveSimulator is a helper class for constructing and running automotive-related simulations
 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 >
 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
 CBuilderConvenient builder class which makes it easy to construct a monolane road network
 CBuilderConvenient builder class which makes it easy to construct a multilane road network
 CBuilderA class to ease the construction of a RoadGeometry from Connection and DirectedWaypoint objects
 CCacheCache is a key-value store used within the System2 framework to avoid computing intermediate data multiple times during simulation or analysis
 CCacheEntryA single cached piece of data, its validity bit, and the set of other cache entries that depend on it
 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
 CCarVis< T >CarVis is a base class that provides visualization geometries and their poses
 CClosestPose< T >ClosestPose bundles together the RoadOdometry of a particular target along with its distance measure relative to the ego vehicle
 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
 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
 CColorPaletteCreates 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)
 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< double >
 CConditionTraits< symbolic::Formula >
 CConnectionRepresentation of a reference path connecting two endpoints
 CConnectionRepresentation of a reference path connecting two endpoints
 CConnectionA container that holds the information needed by a Builder to construct one or more Lane objects
 CPidControlledSystem< T >::ConnectResultThe return type of ConnectController
 CGeometryState< T >::MapKeyRange< K, V >::ConstIterator
 CConstrainedValuesBase class for specifying various desired objectives
 CConstraintAccelProblemData< T >Structure for holding constraint data for computing constraint forces at the acceleration-level
 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
 CContactDetail< double >
 CContactForce< T >The data for a single contact force applied to one body of a contacting pair
 CContactForce< double >
 CContactInfo< T >A class containing information regarding contact response between two bodies including:
 CContactInfo< double >
 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 containg the contact results (contact points and response spatial forces for each colliding pair of collision elements)
 CContactResults< double >
 CContext< T >Context is an abstract base class template that represents all the inputs to a System: time, state, and input vectors
 CContext< AutoDiffXd >
 CContext< double >
 CContext< symbolic::Expression >
 CContinuousState< T >ContinuousState is a container for all the continuous state variables xc
 CContinuousState< double >
 CContinuousState< symbolic::Expression >
 CCubicPolynomialA cubic polynomial, f(p) = a + b*p + c*p^2 + d*p^3
 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
 CDataTypeTraits< DataType, false >
 CDelegatingHasherAn adapter that forwards the HashAlgorithm::operator(data, length) function concept into a runtime-provided std::function of the same signature
 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 >
 CDirectedWaypointA container that holds the information needed by a Builder to construct a Lane from a sequence of ignition::rndf::Waypoint objects
 CDiscreteValues< T >DiscreteValues is a container for numerical but non-continuous state and parameters
 CDiscreteValues< AutoDiffXd >
 CDiscreteValues< double >
 CDiscreteValues< 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
 CDrakeLcmMessageHandlerInterfaceDefines a message handler interface that must be implemented by all LCM subscribers within Drake
 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
 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
 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
 CEndpointComplete set of parameters for an endpoint of a connection, specified in the world frame
 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
 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
 CEndpointZOut-of-plane parameters for an endpoint of a connection, specified in the world frame
 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 >
 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
 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 > >
 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
 CFieldsAllows combination of BaseField and DescriptorType for a PointCloud
 CFindResourceResultModels the outcome of drake::FindResource
 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
 CFrameCache< double >
 CFramedIsometry3< T >An isometric transform along with the frame in which it is defined
 CFramedIsometry3< double >
 CFrameIdVectorRepresents an ordered set of frame identifiers
 CFrameKinematicsVector< KinematicsValue >A FrameKinematicsVector associates a std::vector with a geometry source
 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 toque-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
 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 >
 CGeometryFrameThis simple class carries the definition of a frame used by GeometryWorld
 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
 CGeometryState< T >The context-dependent state of GeometryWorld
 CGeoPositionT< T >A position in 3-dimensional geographical Cartesian space, i.e., in the world frame, consisting of three components x, y, and z
 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
 CGroupA group of Connections
 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
 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 >
 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
 CImageTraits< PixelType >Traits class for Image
 CImageTraits< PixelType::kBgr8U >
 CImageTraits< PixelType::kBgra8U >
 CImageTraits< PixelType::kDepth16U >
 CImageTraits< PixelType::kDepth32F >
 CImageTraits< PixelType::kGrey8U >
 CImageTraits< PixelType::kLabel16I >
 CImageTraits< PixelType::kRgb8U >
 CImageTraits< PixelType::kRgba8U >
 CInitializeAutoDiffTupleHelper< Index >Helper for initializeAutoDiffTuple function (recursive)
 CInitializeAutoDiffTupleHelper< 0 >Helper for initializeAutoDiffTuple function (base case)
 CInputPortDescriptor< T >InputPortDescriptor is a notation for specifying the kind of input a System accepts, on a given port
 CInputPortDescriptor< AutoDiffXd >
 CInputPortDescriptor< double >
 CInputPortEvaluatorInterface< T >InputPortEvaluatorInterface is implemented by classes that are able to evaluate the OutputPortValue connected to a particular InputPortValue
 CInputPortEvaluatorInterface< AutoDiffXd >
 CInputPortEvaluatorInterface< double >
 CIntegratorBase< T >An abstract class for an integrator for ODEs and DAEs as represented by a Drake System
 CIntegratorBase< double >
 CInternalFrameThis class represents the internal representation of a GeometryFrame
 CInternalGeometryBaseBase class for the internal representation of registered geometry
 CInvalidDepthSet of constants used to represent invalid depth values
 CInverseFunctionInterpolatorA linear interpolator for arbitrary inverse functions
 Cis_numeric< T >Is_numeric is true for types that are on the real line
 Cis_numeric< symbolic::Expression >Specializes is_numeric to be false for symbolic::Expression type
 CIsoLaneVelocityIsometric velocity vector in a Lane-frame
 CJoint< T >::JointImplementation(Advanced) A Joint is implemented in terms of MultibodyTree elements such as bodies, mobilizers, force elements and constraints
 CJointImplementationBuilder< T >
 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 >
 CKinematicsResults< T >A class containing the kinematics results from a RigidBodyPlant system
 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
 CLanePositionT< T >A 3-dimensional position in a Lane-frame, consisting of three components:
 CLanePositionT< double >
 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
 CLcmMessageToTimeInterfaceA generic translator interface that extracts time in seconds from an abstract type
 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
 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 >
 CloggerA stubbed-out version of spdlog::logger
 CLowerBoundedProblemThis test comes from Section 3.4 of Handbook of Test Problems in Local and Global Optimization
 CMassDamperSpringAnalyticalSolution< T >This class provides an analytical solution to a mass-damper-spring system
 CMatGradMult< DerivedDA, DerivedB >
 CMatGradMultMat< DerivedA, DerivedB, DerivedDA >
 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
 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)
 CMonolaneOnrampMergeMonolaneOnrampMerge contains an example lane-merge scenario expressed as a maliput monolane road geometry
 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
 CMultibodyTree< T >MultibodyTree provides a representation for a physical system consisting of a collection of interconnected rigid and deformable bodies
 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
 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
 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
 COutputPort< T >An OutputPort belongs to a System and represents the properties of one of that System's output ports
 COutputPort< AutoDiffXd >
 COutputPort< double >
 COutputPortListenerInterfaceOutputPortListenerInterface is an interface that consumers of an output port must satisfy to receive notifications when the value of that output port may have changed
 COutputPortValueOutputPortValue contains the value of a single System output port
 CPackageMapMaps ROS package names to their full path on the local file system
 CParameters< T >Parameters is a container for variables that parameterize a System so that it can represent a family of related models
 CParameters< double >
 CParamSetA class for parsing and storing parameters that are used to generate QpInput for the inverse dynamics controller
 CPenetrationAsPointPair< T >A characterization of the intersection of two penetrating geometries
 CEvent< T >::PeriodicAttributeA token describing an event that recurs on a fixed period
 CPeriodicAttributeComparator< T >Structure for comparing two PeriodicAttributes 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
 CPointCorrespondenceSimple point-to-point correspondence
 CPointPairStructure containing the results of a collision query
 CPolynomial< _CoefficientType >A scalar multi-variate polynomial, modeled after the msspoly in spotless
 CPolynomialRepresents symbolic polynomials
 CPolynomial< CoefficientType >
 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
 CTrajectoryCar< T >::PositionHeadingData structure returned by CalcRawPose containing raw pose information
 CPositionKinematicsCache< T >This class is one of the cache entries in MultibodyTreeContext
 CCurve2< T >::PositionResultA result type for the GetPosition method
 CPolynomial< _CoefficientType >::Product< Rhs, Lhs >
 CTrigPoly< _CoefficientType >::Product< Rhs, Lhs >
 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
 CQueryHandle< T >The QueryHandle serves as a mechanism to allow LeafSystem instances to perform geometry queries on GeometrySystem
 CRandomState< Distribution, Generator >State for a given random distribution and generator
 CRBoundsBounds in the lateral dimension (r component) of a Lane-frame, consisting of a pair of minimum and maximum r value
 Creinit_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
 Creinit_after_move< int >
 CRelationalOpTraits< DerivedA, DerivedB, typename >Provides a return type of relational operations (=, ≠, ≤, <, ≥, >) between Eigen::Arrays
 CResizeDerivativesToMatchScalarImpl< Derived, Scalar >
 CResizeDerivativesToMatchScalarImpl< Derived, Eigen::AutoDiffScalar< DerivType > >
 CResolvedContactThis class holds contact force related information, and works closely with ContactInformation
 CRgbdRendererAn RGB-D renderer that renders RGB, depth and label images using VisualElement
 CRigidBody< T >
 CRigidBody< double >
 CRigidBodyActuatorDefines a physical actuator (i.e., an electric motor and step-down transmission) that operates on a joint
 CRigidBodyConstraintBase class
 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
 CRoadCharacteristicsRoadCharacteristics computes and stores characteristics of a road network; i.e
 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
 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
 CRot3An R^3 rotation parameterized by roll, pitch, yaw
 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 >
 CSampleIndicesDescribes the row indices of a Sample
 CSceneA scene describes a group of objects (stored within a rigid body tree structure), the world frame, and the camera frame
 CSceneStateStored state of a scene
 CSdfJointA representation of a <joint> element in an SDF file
 CSdfLinkA representation of a <link> element in an SDF file
 CSdfModelThis class provides a representation of a <model> element within a given SDF specification
 CSdfSpecThis class provides a representation for an SDF specification
 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 >
 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
 CSimulator< T >A forward dynamics solver for hybrid dynamic systems represented by System<T> objects
 CSimulator< double >
 CTrigPoly< _CoefficientType >::SinCosVars
 CSolverIdIdentifies a MathematicalProgramSolverInterface implementation
 CSolverTypeConverterConverts between SolverType and SolverId
 CGurobiSolver::SolveStatusInfoContains info returned to a user function that handles a Node or Solution callback
 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< SpatialVelocity, T >
 CState< T >State is a container for all the data comprising the complete state of a particular System at a particular moment
 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< symbolic::Expression >
 CLaneEnd::StrictOrderAn arbitrary strict complete ordering, useful for, e.g., std::map
 CSystem< T >A superclass template for systems that receive input, maintain state, and produce output of a given mathematical type T
 CSystem< AutoDiffXd >
 CSystem< double >
 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 >An abstract base class template for the values of the output ports of a System
 CSystemOutput< double >
 CSystemOutput< 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
 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)
 CTrackedBodyA structure used to store the attributes of a tracked rigid body
 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::GeometrySystem >
 CTrajectoryA Trajectory represents a time-varying matrix of doubles
 CTransformSpatial< Derived >
 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
 CTypeSafeIndex< Tag >A type-safe non-negative index class
 CTypeSafeIndex< class AnchoredGeometryTag >
 CTypeSafeIndex< class BodyNodeTag >
 CTypeSafeIndex< class BodyTag >
 CTypeSafeIndex< class ForceElementTag >
 CTypeSafeIndex< class FrameTag >
 CTypeSafeIndex< class GeometryPoseTag >
 CTypeSafeIndex< class GeometryTag >
 CTypeSafeIndex< class MobilizerTag >
 CTypeSafeIndex< class OutputPortTag >
 CTypeSafeIndex< class RobotBaseTag >
 CTypeSafeIndex< class TargetTag >
 CTypeSpecificIdentifier< T >TypeSpecificIdentifier<T> represents an identifier specifically identifying an entity of type T
 Cuhash< HashAlgorithm >A hashing functor, somewhat like std::hash
 Cunique_ptr< T >STL class
 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< symbolic::Expression >
 CVectorSetpoint< Scalar >
 CVelocityKinematicsCache< T >This class is one of the cache entries in MultibodyTreeContext
 CWitnessFunction< T >Abstract class that describes a function that is able to help determine the time and state at which a simulation should be halted, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling)
 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
 CZMPPlannerGiven a desired two dimensional (X and Y) zero-moment point (ZMP) trajectory parametrized 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
 CCollisionFilterGroup< double >
 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< typename drake::systems::Event< double >::PeriodicAttribute, 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 >