| CAabb | Axis-aligned bounding box |
| CAabbMaker< MeshType > | AabbMaker implements the logic to fit an Aabb to a collection of points |
| CAbstractValue | A fully type-erased container class |
| CValue< T > | A container class for an arbitrary type T (with some restrictions) |
| CAbstractValues | AbstractValues is a container for non-numerical state and parameters |
| CAcrobot< T > | The Acrobot - a canonical underactuated system as described in Chapter 3 of Underactuated Robotics |
| CAcrobotInputIndices | Describes the row indices of a AcrobotInput |
| CAcrobotParameters | This class is used to store the numerical parameters defining the model of an acrobot with the method MakeAcrobotPlant() |
| CAcrobotParamsIndices | Describes the row indices of a AcrobotParams |
| CAcrobotStateIndices | Describes the row indices of a AcrobotState |
| CAddCollisionFilterGroup | Directive to add a collision filter group |
| CAddDirectives | Directive to incorporate another model directives file, optionally with its elements prefixed with a namespace |
| CCollisionChecker::AddedShape | Representation of an "added" shape |
| CAddFrame | Directive to add a Frame to the scene |
| CAddModel | Directive to add a model from a URDF or SDFormat file to a scene, using a given name for the added instance |
| CAddModelInstance | Directive to add an empty, named model instance to a scene |
| CAddMultibodyPlantSceneGraphResult< T > | Temporary result from AddMultibodyPlantSceneGraph |
| CAddRotationMatrixBoxSphereIntersectionReturn | Some of the newly added variables in function AddRotationMatrixBoxSphereIntersectionMilpConstraints |
| CAddWeld | Directive to add a weld between two named frames, a parent and a child |
| CRotation::AngleAxis | Rotation constructed from a fixed axis and an angle |
| CSpatialVelocityConstraint::AngularVelocityBounds | Parametrizes bounds on the magnitude and direction of the angular velocity vector |
| 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 |
| 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 |
| CAugmentedLagrangianNonsmooth | Compute the augmented Lagrangian (AL) of a given mathematical program |
| CAugmentedLagrangianSmooth | Compute the augmented Lagrangian (AL) of a given mathematical program |
| CAutoDiff | A scalar type that performs automatic differentiation, similar to Eigen::AutoDiffScalar<Eigen::VectorXd> |
| CBarycentricMesh< T > | Represents a multi-linear function (from vector inputs to vector outputs) by interpolating between points on a mesh using (triangular) barycentric interpolation |
| CBasisElementGradedReverseLexOrder< VariableOrder, BasisElement > | Implements Graded reverse lexicographic order |
| CBeamModelParamsIndices | Describes the row indices of a BeamModelParams |
| CCspaceFreePolytope::BilinearAlternationOptions | Options for bilinear alternation |
| CCspaceFreePolytope::BinarySearchOptions | Options for binary search |
| CBinding< C > | A binding on constraint type C is a mapping of the decision variables onto the inputs of C |
| CBinding< C > | A binding on constraint type C is a mapping of the decision variables onto the inputs of C |
| CBodyShapeDescription | BodyShapeDescription captures all the information necessary to describe a SceneGraph collision shape associated with a MultibodyPlant Body: a shape S, the MultibodyPlant body B (identified by model instance and body names), and the rigid pose of the shape S relative to the body B, X_BS |
| CBodySpheres | Container for all spheres belonging to a single body's collision model |
| Cbool_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 > | |
| CBound | Stores the lower and upper bound of a variable |
| CBsplineBasis< T > | Given a set of non-descending breakpoints t₀ ≤ t₁ ≤ ⋅⋅⋅ ≤ tₘ, a B-spline basis of order k is a set of n + 1 (where n = m - k) piecewise polynomials of degree k - 1 defined over those breakpoints |
| CFemModel< T >::Builder | Builder that builds the FemModel |
| CBusValue | BusValue is a value type used on input ports and output ports to group labeled signals into a single port |
| CImageIo::ByteSpan | When loading from memory, this struct denotes a span of raw bytes as input |
| CCache | (Advanced) 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 | (Advanced) This is the representation in the Context for the value of one of a System's CacheEntry objects |
| CCalcGridPointsOptions | |
| CDifferentialInverseKinematicsSystem::CallbackDetails | (Internal use only) A group of common arguments relevant to multiple different costs and constraints within the DifferentialInverseKinematicsSystem program formulation |
| CCameraConfig | Configuration of a camera |
| CCameraInfo | Simple class for characterizing the Drake camera model |
| CChebyshevPolynomial | Represents the Chebyshev polynomial of the first kind Tₙ(x) |
| CCIrisCollisionGeometry | This class contains the necessary information about the collision geometry used in C-IRIS |
| CClarabelSolverDetails | The Clarabel solver details after calling the Solve() function |
| CClippingRange | Defines the near and far clipping planes for frustum-based (OpenGL) RenderEngine cameras |
| CClpSolverDetails | The CLP solver details after calling Solve() function |
| CCodeGenVisitor | Visitor class for code generation |
| CCollisionChecker | Interface for collision checkers to use |
| CSceneGraphCollisionChecker | An implementation of CollisionChecker that uses SceneGraph to provide collision checks |
| CUnimplementedCollisionChecker | A concrete collision checker implementation that throws an exception for every virtual function hook |
| CSphereRobotModelCollisionChecker | Base class for collision checkers using a sphere-geometry robot model |
| CMbpEnvironmentCollisionChecker | Sphere-model robot collision checker using MbP/SG to model environment geometry |
| CVoxelizedEnvironmentCollisionChecker | Collision checker using a voxelized environment model |
| CCollisionCheckerContext | This class represents the data necessary for CollisionChecker to operate safely across multiple threads in its const API |
| CCollisionCheckerParams | A set of common constructor parameters for a CollisionChecker |
| CCollisionFilterDeclaration | Class for articulating changes to the configuration of SceneGraph's "collision filters"; collision filters limit the scope of various proximity queries |
| CCollisionFilterGroups | This is storage for parsed collision filter groups and group pairs |
| CCollisionFilterManager | Class for configuring "collision filters"; collision filters limit the scope of various proximity queries |
| CColorRenderCamera | Collection of camera properties for cameras to be used with color/label images |
| CCommonSampledIrisOptions | Various options which are common to the sampling-based algorithms IrisNp2 and IrisZo for generating collision free polytopes in configuration space |
| CCompassGaitContinuousStateIndices | Describes the row indices of a CompassGaitContinuousState |
| CCompassGaitParamsIndices | Describes the row indices of a CompassGaitParams |
| 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< double > | |
| CLeafCompositeEventCollection< double > | |
| CCompositeEventCollection< drake::ad::AutoDiff > | |
| CLeafCompositeEventCollection< drake::ad::AutoDiff > | |
| CConditionTraits< symbolic::Formula > | |
| CDifferentialInverseKinematicsSystem::CartesianPositionLimitConstraint::Config | |
| CDifferentialInverseKinematicsSystem::CartesianVelocityLimitConstraint::Config | |
| CDifferentialInverseKinematicsSystem::CollisionConstraint::Config | |
| CDifferentialInverseKinematicsSystem::JointCenteringCost::Config | |
| CDifferentialInverseKinematicsSystem::JointVelocityLimitConstraint::Config | |
| CDifferentialInverseKinematicsSystem::LeastSquaresCost::Config | |
| CPidControlledSystem< T >::ConnectResult | The return type of ConnectController |
| CConstraintRelaxingIk | A wrapper class around the IK planner |
| CContactResults< T > | A container class storing the contact results information for each contact pair for a given state of the simulation |
| CContactSurface< T > | The ContactSurface characterizes the intersection of two geometries M and N as a contact surface with a scalar field and a vector field, whose purpose is to support the hydroelastic pressure field contact model as described in: |
| CContactVisualizerParams | The set of parameters for configuring ContactVisualizer |
| CContactWrench | Stores the contact wrench (spatial force) from Body A to Body B applied at point Cb |
| CContextMessageInterface | |
| CContextBase | Provides non-templatized Context functionality shared by the templatized derived classes |
| CContext< Scalar > | |
| CContext< double > | |
| CContext< drake::ad::AutoDiff > | |
| 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, numeric-valued 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 |
| CSystemBase::ContextSizes | Return type for get_context_sizes() |
| 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 |
| CConvexSet | Abstract base class for defining a convex set |
| CAffineBall | Implements an ellipsoidal convex set represented as an affine scaling of the unit ball {Bu + center | |u|₂ ≤ 1} |
| CAffineSubspace | An affine subspace (also known as a "flat", a "linear variety", or a "linear
manifold") is a vector subspace of some Euclidean space, potentially translated so as to not pass through the origin |
| CCartesianProduct | The Cartesian product of convex sets is a convex set: S = X₁ × X₂ × ⋯ × Xₙ = {(x₁, x₂, ..., xₙ) | x₁ ∈ X₁, x₂ ∈ X₂, ..., xₙ ∈ Xₙ} |
| CConvexHull | Implements the convex hull of a set of convex sets |
| CHPolyhedron | Implements a polyhedral convex set using the half-space representation: {x| A x ≤ b} |
| CHyperellipsoid | Implements an ellipsoidal convex set represented by the quadratic form {x
| (x-center)ᵀAᵀA(x-center) ≤ 1} |
| CHyperrectangle | Axis-aligned hyperrectangle in Rᵈ defined by its lower bounds and upper bounds as {x| lb ≤ x ≤ ub} |
| CIntersection | A convex set that represents the intersection of multiple sets: S = X₁ ∩ X₂ ∩ ... ∩ Xₙ = {x | x ∈ X₁, x ∈ X₂, ..., x ∈ Xₙ} |
| CMinkowskiSum | A convex set that represents the Minkowski sum of multiple sets: S = X₁ ⨁ X₂ ⨁ ... ⨁ Xₙ = {x₁ + x₂ + ... + xₙ | x₁ ∈ X₁, x₂ ∈ X₂, ..., xₙ ∈ Xₙ} |
| CPoint | A convex set that contains exactly one element |
| CSpectrahedron | Implements a spectrahedron (the feasible set of a semidefinite program) |
| CVPolytope | A polytope described using the vertex representation |
| CCoulombFriction< T > | Parameters for Coulomb's Law of Friction, namely: |
| CCsdpSolverDetails | The CSDP solver details after calling Solve() function |
| CCspaceFreePolytopeBase | This virtual class is the base of CspaceFreePolytope and CspaceFreeBox |
| CCspaceFreeBox | This class tries to find large axis-aligned bounding boxes in the configuration space, such that all configurations in the boxes are collision free |
| CCspaceFreePolytope | This class tries to find large convex polytopes in the tangential-configuration space, such that all configurations in the convex polytopes is collision free |
| CCSpaceSeparatingPlane< T > | Wraps the information that a pair of collision geometries are separated by a plane |
| CDampingModel< T > | A viscous Rayleigh damping model in which the damping matrix D is a linear combination of mass and stiffness matrices, as, D = αM + βK where α and β are nonnegative |
| CDefaultProximityProperties | These properties will be used as defaults when the geometry as added via API calls or parsed from model files doesn't say anything more specific |
| CDeformableBodyConfig< T > | DeformableBodyConfig stores the physical parameters for a deformable body |
| CDeformableContactInfo< T > | A class containing information regarding contact and contact response between two geometries belonging to a pair of bodies with at least one of them being a deformable body |
| CDeformableContactInfo< symbolic::Expression > | Full specialization of DeformableContactInfo for T = Expression, with no member data |
| CDelegatingHasher | An 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) |
| 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 step-wise construction procedures |
| CHermitianDenseOutput< T > | A StepwiseDenseOutput class implementation using Hermitian interpolators, and therefore a continuous extension of the solution 𝐱(t) (see [Engquist, 2105]) |
| 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 |
| CDepthRange | Defines a depth sensor's functional range |
| CDepthRenderCamera | Collection of camera properties for cameras to be used with depth images |
| CDerivativesConstXprBase | |
| CDerivativesConstXpr | The return type for AutoDiff::derivatives() when the AutoDiff is const |
| CDescriptorType | Describes an descriptor field with a name and the descriptor's size |
| CDiagramBuilder< T > | DiagramBuilder is a factory class for Diagram |
| CDifferentialInverseKinematicsParameters | Contains parameters for the family of differential inverse kinematics function overloads below, each named DoDifferentialInverseKinematics() |
| CDifferentialInverseKinematicsResult | |
| CDiscreteValues< T > | DiscreteValues is a container for numerical but non-continuous state and parameters |
| CDiagramDiscreteValues< T > | DiagramDiscreteValues is a DiscreteValues container comprised recursively of a sequence of child DiscreteValues objects |
| CDistanceAndGradient | Wrapper that combines a distance value and gradient |
| CDistanceAndInterpolationProvider | This class represents the base interface for performing configuration distance and interpolation operations, used by CollisionChecker |
| CLinearDistanceAndInterpolationProvider | This class represents a basic "linear" implementation of DistanceAndInterpolationProvider |
| CDistanceConstraintParams | Parameters for a distance constraint |
| CDistribution | Base class for a single distribution, to be used with YAML archives |
| CDeterministic | A single deterministic value |
| CGaussian | A gaussian distribution with mean and stddev |
| CUniform | A uniform distribution with min inclusive and max exclusive |
| CUniformDiscrete | Chooses from among discrete values with equal probability |
| CDistributionVector | Base class for a vector of distributions, to be used with YAML archives |
| CDeterministicVector< Size > | A single deterministic vector value |
| CGaussianVector< Size > | A gaussian distribution with vector mean and vector or scalar stddev |
| CUniformVector< Size > | A uniform distribution with vector min inclusive and vector max exclusive |
| CDofMask | A mask on the degrees of freedom (dofs) of a MultibodyPlant instance, partitioning the plant's dofs into "selected" and "unselected" dofs |
| CDoorHingeConfig | Configuration structure for the DoorHinge |
| CDrakeLcmInterface | A pure virtual interface that enables LCM to be mocked |
| CDrakeLcm | A wrapper around a real LCM instance |
| CDrakeLcmBase | A concrete subclass of DrakeInterface that throws for all functions except the constructor and destructor |
| CDrakeLcmLog | A LCM interface for logging LCM messages to a file or playing back from a existing log |
| CLcmInterfaceSystem | LcmInterfaceSystem acts within a Diagram to allow LcmSubscriberSystem instances to receive data from the network during a simulation |
| CDrakeLcmParams | The set of parameters for configuring DrakeLcm |
| CDrakeSubscriptionInterface | A helper class returned by DrakeLcmInterface::Subscribe() that allows for (possibly automatic) unsubscription and/or queue capacity control |
| CDrakeVisualizerParams | The set of parameters for configuring DrakeVisualizer |
| CDrakeVisualizerTest< T > | |
| 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< int > | |
| Cdummy_value< symbolic::Expression > | Specializes common/dummy_value.h |
| CDynamicProgrammingOptions | Consolidates the many possible options to be passed to the dynamic programming algorithms |
| CGraphOfConvexSets::Edge | An edge in the graph connects between vertex u and vertex v |
| CEdgeMeasure | The measure of the distance of the edge from q1 to q2 and the portion of that is collision free |
| CGcsTrajectoryOptimization::EdgesBetweenSubgraphs | EdgesBetweenSubgraphs are defined as the connecting edges between two given subgraphs |
| 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 |
| CEnvironment | Represents a symbolic environment (mapping from a variable to a value) |
| CEnvironmentMap | |
| Cequal_to< drake::symbolic::Expression > | |
| Cequal_to< drake::symbolic::Formula > | |
| Cequal_to< drake::symbolic::Variable > | |
| CEquirectangularMap | |
| 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 |
| CContactWrenchEvaluator | |
| CContactWrenchFromForceInWorldFrameEvaluator | The contact wrench is τ_AB_W = 0, f_AB_W = λ Namely we assume that λ is the contact force from A to B, applied directly at B's witness point |
| CConstraint | A constraint is a function + lower and upper bounds |
| CEvaluatorConstraint< PolynomialEvaluator > | |
| CPolynomialConstraint | A constraint on the values of multivariate polynomials |
| CAngleBetweenVectorsConstraint | Constrains that the angle between a vector a and another vector b is between [θ_lower, θ_upper] |
| CCentroidalMomentumConstraint | Impose the constraint CentroidalMomentum(q, v) - h_WC = 0 with decision variables [q;v;h_WC] or CentroidalAngularMomentum(q, v) - k_WC = 0 with decision variables [q; v; k_WC] h_WC is the 6D spatial momentum (linear and angular momentum about the center of mass C) expressed in the world frame (W) |
| CComInPolyhedronConstraint | Constrains the center of mass to lie within a polyhedron lb <= A * p_EC <= ub where p_EC is the position of the center-of-mass (C) expressed in a frame E |
| CComPositionConstraint | Impose the constraint p_EScm(q) - p_EC = 0, where p_EScm(q) is a function that computes the center-of-mass (COM) position from robot generalized position q, expressed in a frame E |
| CDistanceConstraint | Constrains the distance between a pair of geometries to be within a range [distance_lower, distance_upper] |
| CGazeTargetConstraint | Constrains a target point T to be within a cone K |
| CManipulatorEquationConstraint | A Constraint to impose the manipulator equation: 0 = (Buₙ₊₁ + ∑ᵢ (Jᵢ_WBᵀ(qₙ₊₁)ᵀ * Fᵢ_AB_W(λᵢ,ₙ₊₁)) |
| CMinimumDistanceLowerBoundConstraint | Constrain min(d) >= lb, namely the signed distance between all candidate pairs of geometries (according to the logic of SceneGraphInspector::GetCollisionCandidates()) to be no smaller than a specified minimum distance lb |
| CMinimumDistanceUpperBoundConstraint | Constrain min(d) <= ub, namely at least one signed distance between a candidate pairs of geometries (according to the logic of SceneGraphInspector::GetCollisionCandidates()) to be no larger than a specified ub |
| COrientationConstraint | Constrains that the angle difference θ between the orientation of frame A and the orientation of frame B to satisfy θ ≤ θ_bound |
| CPointToLineDistanceConstraint | Constrain that the distance between a point P on frame B1 and another line L on frame B2 is within a range [distance_lower, distance_upper] |
| CPointToPointDistanceConstraint | Constrain that the distance between a point P1 on frame B1 and another point P2 on frame B2 is within a range [distance_lower, distance_upper] |
| CPolyhedronConstraint | Constrain the position of points P1, P2, ..., Pn to satisfy the constraint A |
| CPositionConstraint | Constrains the position of a point Q, rigidly attached to a frame B, to be within a bounding box measured and expressed in frame A |
| CQuaternionEulerIntegrationConstraint | If we have a body with orientation quaternion z₁ at time t₁, and a quaternion z₂ at time t₂ = t₁ + h, with the angular velocity ω (expressed in the world frame), we impose the constraint that the body rotates at a constant velocity ω from quaternion z₁ to quaternion z₂ within time interval h |
| CSpatialVelocityConstraint | Constrains the spatial velocity of a frame C, rigidly attached to a frame B, measured and expressed in frame A |
| CStaticEquilibriumConstraint | Impose the static equilibrium constraint 0 = τ_g + Bu + ∑J_WBᵀ(q) * Fapp_B_W |
| CStaticFrictionConeConstraint | Formulates the nonlinear friction cone constraint |fₜ| ≤ μ*fₙ, where fₜ is the tangential contact force, fₙ is the normal contact force, and μ is the friction coefficient |
| CUnitQuaternionConstraint | Constrains the quaternion to have a unit length |
| CDirectCollocationConstraint | Implements the direct collocation constraints for a first-order hold on the input and a cubic polynomial representation of the state trajectories |
| CMidPointIntegrationConstraint | Implements the midpoint integration |
| CEvaluatorConstraint< EvaluatorType > | A constraint that may be specified using another (potentially nonlinear) evaluator |
| CExponentialConeConstraint | An exponential cone constraint is a special type of convex cone constraint |
| 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 |
| CLorentzConeConstraint | Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone |
| CMinimumValueLowerBoundConstraint | Constrain min(v) >= lb where v=f(x) |
| CMinimumValueUpperBoundConstraint | Constrain min(v) <= ub where v=f(x) |
| CPositiveSemidefiniteConstraint | Implements a positive semidefinite constraint on a symmetric matrix S |
| 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 |
| CSystemConstraintWrapper | This wrapper class wraps a SystemConstraint object to the format of solvers::Constraint |
| CCost | Provides an abstract base for all costs |
| CEvaluatorCost< PolynomialEvaluator > | |
| CPolynomialCost | Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y, .. |
| CAngleBetweenVectorsCost | Implements a cost of the form c*(1-cosθ), where θ is the angle between two vectors a and b |
| COrientationCost | Implements a cost of the form c * (1 - cos(θ)), where θ is the angle between the orientation of frame A and the orientation of frame B, and c is a cost scaling |
| CPositionCost | Implements a cost of the form (p_AP - p_AQ)ᵀ C (p_AP - p_AQ), where point P is specified relative to frame A and point Q is specified relative to frame B, and the cost is evaluated in frame A |
| CEvaluatorCost< EvaluatorType > | A cost that may be specified using another (potentially nonlinear) evaluator |
| CExpressionCost | Impose a generic (potentially nonlinear) cost represented as a symbolic Expression |
| CL1NormCost | Implements a cost of the form ‖Ax + b‖₁ |
| CL2NormCost | Implements a cost of the form ‖Ax + b‖₂ |
| CLInfNormCost | Implements a cost of the form ‖Ax + b‖∞ |
| CLinearCost | Implements a cost of the form |
| CPerspectiveQuadraticCost | If \( z = Ax + b,\) implements a cost of the form: |
| CQuadraticCost | Implements a cost of the form |
| 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 |
| 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 |
| 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 |
| CEventStatus | Holds the return status from execution of an event handler function, or the effective status after a series of handler executions due to dispatching of simultaneous events |
| Cexponential_distribution< drake::symbolic::Expression > | Provides std::exponential_distribution, Exp(λ), for symbolic expressions |
| CExpression | Represents a symbolic form of an expression |
| CExternallyAppliedSpatialForce< T > | |
| CExternalSystemConstraint | An "external" constraint on a System |
| CFemModel< T > | FemModel calculates the components of the spatially discretized FEM equations for dynamic elasticity problems |
| CFemModel< Element::T > | |
| CFemPlantData< T > | |
| CFemState< T > | FemState provides access to private workspace FEM state and per-element state-dependent data |
| CFields | Allows combination of BaseField and DescriptorType for a PointCloud |
| CCspaceFreePolytope::FindPolytopeGivenLagrangianOptions | Options for finding polytope with given Lagrangians |
| CFindResourceResult | Models the outcome of drake::FindResource |
| CFindSeparationCertificateOptions | |
| CCspaceFreePolytope::FindSeparationCertificateGivenPolytopeOptions | |
| CFiniteHorizonLinearQuadraticRegulatorOptions | A structure to facilitate passing the myriad of optional arguments to the FiniteHorizonLinearQuadraticRegulator algorithms |
| CFiniteHorizonLinearQuadraticRegulatorResult | A structure that contains the basic FiniteHorizonLinearQuadraticRegulator results |
| CFixedInputPortValue | A FixedInputPortValue encapsulates a vector or abstract value for use as an internal value source for one of a System's input ports |
| CCameraConfig::FocalLength | Specification of a camera's intrinsic focal properties as focal length (in pixels) |
| CForceDensityFieldBase< T > | The ForceDensityFieldBase class is an abstract base class that represents a force density field affecting deformable bodies in a MultibodyPlant |
| CForceDensityField< T > | Implementations of the ForceDensityFieldBase class should inherit from this class |
| CGravityForceField< T > | A uniform gravitational force density field for a uniform density object |
| Cformatter | |
| Cformatter< drake::geometry::GeometryId > | |
| Cformatter< drake::multibody::SpatialVector< SpatialQuantity, T > > | |
| Cformatter | |
| Cformatter< T > | |
| Cformatter< drake::ad::AutoDiff > | Specializes the fmt::formatter<> class template for drake::ad::AutoDiff |
| Cformatter< drake::copyable_unique_ptr< T > > | Specializes the fmt::formatter<> class template for drake::copyable_unique_ptr<T> |
| Cformatter< drake::geometry::Box > | Specializes the fmt::formatter<> class template for drake::geometry::Box |
| Cformatter< drake::geometry::Capsule > | Specializes the fmt::formatter<> class template for drake::geometry::Capsule |
| Cformatter< drake::geometry::Convex > | Specializes the fmt::formatter<> class template for drake::geometry::Convex |
| Cformatter< drake::geometry::Cylinder > | Specializes the fmt::formatter<> class template for drake::geometry::Cylinder |
| Cformatter< drake::geometry::Ellipsoid > | Specializes the fmt::formatter<> class template for drake::geometry::Ellipsoid |
| Cformatter< drake::geometry::GeometryProperties > | Specializes the fmt::formatter<> class template for drake::geometry::GeometryProperties |
| Cformatter< drake::geometry::HalfSpace > | Specializes the fmt::formatter<> class template for drake::geometry::HalfSpace |
| Cformatter< drake::geometry::InMemoryMesh > | Specializes the fmt::formatter<> class template for drake::geometry::InMemoryMesh |
| Cformatter< drake::geometry::Mesh > | Specializes the fmt::formatter<> class template for drake::geometry::Mesh |
| Cformatter< drake::geometry::MeshcatCone > | Specializes the fmt::formatter<> class template for drake::geometry::MeshcatCone |
| Cformatter< drake::geometry::render::LightFrame > | Specializes the fmt::formatter<> class template for drake::geometry::render::LightFrame |
| Cformatter< drake::geometry::render::LightType > | Specializes the fmt::formatter<> class template for drake::geometry::render::LightType |
| Cformatter< drake::geometry::render::RenderLabel > | Specializes the fmt::formatter<> class template for drake::geometry::render::RenderLabel |
| Cformatter< drake::geometry::Rgba > | Specializes the fmt::formatter<> class template for drake::geometry::Rgba |
| Cformatter< drake::geometry::Role > | Specializes the fmt::formatter<> class template for drake::geometry::Role |
| Cformatter< drake::geometry::Shape > | Specializes the fmt::formatter<> class template for drake::geometry::Shape |
| Cformatter< drake::geometry::Sphere > | Specializes the fmt::formatter<> class template for drake::geometry::Sphere |
| Cformatter< drake::Identifier< Tag > > | Specializes the fmt::formatter<> class template for drake::Identifier<Tag> |
| Cformatter< drake::math::RigidTransform< T > > | Specializes the fmt::formatter<> class template for drake::math::RigidTransform<T> |
| Cformatter< drake::math::RollPitchYaw< T > > | Specializes the fmt::formatter<> class template for drake::math::RollPitchYaw<T> |
| Cformatter< drake::MemoryFile > | Specializes the fmt::formatter<> class template for drake::MemoryFile |
| Cformatter< drake::multibody::CollisionFilterGroups > | Specializes the fmt::formatter<> class template for drake::multibody::CollisionFilterGroups |
| Cformatter< drake::multibody::DifferentialInverseKinematicsStatus > | Specializes the fmt::formatter<> class template for drake::multibody::DifferentialInverseKinematicsStatus |
| Cformatter< drake::multibody::PackageMap > | Specializes the fmt::formatter<> class template for drake::multibody::PackageMap |
| Cformatter< drake::multibody::RotationalInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::RotationalInertia<T> |
| Cformatter< drake::multibody::ScopedName > | Specializes the fmt::formatter<> class template for drake::multibody::ScopedName |
| Cformatter< drake::multibody::SpatialAcceleration< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialAcceleration<T> |
| Cformatter< drake::multibody::SpatialForce< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialForce<T> |
| Cformatter< drake::multibody::SpatialInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialInertia<T> |
| Cformatter< drake::multibody::SpatialMomentum< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialMomentum<T> |
| Cformatter< drake::multibody::SpatialVelocity< T > > | Specializes the fmt::formatter<> class template for drake::multibody::SpatialVelocity<T> |
| Cformatter< drake::multibody::UnitInertia< T > > | Specializes the fmt::formatter<> class template for drake::multibody::UnitInertia<T> |
| Cformatter< drake::perception::pc_flags::DescriptorType > | Specializes the fmt::formatter<> class template for drake::perception::pc_flags::DescriptorType |
| Cformatter< drake::perception::pc_flags::Fields > | Specializes the fmt::formatter<> class template for drake::perception::pc_flags::Fields |
| Cformatter< drake::Polynomial< double >::Monomial > | Specializes the fmt::formatter<> class template for drake::Polynomial<double>::Monomial |
| Cformatter< drake::Polynomial< T > > | Specializes the fmt::formatter<> class template for drake::Polynomial<T> |
| Cformatter< drake::solvers::Binding< C > > | Specializes the fmt::formatter<> class template for drake::solvers::Binding<C> |
| Cformatter< drake::solvers::CommonSolverOption > | Specializes the fmt::formatter<> class template for drake::solvers::CommonSolverOption |
| Cformatter< drake::solvers::IntervalBinning > | Specializes the fmt::formatter<> class template for drake::solvers::IntervalBinning |
| Cformatter< drake::solvers::MathematicalProgram > | Specializes the fmt::formatter<> class template for drake::solvers::MathematicalProgram |
| Cformatter< drake::solvers::MixedIntegerRotationConstraintGenerator::Approach > | Specializes the fmt::formatter<> class template for drake::solvers::MixedIntegerRotationConstraintGenerator::Approach |
| Cformatter< drake::solvers::ProgramAttribute > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramAttribute |
| Cformatter< drake::solvers::ProgramAttributes > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramAttributes |
| Cformatter< drake::solvers::ProgramType > | Specializes the fmt::formatter<> class template for drake::solvers::ProgramType |
| Cformatter< drake::solvers::RemoveFreeVariableMethod > | Specializes the fmt::formatter<> class template for drake::solvers::RemoveFreeVariableMethod |
| Cformatter< drake::solvers::SolutionResult > | Specializes the fmt::formatter<> class template for drake::solvers::SolutionResult |
| Cformatter< drake::solvers::SolverId > | Specializes the fmt::formatter<> class template for drake::solvers::SolverId |
| Cformatter< drake::solvers::SolverOptions > | Specializes the fmt::formatter<> class template for drake::solvers::SolverOptions |
| Cformatter< drake::symbolic::ChebyshevBasisElement > | Specializes the fmt::formatter<> class template for drake::symbolic::ChebyshevBasisElement |
| Cformatter< drake::symbolic::ChebyshevPolynomial > | Specializes the fmt::formatter<> class template for drake::symbolic::ChebyshevPolynomial |
| Cformatter< drake::symbolic::Environment > | Specializes the fmt::formatter<> class template for drake::symbolic::Environment |
| Cformatter< drake::symbolic::Expression > | Specializes the fmt::formatter<> class template for drake::symbolic::Expression |
| Cformatter< drake::symbolic::Formula > | Specializes the fmt::formatter<> class template for drake::symbolic::Formula |
| Cformatter< drake::symbolic::GenericPolynomial< BasisElement > > | Specializes the fmt::formatter<> class template for drake::symbolic::GenericPolynomial<BasisElement> |
| Cformatter< drake::symbolic::MonomialBasisElement > | Specializes the fmt::formatter<> class template for drake::symbolic::MonomialBasisElement |
| Cformatter< drake::symbolic::Polynomial > | Specializes the fmt::formatter<> class template for drake::symbolic::Polynomial |
| Cformatter< drake::symbolic::RationalFunction > | Specializes the fmt::formatter<> class template for drake::symbolic::RationalFunction |
| Cformatter< drake::symbolic::Variable > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable |
| Cformatter< drake::symbolic::Variable::Id > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable::Id |
| Cformatter< drake::symbolic::Variable::Type > | Specializes the fmt::formatter<> class template for drake::symbolic::Variable::Type |
| Cformatter< drake::symbolic::Variables > | Specializes the fmt::formatter<> class template for drake::symbolic::Variables |
| Cformatter< drake::systems::BasicVector< T > > | Specializes the fmt::formatter<> class template for drake::systems::BasicVector<T> |
| Cformatter< drake::systems::Context< T > > | Specializes the fmt::formatter<> class template for drake::systems::Context<T> |
| Cformatter< drake::systems::sensors::ImageFileFormat > | Specializes the fmt::formatter<> class template for drake::systems::sensors::ImageFileFormat |
| Cformatter< drake::systems::sensors::PixelFormat > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelFormat |
| Cformatter< drake::systems::sensors::PixelScalar > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelScalar |
| Cformatter< drake::systems::sensors::PixelType > | Specializes the fmt::formatter<> class template for drake::systems::sensors::PixelType |
| Cformatter< drake::systems::VectorBase< T > > | Specializes the fmt::formatter<> class template for drake::systems::VectorBase<T> |
| Cformatter< drake::TypeSafeIndex< Tag > > | Specializes the fmt::formatter<> class template for drake::TypeSafeIndex<Tag> |
| Cformatter< drake::yaml::LoadYamlOptions > | Specializes the fmt::formatter<> class template for drake::yaml::LoadYamlOptions |
| CFormula | Represents a symbolic form of a first-order logic formula |
| CCameraConfig::FovDegrees | Specification of focal length via fields of view (in degrees) |
| 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 torque-free 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 |
| CMeshcat::Gamepad | Status of a gamepad obtained from the Meshcat javascript client |
| CGcsGraphvizOptions | |
| CGcsTrajectoryOptimization | GcsTrajectoryOptimization implements a simplified motion planning optimization problem introduced in the paper "Motion Planning around Obstacles with Convex Optimization" by Tobia Marcucci, Mark Petersen, David von Wrangel, Russ Tedrake |
| CVoxelSignedDistanceField::GenerationParameters | Param struct for generating a VoxelSignedDistanceField |
| CGenericPolynomial< BasisElement > | Represents symbolic generic polynomials using a given basis (for example, monomial basis, Chebyshev basis, etc) |
| 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 |
| CGeometryPairContactWrenchEvaluatorBinding | |
| CGeometryProperties | The base class for defining a set of geometry properties |
| CIllustrationProperties | The set of properties for geometry used in an "illustration" role |
| CPerceptionProperties | The set of properties for geometry used in a "perception" 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 context-dependent state of SceneGraph |
| CGeometryVersion | A version numbering class that reports revisions of SceneGraph's geometric data |
| CGetSubMatrixGradientArray< QSubvectorSize, Derived, NRows, NCols > | |
| CGetSubMatrixGradientSingleElement< QSubvectorSize, Derived > | |
| CGlobalInverseKinematics | Solves the inverse kinematics problem as a mixed integer convex optimization problem |
| CGltfExtension | Specifies how to deal with glTF "extensions" (non-standard capabilities) |
| CGradedReverseLexOrder< VariableOrder > | Implements Graded reverse lexicographic order |
| CGradient< Derived, nq, derivative_order > | Recursively defined template specifying a matrix type of the correct size for a gradient of a matrix function with respect to nq variables, of any order |
| CGradient< Derived, nq, 1 > | Base case for recursively defined gradient template |
| CGraphOfConvexSets | GraphOfConvexSets (GCS) implements the design pattern and optimization problems first introduced in the paper "Shortest Paths in Graphs of Convex Sets" |
| CGraphOfConvexSetsOptions | |
| CSystemBase::GraphvizFragment | (Advanced) The return type of GetGraphvizFragment() |
| CSystemBase::GraphvizFragmentParams | (Advanced) The arguments to the protected method DoGetGraphvizFragment() |
| CGrayCodesMatrix< NumDigits > | GrayCodesMatrix::type returns an Eigen matrix of integers |
| CGurobiSolverDetails | The Gurobi solver details after calling Solve() function |
| Chash< drake::geometry::GeometryId > | Enables use of the identifier to serve as a key in STL containers |
| Chash< drake::Sha256 > | The STL container hash for Sha256 objects |
| CHydroelasticContactInfo< T > | A class containing information regarding contact and contact response between two geometries attached to a pair of bodies |
| CHydroelasticContactInfo< symbolic::Expression > | Full specialization of HydroelasticContactInfo for T = Expression, with no member data |
| CIcfSolverParameters | (Advanced) Parameters to configure the Irrotational Contact Fields (ICF) convex solver |
| CVariable::Id | Identifier for a symbolic variable |
| CIdentifier< Tag > | A simple identifier class |
| CIdentifier< class GeometryTag > | |
| CGeometryId | Type used to identify geometry instances in SceneGraph |
| CRotation::Identity | No-op rotation |
| CIiwaControlPorts | The return type of BuildSimplifiedIiwaControl() |
| CIiwaDriver | This config struct specifies how to wire up Drake systems between an LCM interface and the actuation input ports of a MultibodyPlant |
| CConstraintRelaxingIk::IkCartesianWaypoint | Cartesian waypoint |
| CImage< kPixelType > | Simple data format for Image |
| CImageIo | Utility functions for reading and writing images, from/to either files or memory buffers |
| CImageTraits< PixelType > | Traits class for Image, specialized by PixelType |
| CImageTraits< PixelType::kBgr8U > | |
| CImageTraits< PixelType::kBgra8U > | |
| CImageTraits< PixelType::kDepth16U > | |
| CImageTraits< PixelType::kDepth32F > | |
| CImageTraits< PixelType::kGrey8U > | |
| CImageTraits< PixelType::kLabel16I > | |
| CImageTraits< PixelType::kRgb8U > | |
| CImageTraits< PixelType::kRgba8U > | |
| CImplicitGraphOfConvexSets | A base class to define the interface to an implicit graph of convex sets |
| CImplicitGraphOfConvexSetsFromExplicit | Provides an implicit GCS interface given an explicit GCS |
| CDifferentialInverseKinematicsSystem::Ingredient | (Internal use only) A user-provided set of constraint(s) and/or cost(s) for a DifferentialInverseKinematicsSystem recipe, to allow for user customization of the mathematical program formulation |
| CDifferentialInverseKinematicsSystem::CartesianPositionLimitConstraint | Constrains the goal frames to a cartesian bounding box: ∀i p_TG_next_lower ≤ p_TGi + Jv_TGi[3:6] * v_next * Δt ≤ p_TG_next_upper where: |
| CDifferentialInverseKinematicsSystem::CartesianVelocityLimitConstraint | Constrains the spatial velocities of the goal frames: ∀i, ∀j ∈ [0, 5]: abs(Jv_TGi * v_next)[j] ≤ V_next_TG_limit[j] |
| CDifferentialInverseKinematicsSystem::CollisionConstraint | Constrains the collision clearance around the robot to remain above the safety distance: ∀j ϕₛ ≤ ϕⱼ + ∂ϕⱼ/∂q_active * v_next * Δt where: |
| CDifferentialInverseKinematicsSystem::JointCenteringCost | Provides a secondary minimization objective |
| CDifferentialInverseKinematicsSystem::JointVelocityLimitConstraint | Constrains the generalized velocity to prevent a commanded velocity that would push the generalized position outside its limits |
| CDifferentialInverseKinematicsSystem::LeastSquaresCost | Provides a primary DifferentialInverseKinematicsSystem objective to minimize G*| S * (Vd_TGs - Jv_TGs * v_next)|², also known as the "least squares" formulation |
| CInitializeParams | Parameters for fine control of simulator initialization |
| 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₀; 𝐤) = 𝐱₀ |
| CInMemoryMesh | Representation of a mesh file stored in memory |
| CSelectorParams::InputPortParams | Helper struct for inputs |
| CMultibodyPlant< T >::InputPortIndices::Instance | |
| CMultibodyPlant< T >::OutputPortIndices::Instance | |
| Cintegral_constant | |
| Ctuple_size< drake::SortedPair< T > > | Support using SortedPair<T> in structured bindings |
| 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 |
| CCenicIntegrator< T > | Convex Error-controlled Numerical Integration for Contact (CENIC) is a specialized error-controlled implicit integrator for contact-rich robotics simulations [Kurtz and Castro, 2025] |
| CBogackiShampine3Integrator< T > | A third-order, four-stage, first-same-as-last (FSAL) Runge-Kutta integrator with a second order error estimate |
| CExplicitEulerIntegrator< T > | A first-order, explicit Euler integrator |
| CImplicitIntegrator< T > | An abstract class providing methods shared by implicit integrators |
| CRadauIntegrator< T, 2 > | |
| CRadauIntegrator< T, 1 > | |
| CImplicitEulerIntegrator< T > | A first-order, fully implicit integrator with second order error estimation |
| CRadauIntegrator< T, num_stages > | A selectable order (third- or first-order), fully implicit integrator with error estimation |
| CVelocityImplicitEulerIntegrator< T > | A first-order, fully implicit integrator optimized for second-order systems, with a second-order error estimate |
| CRungeKutta2Integrator< T > | A second-order, explicit Runge Kutta integrator |
| CRungeKutta3Integrator< T > | A third-order Runge Kutta integrator with a third order error estimate |
| CRungeKutta5Integrator< T > | A fifth-order, seven-stage, first-same-as-last (FSAL) Runge Kutta integrator with a fifth order error estimate |
| CSemiExplicitEulerIntegrator< T > | A first-order, semi-explicit Euler integrator |
| CInverseKinematics | Solves an inverse kinematics (IK) problem on a MultibodyPlant, to find the postures of the robot satisfying certain constraints |
| CIpoptSolverDetails | The Ipopt solver details after calling Solve() function |
| CIrisFromCliqueCoverOptions | |
| CIrisNp2Options | IrisNp2Options collects all parameters for the IRIS-NP2 algorithm |
| CIrisOptions | Configuration options for the IRIS algorithm |
| CIrisParameterizationFunction | Ordinarily, IRIS algorithms grow collision free regions in the robot's configuration space C |
| CIrisZoOptions | IrisZoOptions collects all parameters for the IRIS-ZO algorithm |
| Cis_base_of | |
| Cis_eigen_type< Derived > | |
| CImplicitIntegrator< T >::IterationMatrix | A class for storing the factorization of an iteration matrix and using it to solve linear systems of equations |
| CBusValue::Iterator | Provides a forward_iterator over BusValue signals |
| CJointImpedanceController | Drake does not yet offer a joint impedance controller, which would use feedback to shape the stiffness, damping, and inertia of the closed-loop system |
| CJointLimits | Wrapper type for position, velocity, and acceleration limits |
| CKinematicsVector< Id, KinematicsValue > | A KinematicsVector is a container class used to report kinematics data for registered frames and geometries (keyed by unique FrameId/GeometryId values) to SceneGraph where the set of keys (FrameId/GeometryId) is usually constant and the values (kinematics data) are varying |
| CKinematicTrajectoryOptimization | Optimizes a trajectory, q(t) subject to costs and constraints on the trajectory and its derivatives |
| CLcmBuses | A mapping from {bus_name: interface} with sugar for error checking with nice error messages during access |
| 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 > | |
| CLcmPixelTraits< PixelFormat > | |
| CLcmPixelTraits< PixelFormat::kBgr > | |
| CLcmPixelTraits< PixelFormat::kBgra > | |
| CLcmPixelTraits< PixelFormat::kDepth > | |
| CLcmPixelTraits< PixelFormat::kGrey > | |
| CLcmPixelTraits< PixelFormat::kLabel > | |
| CLcmPixelTraits< PixelFormat::kRgb > | |
| CLcmPixelTraits< PixelFormat::kRgba > | |
| Cless< drake::solvers::SolverId > | |
| Cless< drake::symbolic::Expression > | |
| Cless< drake::symbolic::Formula > | |
| Cless< drake::symbolic::Variable > | |
| CLightParameter | Light parameter for supporting RenderEngine implementations |
| CLinearQuadraticRegulatorResult | |
| CLinearSolver< LinearSolverType, DerivedA > | Solves a linear system of equations A*x=b |
| CLoadYamlOptions | Configuration for LoadYamlFile() and LoadYamlString() to govern when certain conditions are errors or not |
| CLogarithmicSos2NewBinaryVariables< NumLambda > | The size of the new binary variables in the compile time, for Special Ordered Set of type 2 (SOS2) constraint |
| Clogger | The singleton class returned by Drake's drake::log() function, offering functions to emit log messages |
| CMap | |
| CDerivativesMutableXpr | The return type for AutoDiff::derivatives() when the AutoDiff is mutable |
| CMassDamperSpringAnalyticalSolution< T > | This class provides an analytical solution to a mass-damper-spring system |
| CMatGradMult< DerivedDA, DerivedB > | |
| CMatGradMultMat< DerivedA, DerivedB, DerivedDA > | |
| CMathematicalProgram | MathematicalProgram stores the decision variables, the constraints and costs of an optimization problem |
| CMathematicalProgramResult | The result returned by MathematicalProgram::Solve() |
| CMaxCliqueSolverBase | The problem of finding the maximum clique in a graph is known to be NP-complete |
| CMaxCliqueSolverViaGreedy | Approximately solves the maximum clique problem via a greedy heuristic |
| CMaxCliqueSolverViaMip | Solves the maximum clique problem to global optimality by solving the mixed-integer program |
| CMemoryFile | A virtual file, stored in memory |
| CMeshcat | Provides an interface to Meshcat (https://github.com/meshcat-dev/meshcat) |
| CMeshcatAnimation | An interface for recording/playback animations in Meshcat |
| CMeshcatParams | The set of parameters for configuring Meshcat |
| CMeshcatVisualizerParams | The set of parameters for configuring MeshcatVisualizer |
| CMeshFieldLinear< T, MeshType > | MeshFieldLinear represents a continuous piecewise-linear scalar field f defined on a (triangular or tetrahedral) mesh; the field value changes linearly within each element E (triangle or tetrahedron), and the gradient ∇f is constant within each element |
| CMeshSource | Provides a general abstraction to the definition of a mesh |
| CImageIo::Metadata | Some characteristics of an image file |
| CMinCliqueCoverSolverBase | |
| CMinCliqueCoverSolverViaGreedy | Approximately solves the min clique cover problem via a greedy heuristic |
| CMixedIntegerBranchAndBound | Given a mixed-integer optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branch-and-bound process |
| CMixedIntegerBranchAndBoundNode | A node in the branch-and-bound (bnb) tree |
| CMixedIntegerRotationConstraintGenerator | We relax the non-convex SO(3) constraint on rotation matrix R to mixed-integer linear constraints |
| CModelDirective | Union structure for model directives |
| CModelDirectives | Top-level structure for a model directives yaml file schema |
| CModelInstanceInfo | Convenience structure to hold all of the information to add a model instance from a file |
| CPolynomial< T >::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 non-negative integer exponents |
| CMosekSolverDetails | The MOSEK™ solver details after calling Solve() function |
| CMoveIkDemoBase | This class provides some common functionality for generating IK plans for robot arms, including things like creating a MultibodyPlant, setting joint velocity limits, implementing a robot status update handler suitable for invoking from an LCM callback, and generating plans to move a specified link to a goal configuration |
| CMovingAverageFilter< T > | The implementation of a Moving Average Filter |
| CMultibodyElement< T > | A class representing an element (subcomponent) of a MultibodyPlant or (internally) a MultibodyTree |
| CDeformableBody< T > | The DeformableBody class represents a single deformable element within a MultibodyPlant |
| CForceElement< T > | A ForceElement allows modeling state and time dependent forces in a MultibodyTree model |
| CDoorHinge< T > | This ForceElement models a revolute DoorHinge joint that could exhibit different force/torque characteristics at different states due to the existence of different type of torques on the joint |
| CLinearBushingRollPitchYaw< T > | This ForceElement models a massless flexible bushing that connects a frame A of a link (body) L0 to a frame C of a link (body) L1 |
| CLinearSpringDamper< T > | This ForceElement models a spring-damper attached between two points on two different bodies (links) |
| CPrismaticSpring< T > | This ForceElement models a linear spring attached to a PrismaticJoint and applies a force to that joint according to |
| CRevoluteSpring< T > | This ForceElement models a torsional spring attached to a RevoluteJoint and applies a torque to that joint |
| CUniformGravityFieldElement< T > | This ForceElement allows modeling the effect of a uniform gravity field as felt by bodies on the surface of the Earth |
| CFrame< T > | Frame is an abstract class representing a material frame (also called a physical frame) of its underlying RigidBody (Link) |
| CFixedOffsetFrame< T > | FixedOffsetFrame represents a material frame F whose pose is fixed with respect to a parent material frame P |
| CRigidBodyFrame< T > | A RigidBodyFrame is a material Frame that serves as the unique reference frame for a RigidBody |
| CJoint< T > | A Joint models the kinematical relationship which characterizes the possible relative motion between two bodies |
| CBallRpyJoint< T > | This Joint allows two bodies to rotate freely relative to one another |
| CCurvilinearJoint< T > | A Joint that allows a body to move along a piecewise constant curvature path contained in a plane |
| CPlanarJoint< T > | This joint models a planar joint allowing two bodies to translate and rotate relative to one another in a plane with three degrees of freedom |
| CPrismaticJoint< T > | This Joint allows two bodies to translate relative to one another along a common axis |
| CQuaternionFloatingJoint< T > | This Joint allows two bodies to move freely relatively to one another |
| CRevoluteJoint< T > | This Joint allows two bodies to rotate relatively to one another around a common axis |
| CRpyFloatingJoint< T > | This Joint allows a rigid body to move freely with respect to its parent rigid body |
| CScrewJoint< T > | This joint models a screw joint allowing two bodies to rotate about one axis while translating along that same axis with one degree of freedom |
| CUniversalJoint< T > | This joint models a universal joint allowing two bodies to rotate relative to one another with two degrees of freedom |
| 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 |
| 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 |
| CMultibodyElement< double > | |
| CFrame< double > | |
| CRigidBodyFrame< double > | |
| CRigidBody< double > | |
| CMultibodyForces< T > | A class to hold a set of forces applied to a MultibodyTree system |
| CMultibodyPlantConfig | The set of configurable properties on a MultibodyPlant |
| 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 one-step of numerical integration provides the dynamic constraints between those decision variables |
| CNameValue< T > | (Advanced) A basic implementation of the Name-Value Pair concept as used in the Serialize / Archive pattern |
| 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::Matrix< double, Rows, Cols >::SizeAtCompileTime > | |
| 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 |
| CNiceTypeName | Obtains canonicalized, platform-independent, human-readable names for arbitrarily-complicated C++ types |
| CNloptSolverDetails | The NLopt solver details after calling Solve() function |
| CNonSymbolicTraits | A concrete traits class providing sugar to disable support for symbolic evaluation (i.e., the symbolic::Expression scalar type) |
| CTraits< LinearTransformDensity > | |
| CTraits< RandomSource > | |
| CTraits< TrajectoryAffineSystem > | |
| CTraits< TrajectoryLinearSystem > | |
| CTraits< drake::multibody::meshcat::ContactVisualizer > | |
| CTraits< examples::rimless_wheel::RimlessWheel > | |
| CTraits< geometry::DrakeVisualizer > | |
| CTraits< geometry::MeshcatPointCloudVisualizer > | |
| CTraits< geometry::MeshcatVisualizer > | |
| CTraits< sensors::BeamModel > | |
| Cnormal_distribution< drake::symbolic::Expression > | Provides std::normal_distribution, N(μ, σ), for symbolic expressions |
| CNullTexture | (Internal use only) A place holder indicating that no texture has been provided for environment map (and, therefore, no environment map) |
| Cnumeric_limits | |
| Cnumeric_limits< drake::symbolic::Expression > | |
| CNumericalGradientOption | |
| CObb | |
| CObbMaker< MeshType > | ObbMaker performs an algorithm to create an oriented bounding box that fits a specified set of vertices in a mesh |
| CObbMakerTester< MeshType > | |
| CCspaceFreePolytopeBase::Options | Optional argument for constructing CspaceFreePolytopeBase |
| CGlobalInverseKinematics::Options | |
| CMixedIntegerBranchAndBound::Options | Configuration settings for the MixedIntegerBranchAndBound constructor |
| CMeshcat::OrthographicCamera | Properties for an orthographic camera in three.js: https://threejs.org/docs/#api/en/cameras/OrthographicCamera |
| COsqpSolverDetails | The OSQP solver details after calling Solve() function |
| CSelectorParams::OutputPortParams | Helper struct for outputs |
| CSelectorParams::OutputSelection | Helper struct for output_selections |
| CPackageMap | Maps ROS package names to their full path on the local file system |
| CParallelism | Specifies a desired degree of parallelism for a parallelized operation |
| CParameters< T > | Parameters is a container for variables that parameterize a System so that it can represent a family of related models |
| CParser | Parses model description input into a MultibodyPlant and (optionally) a SceneGraph |
| CPdControllerGains | PD controller gains |
| CPendulumInputIndices | Describes the row indices of a PendulumInput |
| CPendulumParameters | This class is used to store the numerical parameters defining the model of a simple pendulum with the method MakePendulumPlant() |
| CPendulumParamsIndices | Describes the row indices of a PendulumParams |
| CPendulumStateIndices | Describes the row indices of a PendulumState |
| CPenetrationAsPointPair< T > | A characterization of the intersection of two penetrating geometries |
| CDynamicProgrammingOptions::PeriodicBoundaryCondition | For 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) |
| CPeriodicEventData | An event data variant describing an event that recurs on a fixed period |
| CPeriodicEventDataComparator | |
| CMeshcat::PerspectiveCamera | Properties for a perspective camera in three.js: https://threejs.org/docs/#api/en/cameras/PerspectiveCamera |
| CPlaceholder | This is a stub class to exercise the build system |
| CPlane< T > | The definition of a plane in ℜ³, posed in an arbitrary frame |
| CPlaneSeparatesGeometries | Contains the information to enforce a pair of geometries are separated by a plane |
| 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 |
| CPointPairContactInfo< T > | A class containing information regarding contact response between two bodies including: |
| CPointSignedDistanceAndGradientResult | Wrapper for multiple distance and gradient values |
| CPolygonSurfaceMesh< T > | PolygonSurfaceMesh represents a surface comprised of polygonal elements (three or more sides) |
| CPolygonSurfaceMeshTest< T > | |
| CPolynomial< T > | A scalar multi-variate polynomial, modeled after the msspoly in spotless |
| CPolynomial | Represents symbolic polynomials |
| CPolynomialBasisElement | Each polynomial p(x) can be written as a linear combination of its basis elements p(x) = ∑ᵢ cᵢ * ϕᵢ(x), where ϕᵢ(x) is the i'th element in the basis, cᵢ is the coefficient of that element |
| CChebyshevBasisElement | ChebyshevBasisElement represents an element of Chebyshev polynomial basis, written as the product of Chebyshev polynomials, in the form Tₚ₀(x₀)Tₚ₁(x₁)...Tₚₙ(xₙ), where each Tₚᵢ(xᵢ) is a (univariate) Chebyshev polynomial of degree pᵢ |
| CMonomialBasisElement | MonomialBasisElement represents a monomial, a product of powers of variables with non-negative integer exponents |
| CGlobalInverseKinematics::Polytope3D | Describes a polytope in 3D as 𝐀 * 𝐱 ≤ 𝐛 (a set of half-spaces), where 𝐀 ∈ ℝⁿˣ³, 𝐱 ∈ ℝ³, 𝐛 ∈ ℝⁿ |
| CPortBase | A PortBase is base class for System ports; users will typically use the InputPort<T> or OutputPort<T> types, not this base class |
| CInputPortBase | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
| CInputPort< double > | |
| CInputPort< drake::ad::AutoDiff > | |
| CInputPort< T > | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
| COutputPortBase | OutputPortBase handles the scalar type-independent aspects of an OutputPort |
| COutputPort< double > | |
| COutputPort< T > | An OutputPort belongs to a System and represents the properties of one of that System's output ports |
| CDiagramOutputPort< T > | (Advanced.) Holds information about a subsystem output port that has been exported to become one of this Diagram's output ports |
| CLeafOutputPort< T > | (Advanced.) Implements an output port whose value is managed by a cache entry in the same LeafSystem as the port |
| CRationalForwardKinematics::Pose< T > | This is a proxy for math::RigidTransform |
| CPolynomial< T >::Product< Rhs, Lhs > | |
| Cpromoted_numerical< T, U > | Given the two scalar types U and T, returns the most "promoted" type |
| CPropellerInfo | Parameters that describe the kinematic frame and force-production properties of a single propeller |
| CMeshcatParams::PropertyTuple | A helper struct for the initial_properties params |
| CQueryObject< T > | The QueryObject serves as a mechanism to perform geometry queries on the world's geometry |
| CRandomGenerator | Defines Drake's canonical implementation of the UniformRandomBitGenerator C++ concept (as well as a few conventional extras beyond the concept, e.g., seeds) |
| CRandomSimulationResult | A snapshot of the generator used to produce the random simulation |
| CRationalForwardKinematics | For certain robots (whose joint transforms are algebraic functions of joint variables, for example revolute/prismatic/floating-base joints), we can represent the pose (position, orientation) of each body, as rational functions, namely n(s) / d(s) where both the numerator n(s) and denominator d(s) are polynomials of s, and s is some variable related to the generalized position |
| CRationalFunction | Represents symbolic rational function |
| CRaySamplerOptions | RaySamplerOptions contains settings specific to the kRaySampler strategy for drawing the initial samples |
| CDifferentialInverseKinematicsSystem::Recipe | A recipe collects a list of ingredients for DifferentialInverseKinematicsSystem, allowing the user to customize the program being solved |
| CRegionOfAttractionOptions | Consolidates the many possible options to be passed to the region of attraction algorithm |
| CPackageMap::RemoteParams | Parameters used for AddRemote() |
| CRenderCameraCore | Collection of core parameters for modeling a pinhole-model camera in a RenderEngine |
| CRenderEngine | The engine for performing rasterization operations on geometry |
| CRenderEngineGlParams | Construction parameters for RenderEngineGl |
| CRenderEngineGltfClientParams | Construction parameters for the MakeRenderEngineGltfClient() to create a client as part of the glTF Render Client-Server API |
| CRenderEngineVtkParams | Construction parameters for the RenderEngineVtk |
| CRenderLabel | Class representing object "labels" for rendering |
| 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_on_copy< T > | Type wrapper that performs value-initialization on copy construction or assignment |
| CMixedIntegerRotationConstraintGenerator::ReturnType | |
| CRewritingRule | A RewritingRule, lhs => rhs, consists of two Patterns lhs and rhs |
| CRgba | Defines RGBA (red, green, blue, alpha) values on the range [0, 1] |
| CRigidTransform< T > | This class represents a proper rigid transform between two frames which can be regarded in two ways |
| CRimlessWheelContinuousStateIndices | Describes the row indices of a RimlessWheelContinuousState |
| CRimlessWheelParamsIndices | Describes the row indices of a RimlessWheelParams |
| CRlocationOrError | (Advanced.) The return type of FindRunfile() |
| CRobotClearance | A summary of the clearance – a collection of distance measurements – between the robot and everything in the world |
| CRobotDiagramBuilder< T > | Storage for a combined diagram builder, plant, and scene graph |
| 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] |
| CRotation | A specification for an SO(3) rotation, to be used for serialization purposes, e.g., to define stochastic scenarios |
| CRotationalInertia< T > | This class describes 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 |
| CRotation::Rpy | A roll-pitch-yaw rotation, using the angle conventions of Drake's RollPitchYaw |
| CSampledVolume | The result of a volume calculation from CalcVolumeViaSampling() |
| Cscalar_predicate< T > | A traits struct that describes the return type of predicates over a scalar type (named T) |
| CScalarConvertibleComponent< T > | |
| CPhysicalModel< T > | (Internal) PhysicalModel provides the functionalities to extend the type of physical model of MultibodyPlant |
| CDeformableModel< T > | DeformableModel implements the interface in PhysicalModel and provides the functionalities to specify deformable bodies |
| CScalarInitialValueProblem< T > | A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e |
| CSceneGraphConfig | The set of configurable properties on a SceneGraph |
| CSceneGraphInspector< T > | The SceneGraphInspector serves as a mechanism to query the topological structure of a SceneGraph instance |
| CSchunkWsgDriver | This config struct specifies how to wire up Drake systems between an LCM interface and the actuation input ports of a MultibodyPlant |
| CSchunkWsgTrajectoryGeneratorStateVectorIndices | Describes the row indices of a SchunkWsgTrajectoryGeneratorStateVector |
| CScopedName | A delimited string name for a multibody element, e.g., "robot1::torso" |
| CScopeExit | Helper class to create a scope exit guard – an object that when destroyed runs func |
| CScsSolverDetails | The SCS solver details after calling Solve() function |
| CCspaceFreePolytope::SearchResult | Result on searching the C-space polytope and separating planes |
| CSelectorParams | The constructor arguments for a Selector |
| CSemidefiniteRelaxationOptions | Configuration options for the MakeSemidefiniteRelaxation |
| CCspaceFreeBox::SeparatingPlaneLagrangians | When searching for the separating plane, we want to certify that the numerator of a rational is non-negative in the C-space box q_box_lower <= q <= q_box_upper (or equivalently s_box_lower <= s <= s_box_upper) |
| CCspaceFreePolytope::SeparatingPlaneLagrangians | When searching for the separating plane, we want to certify that the numerator of a rational is non-negative in the C-space region C*s<=d, s_lower <= s <= s_upper |
| CCspaceFreeBox::SeparationCertificate | This struct stores the necessary information to search for the separating plane for the polytopic C-space box q_box_lower <= q <= q_box_upper |
| CCspaceFreePolytope::SeparationCertificate | This struct stores the necessary information to search for the separating plane for the polytopic C-space region C*s <= d, s_lower <= s <= s_upper |
| CSeparationCertificateProgramBase | |
| CCspaceFreeBox::SeparationCertificateProgram | |
| CCspaceFreePolytope::SeparationCertificateProgram | |
| CSeparationCertificateResultBase | We certify that a pair of geometries is collision free by finding the separating plane over a range of configuration |
| CCspaceFreeBox::SeparationCertificateResult | We certify that a pair of geometries is collision free in the C-space box {q | q_box_lower<=q<=q_box_upper} by finding the separating plane and the Lagrangian multipliers |
| CCspaceFreePolytope::SeparationCertificateResult | We certify that a pair of geometries is collision free in the C-space region {s | Cs<=d, s_lower<=s<=s_upper} by finding the separating plane and the Lagrangian multipliers |
| CSerializerInterface | SerializerInterface translates between LCM message bytes and drake::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::Value<LcmMessage> objects |
| CSha256 | Represents a SHA-256 cryptographic checksum |
| CShape | The abstract base class for all shape specifications |
| CBox | Definition of a box |
| CCapsule | Definition of a capsule |
| CConvex | Definition of a convex surface mesh |
| CCylinder | Definition of a cylinder |
| CEllipsoid | Definition of an ellipsoid |
| CHalfSpace | Definition of a half space |
| CMesh | Definition of a general (possibly non-convex) mesh |
| CMeshcatCone | Definition of a cone |
| CSphere | Definition of sphere |
| CShapeReifier | The interface for converting shape descriptions to real shapes |
| CConvexHull | Implements the convex hull of a set of convex sets |
| 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 |
| CSignedDistanceWithTimeDerivative | The struct containing the signed distance and its time derivative between a pair of geometries |
| CSimulator< T > | A class for advancing the state of hybrid dynamic systems, represented by System<T> objects, forward in time |
| CSimulatorConfig | The set of all configurable properties on a Simulator and IntegratorBase |
| CSimulatorStatus | Holds the status return value from a call to Simulator::AdvanceTo() and related methods |
| CSinCos | Represents a pair of Variables corresponding to sin(q) and cos(q) |
| CSnoptSolverDetails | The SNOPT solver details after calling Solve() function |
| CSolverId | Identifies a SolverInterface implementation |
| CSolverInterface | Interface used by implementations of individual solvers |
| CSolverBase | Abstract base class used by implementations of individual solvers |
| CClarabelSolver | An interface to wrap Clarabel https://github.com/oxfordcontrol/Clarabel.cpp |
| CClpSolver | A wrapper to call CLP using Drake's MathematicalProgram |
| CCsdpSolver | Wrap CSDP solver such that it can solve a drake::solvers::MathematicalProgram |
| CEqualityConstrainedQPSolver | Solves a quadratic program with equality constraint |
| CGurobiSolver | An implementation of SolverInterface for the commercially-licensed Gurobi solver (https://www.gurobi.com/) |
| CIpoptSolver | A wrapper to call Ipopt using Drake's MathematicalProgram |
| CLinearSystemSolver | Finds the least-square solution to the linear system A * x = b |
| CMobyLcpSolver | A class for solving Linear Complementarity Problems (LCPs) |
| CMosekSolver | An implementation of SolverInterface for the commercially-licensed MOSEK (TM) solver (https://www.mosek.com/) |
| CNloptSolver | |
| COsqpSolver | A wrapper to call OSQP using Drake's MathematicalProgram |
| CProjectedGradientDescentSolver | Solves a nonlinear program via the projected gradient descent algorithm |
| CScsSolver | |
| CSnoptSolver | An implementation of SolverInterface for the commercially-licensed SNOPT solver (https://ccom.ucsd.edu/~optimizers/solvers/snopt/) |
| CUnrevisedLemkeSolver< T > | A class for the Unrevised Implementation of Lemke Algorithm's for solving Linear Complementarity Problems (LCPs) |
| CSolverInterface | Interface used by implementations of individual solvers |
| CSolverBase | Abstract base class used by implementations of individual solvers |
| CSolverOptions | Stores options for multiple solvers |
| 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 |
| CSpatialVector< SV, T > | This class represents a spatial vector and has 6 elements, with a 3-element rotational vector on top of a 3-element translational vector |
| CSpatialVector< SpatialAcceleration, T > | |
| CSpatialAcceleration< T > | This class represents a spatial acceleration A and has 6 elements with an angular (rotational) acceleration α (3-element vector) on top of a translational (linear) acceleration 𝐚 (3-element vector) |
| CSpatialVector< SpatialForce, double > | |
| CSpatialForce< double > | |
| CSpatialVector< SpatialForce, T > | |
| CSpatialForce< T > | This class represents a spatial force F (also called a wrench) and has 6 elements with a torque 𝛕 (3-element vector) on top of a force 𝐟 (3-element vector) |
| CSpatialVector< SpatialMomentum, T > | |
| CSpatialMomentum< T > | This class represents a spatial momentum L and has 6 elements with an angular (rotational) momentum 𝐡 (3-element vector) on top of a translational (linear) momentum 𝐥 (3-element vector) |
| CSpatialVector< SpatialVelocity, double > | |
| CSpatialVelocity< double > | |
| CSpatialVector< SpatialVelocity, T > | |
| CSpatialVelocity< T > | This class represents a spatial velocity V (also called a twist) and has 6 elements with an angular (rotational) velocity ω (3-element vector) on top of a translational (linear) velocity v (3-element vector) |
| CSphereSpecification | Class modelling collision spheres used for collision checking |
| CSpongControllerParamsIndices | Describes the row indices of a SpongControllerParams |
| CSsaoParameter | Screen-space ambient occlusion (SSAO) parameters |
| 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 |
| CStateFeedbackControllerInterface< T > | Interface for state feedback controllers |
| CInverseDynamicsController< T > | A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into MultibodyPlant actuation inputs using InverseDynamics (with mode = InverseDynamics::kInverseDynamics) |
| CPidController< T > | Implements the PID controller |
| CStateFeedbackControllerInterface< double > | |
| CSchunkWsgPlainController | This class implements a controller for a Schunk WSG gripper as a systems::Diagram |
| CStaticEquilibriumProblem | Finds the static equilibrium pose of a multibody system through optimization |
| CGcsTrajectoryOptimization::Subgraph | A Subgraph is a subset of the larger graph |
| CSubscriber< Message > | Subscribes to and stores a copy of the most recent message on a given channel, for some Message type |
| CPolynomial::SubstituteAndExpandCacheData | An encapsulated data type for use with the method SubstituteAndExpand |
| CSurfacePolygon | Representation of a polygonal face in a SurfacePolygon |
| CSurfaceTriangle | SurfaceTriangle represents a triangular face in a TriangleSurfaceMesh |
| CSymbolicVectorSystemBuilder | Builder design pattern to help with all of the optional arguments in the constructor of SymbolicVectorSystem |
| CSystemConstraint< T > | A SystemConstraint is a generic base-class for constraints on Systems |
| CSystemConstraintAdapter | This class is a factory class to generate SystemConstraintWrapper |
| CSystemConstraintBounds | The bounds of a SystemConstraint |
| CSystemMessageInterface | |
| CSystemBase | Provides non-templatized functionality shared by the templatized System classes |
| CSystem< double > | |
| CDiagram< double > | |
| CRobotDiagram< double > | |
| CStateInterpolatorWithDiscreteDerivative< double > | |
| 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 discrete-derivative to estimate the desired velocity from the desired position commands |
| CDifferentialInverseKinematicsController | Differential Inverse Kinematics controller that tracks desired poses / velocities for multiple operational points |
| CRgbdSensorDiscrete | Wraps a continuous RgbdSensor with a zero-order hold to create a discrete sensor |
| CLeafSystem< double > | |
| CDrakeVisualizer< double > | |
| CMeshcatPointCloudVisualizer< double > | |
| CMeshcatVisualizer< double > | |
| CSceneGraph< double > | |
| CMultibodyTreeSystem< double > | |
| CMultibodyPlant< double > | |
| CContactVisualizer< double > | |
| CDiscreteDerivative< double > | |
| CDiscreteTimeIntegrator< double > | |
| CAcrobotGeometry | Expresses an AcrobotPlant's geometry to a SceneGraph |
| CCompassGaitGeometry | Expresses a CompassGait's geometry to a SceneGraph |
| CPendulumGeometry | Expresses a PendulumPlants's geometry to a SceneGraph |
| CQuadrotorGeometry | Expresses a QuadrotorPlant's geometry to a SceneGraph |
| CRimlessWheelGeometry | Expresses a RimlessWheel's geometry to a SceneGraph |
| CPandaCommandReceiver | Handles lcmt_panda_command message from a LcmSubscriberSystem |
| CPandaCommandSender | Creates and outputs lcmt_panda_command messages |
| CPandaStatusReceiver | Handles lcmt_panda_status messages from a LcmSubscriberSystem |
| CPandaStatusSender | Creates and outputs lcmt_panda_status messages |
| CJacoCommandReceiver | Handles lcmt_jaco_command message 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 lcmt_iiwa_command message from a LcmSubscriberSystem |
| CIiwaCommandSender | Creates and outputs lcmt_iiwa_command messages |
| CIiwaStatusReceiver | Handles lcmt_iiwa_status messages from a LcmSubscriberSystem |
| CIiwaStatusSender | Creates and outputs lcmt_iiwa_status messages |
| 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 |
| CRobotPlanInterpolator | This class implements a source of joint positions for a robot |
| CDifferentialInverseKinematicsIntegrator | A LeafSystem that integrates successive calls to DoDifferentialInverseKinematics (which produces joint velocity commands) to produce joint position commands |
| CDifferentialInverseKinematicsSystem | The DifferentialInverseKinematicsSystem takes as input desired cartesian poses (or cartesian velocities) for an arbitrary number of "goal" frames on the robot, and produces a generalized velocity command as output to move the goal frames toward the desired state |
| CDepthImageToPointCloud | Converts a depth image to a point cloud |
| CPointCloudToLcm | Converts PointCloud inputs to lcmt_point_cloud output messages |
| CLcmInterfaceSystem | LcmInterfaceSystem acts within a Diagram to allow LcmSubscriberSystem instances to receive data from the network during a simulation |
| 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 |
| CLcmScopeSystem | LcmScopeSystem provides the ability to convert any vector output port to a simple LCM message and publish that message periodically |
| CLcmSubscriberSystem | Receives LCM messages from a given channel and outputs them to a System<double>'s port |
| 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<lcmt_image_array> LCM message that defines an array of images (lcmt_image) |
| CRgbdSensor | A meta-sensor that houses RGB, depth, and label cameras, producing their corresponding images based on the contents of the geometry::SceneGraph |
| CRgbdSensorAsync | A sensor similar to RgbdSensorDiscrete but the rendering occurs on a background thread to offer improved performance |
| CSystem< drake::ad::AutoDiff > | |
| CLeafSystem< drake::ad::AutoDiff > | |
| CSceneGraph< drake::ad::AutoDiff > | |
| CMultibodyTreeSystem< drake::ad::AutoDiff > | |
| CMultibodyPlant< drake::ad::AutoDiff > | |
| CSystem< drake::symbolic::Expression > | |
| 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 |
| CSimIiwaDriver< T > | SimIiwaDriver simulates the IIWA control and status interface using a MultibodyPlant |
| CRobotDiagram< T > | Storage for a combined diagram, plant, and scene graph |
| CStateInterpolatorWithDiscreteDerivative< T > | Supports the common pattern of combining a (feed-through) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked |
| CInverseDynamicsController< T > | A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into MultibodyPlant actuation inputs using InverseDynamics (with mode = InverseDynamics::kInverseDynamics) |
| CPidControlledSystem< T > | A system that encapsulates a PidController and a controlled System (a.k.a the "plant") |
| CLeafSystem< T > | A superclass template that extends System with some convenience utilities that are not applicable to Diagrams |
| CAcrobotPlant< T > | The Acrobot - a canonical underactuated system as described in Chapter 3 of Underactuated Robotics |
| CAcrobotSpongController< T > | The Spong acrobot swing-up controller as described in: Spong, Mark W |
| 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 |
| CPendulumPlant< T > | A model of a simple pendulum |
| 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: |
| CVanDerPolOscillator< T > | Van der Pol oscillator |
| CDrakeVisualizer< T > | A system that publishes LCM messages representing the current state of a SceneGraph instance (whose QueryObject-valued output port is connected to this system's input port) |
| CMeshcatPointCloudVisualizer< T > | MeshcatPointCloudVisualizer is a systems::LeafSystem that publishes a perception::PointCloud from its input port to Meshcat |
| CMeshcatVisualizer< T > | A system wrapper for Meshcat that publishes the current state of a SceneGraph instance (whose QueryObject-valued output port is connected to this system's input port) |
| CSceneGraph< T > | SceneGraph serves as the nexus for all geometry (and geometry-based operations) in a Diagram |
| CContactResultsToLcmSystem< T > | A System that encodes ContactResults into a lcmt_contact_results_for_viz message |
| CExternallyAppliedSpatialForceMultiplexer< T > | Concatenates multiple std::vector<>'s of ExternallyAppliedSpatialForce<T> |
| CPropeller< T > | A System that connects to the MultibodyPlant in order to model the effects of one or more controlled propellers acting on a Body |
| CWing< T > | A System that connects to the MultibodyPlant in order to model the simplified dynamics of an airfoil (or hydrofoil) |
| CMultibodyTreeSystem< T > | |
| 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 |
| CContactVisualizer< T > | ContactVisualizer is a system that publishes a ContactResults to geometry::Meshcat; For point contact results, it draws double-sided arrows at the location of the contact force with length scaled by the magnitude of the contact force |
| CJointSliders< T > | JointSliders adds slider bars to the Meshcat control panel for the joints of a MultibodyPlant |
| CAdder< T > | An adder for arbitrarily many inputs of equal size |
| CBusCreator< T > | This system packs values from heterogeneous input ports into a single output port of type BusValue |
| CBusSelector< T > | This system unpacks values from a single input port of type BusValue onto heterogeneous output ports, where each output port's value comes from the same- named signal on the bus |
| CConstantValueSource< T > | A source block that always outputs a constant value |
| CDemultiplexer< T > | This system splits a vector valued signal on its input into multiple outputs |
| CDiscreteDerivative< T > | System that outputs the discrete-time derivative of its input: y(t) = (u[n] - u[n-1])/h, where n = floor(t/h), where h is the time period |
| CDiscreteTimeDelay< T > | A discrete time delay block with input u, which is vector-valued (discrete or continuous) or abstract, and output delayed_u which is previously received input, delayed by the given amount |
| CDiscreteTimeIntegrator< T > | A discrete-time integrator for a vector input, using explicit Euler integration |
| CLinearTransformDensity< T > | Performs linear transformation on the random signal w_in as w_out = A*w_in + b |
| CMultilayerPerceptron< T > | The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today |
| CMultiplexer< T > | This system combines multiple vector-valued inputs into a vector-valued output |
| CPassThrough< T > | A pass through system with input u and output y = u |
| CPortSwitch< T > | A simple system that passes through the value from just one of its input ports to the output |
| CRandomSource< T > | A source block which generates random numbers at a fixed sampling interval, with a zero-order hold between samples |
| CSaturation< T > | An element-wise hard saturation block with inputs signal u, saturation values \( u_{min} \) and/or \( u_{max} \), and output y respectively as in: |
| CSelector< T > | This system combines multiple vector-valued inputs into multiple vector- valued outputs |
| CSharedPointerSystem< T > | SharedPointerSystem holds a single shared_ptr that will be released at System deletion time (i.e., the end of a Diagram lifespan) |
| 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 > | Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time |
| CSparseMatrixGain< T > | A variant of MatrixGain which supports multiplication by SparseMatrix, D |
| CSymbolicVectorSystem< T > | A LeafSystem that is defined by vectors of symbolic::Expression representing the dynamics and output |
| CTimeVaryingAffineSystem< T > | Base class for a discrete- or continuous-time, time-varying affine system, with potentially time-varying coefficients |
| CAffineSystem< T > | A discrete OR continuous affine system (with constant coefficients) |
| CLinearSystem< T > | A discrete OR continuous linear system |
| CMatrixGain< T > | A system that specializes LinearSystem by setting coefficient matrices A, B, and C to all be zero |
| CTimeVaryingLinearSystem< T > | Base class for a discrete or continuous linear time-varying (LTV) system |
| CTrajectoryLinearSystem< T > | A continuous- or discrete-time Linear Time-Varying system with system matrices described by trajectories |
| CTrajectoryAffineSystem< T > | A continuous- or discrete-time Affine Time-Varying system with system matrices described by trajectories |
| CVectorLogSink< T > | A discrete sink block which logs its vector-valued input to per-context memory |
| 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 > | Extract the gripper measured force from the generalized forces on the two fingers |
| CBarycentricMeshSystem< T > | A (stateless) vector system implemented as a multi-linear (barycentric) interpolation on a mesh over the inputs |
| CFirstOrderLowPassFilter< T > | An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ |
| CGain< T > | An element-wise gain block with input u and output y = k * u with k a constant vector |
| CIntegrator< T > | A continuous-time integrator for a vector input |
| CRotaryEncoders< T > | Simple model to capture the quantization and calibration offset effects of a rotary encoder |
| CWrapToSystem< T > | An element-wise wrapping block that transforms the specified indices of the input signal u into the interval [low, high) |
| CZeroOrderHold< T > | A zero order hold block with input u, which may be vector-valued (discrete or continuous) or abstract, and discrete output y, where the y is sampled from u with a fixed period (and optional offset) |
| CInverseDynamics< T > | Solves inverse dynamics with no consideration for joint actuator force limits |
| CJointStiffnessController< T > | Implements a joint-space stiffness controller of the form |
| CPidController< T > | Implements the PID controller |
| CLuenbergerObserver< T > | A simple state observer for a continuous-time dynamical system of the form: |
| CMultibodyPositionToGeometryPose< T > | A direct-feedthrough system that converts a vector of joint positions directly to a geometry::FramePoseVector<T> to behave like a MultibodyPlant::get_geometry_pose_output_port() |
| CAccelerometer< T > | Sensor to represent an ideal accelerometer sensor |
| CBeamModel< T > | Implements the "Beam Models of Range Finders" from section 6.3 of Probabilistic Robotics (2006), by Thrun, Burgard, and Fox |
| CGyroscope< T > | Sensor to represent an ideal gyroscopic sensor |
| CColorizeDepthImage< T > | ColorizeDepthImage converts a depth image, either 32F or 16U, to a color image |
| CColorizeLabelImage< T > | ColorizeLabelImage converts a label image to a color image |
| CConcatenateImages< T > | ConcatenateImages stacks multiple input images into a single output image |
| CInertiaVisualizer< T > | InertiaVisualizer provides illustration geometry to reflect the equivalent inertia of all bodies in a MultibodyPlant that are not welded to the world |
| CMeshcatPoseSliders< T > | MeshcatPoseSliders adds slider bars to the MeshCat control panel for the roll, pitch, yaw, x, y, z control of a pose |
| CSystemOutput< T > | Conveniently stores a snapshot of the values of every output port of a System |
| 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 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 input-to-output sparsity, along with many others |
| CSystemTypeTag< S > | A tag object that denotes a System subclass S in function signatures |
| CSystemVisitor< T > | Provides a "Visitor Pattern" for System and Diagram |
| CTamsiSolver< T > | TamsiSolver uses the Transition-Aware Modified Semi-Implicit (TAMSI) method, [Castro et al., 2019], to solve the equations below for mechanical systems in contact with regularized friction: |
| CTamsiSolverIterationStats | Struct used to store information about the iteration process performed by TamsiSolver |
| CTamsiSolverParameters | These are the parameters controlling the iteration process of the TamsiSolver solver |
| CPolynomial< T >::Term | An individual variable raised to an integer power; e.g. x**2 |
| CTimer | Abstract base class for timing utility |
| CManualTimer | Implementation of timing for use with unit tests that control time manually |
| CSteadyTimer | Implementation of timing utility that uses monotonic std::chrono::steady_clock |
| CTimeStep | |
| CToppra | Solves a Time Optimal Path Parameterization based on Reachability Analysis (TOPPRA) to find the fastest traversal of a given path, satisfying the given constraints |
| CTraits< S > | A templated traits class for whether an S<U> can be converted into an S<T>; the default value is true for all values of S, T, and U |
| CTraits< TrajectorySource > | Spells out the supported scalar conversions for TrajectorySource |
| CTrajectory< T > | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
| CBezierCurve< T > | A Bézier curve is defined by a set of control points p₀ through pₙ, where n is called the order of the curve (n = 1 for linear, 2 for quadratic, 3 for cubic, etc.) |
| CBsplineTrajectory< T > | Represents a B-spline curve using a given basis with ordered control_points such that each control point is a matrix in ℝʳᵒʷˢ ˣ ᶜᵒˡˢ |
| CDerivativeTrajectory< T > | Trajectory objects provide derivatives by implementing DoEvalDerivative and DoMakeDerivative |
| CDiscreteTimeTrajectory< T > | A DiscreteTimeTrajectory is a Trajectory whose value is only defined at discrete time points |
| CFunctionHandleTrajectory< T > | FunctionHandleTrajectory takes a function, value = f(t), and provides a Trajectory interface |
| CPathParameterizedTrajectory< T > | A trajectory defined by a path and timing trajectory |
| 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" |
| CCompositeTrajectory< T > | A "composite trajectory" is a series of trajectories joined end to end where the end time of one trajectory coincides with the starting time of the next |
| CExponentialPlusPiecewisePolynomial< T > | Represents a piecewise-trajectory with piece \(j\) given by: |
| CPiecewiseConstantCurvatureTrajectory< T > | A piecewise constant curvature trajectory in a plane, where the plane is posed arbitrarily in three dimensions |
| CPiecewisePolynomial< T > | A scalar multi-variate piecewise polynomial |
| CPiecewisePose< T > | A wrapper class that represents a pose trajectory, whose rotation part is a PiecewiseQuaternionSlerp and the translation part is a PiecewisePolynomial |
| CPiecewiseQuaternionSlerp< T > | A class representing a trajectory for quaternions that are interpolated using piecewise slerp (spherical linear interpolation) |
| CStackedTrajectory< T > | A StackedTrajectory stacks the values from one or more underlying Trajectory objects into a single Trajectory, without changing the start_time() or end_time() |
| CTrajectory< T > | A Trajectory represents a time-varying matrix, indexed by a single scalar time |
| CBezierCurve< T > | A Bézier curve is defined by a set of control points p₀ through pₙ, where n is called the order of the curve (n = 1 for linear, 2 for quadratic, 3 for cubic, etc.) |
| CBsplineTrajectory< T > | Represents a B-spline curve using a given basis with ordered control_points such that each control point is a matrix in ℝʳᵒʷˢ ˣ ᶜᵒˡˢ |
| CDerivativeTrajectory< T > | Trajectory objects provide derivatives by implementing DoEvalDerivative and DoMakeDerivative |
| CDiscreteTimeTrajectory< T > | A DiscreteTimeTrajectory is a Trajectory whose value is only defined at discrete time points |
| CFunctionHandleTrajectory< T > | FunctionHandleTrajectory takes a function, value = f(t), and provides a Trajectory interface |
| CPathParameterizedTrajectory< T > | A trajectory defined by a path and timing trajectory |
| 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" |
| CStackedTrajectory< T > | A StackedTrajectory stacks the values from one or more underlying Trajectory objects into a single Trajectory, without changing the start_time() or end_time() |
| CTrajectory< double > | |
| CBezierCurve< double > | |
| CBsplineTrajectory< double > | |
| CPiecewiseTrajectory< double > | |
| CExponentialPlusPiecewisePolynomial< double > | |
| CPiecewiseConstantCurvatureTrajectory< double > | |
| CPiecewisePolynomial< double > | |
| CTrajectory< drake::ad::AutoDiff > | |
| CPiecewiseTrajectory< drake::ad::AutoDiff > | |
| CPiecewisePolynomial< drake::ad::AutoDiff > | |
| CTransferFunction | Represents a linear-time-invariant (LTI) system in transfer function form, e.g |
| CTransform | A specification for a 3d rotation and translation, optionally with respect to a base frame |
| CTriangleQuadrature< NumericReturnType, T > | A class for integrating a function using numerical quadrature over triangular domains |
| CTriangleQuadratureRule | A "rule" (weights and quadrature points) for computing quadrature over triangular domains |
| CGaussianTriangleQuadratureRule | |
| CTriangleSurfaceMesh< T > | TriangleSurfaceMesh represents a union of triangles |
| CTriangleSurfaceMeshTester< T > | |
| Ctuple_element< Index, drake::SortedPair< T > > | |
| CTypeSafeIndex< Tag > | A type-safe non-negative index class |
| Cuhash< HashAlgorithm > | A hashing functor, somewhat like std::hash |
| Cuhash< DefaultHasher > | |
| Chash< drake::Identifier< Tag > > | Enables use of the identifier to serve as a key in STL containers |
| Chash< drake::SortedPair< T > > | Provides std::hash<SortedPair<T>> |
| Chash< drake::TypeSafeIndex< Tag > > | Enables use of the type-safe index to serve as a key in STL containers |
| Chash< drake::geometry::render::RenderLabel > | Enables use of the label to serve as a key in STL containers |
| Chash< drake::solvers::Binding< C > > | |
| Chash< drake::solvers::SolverId > | |
| Chash< drake::symbolic::ChebyshevBasisElement > | |
| Chash< drake::symbolic::ChebyshevPolynomial > | |
| Chash< drake::symbolic::Expression > | |
| Chash< drake::symbolic::Formula > | |
| Chash< drake::symbolic::GenericPolynomial< BasisElement > > | |
| Chash< drake::symbolic::Monomial > | |
| Chash< drake::symbolic::MonomialBasisElement > | |
| Chash< drake::symbolic::Polynomial > | |
| Chash< drake::symbolic::Variable > | |
| Chash< drake::symbolic::Variable::Id > | |
| Chash< drake::symbolic::Variables > | |
| Chash< drake::systems::sensors::PixelType > | |
| CRotation::Uniform | Rotation sampled from a uniform distribution over SO(3) |
| Cuniform_real_distribution< drake::symbolic::Expression > | Provides std::uniform_real_distribution, U(a, b), for symbolic expressions |
| Cunique_ptr< T > | STL class |
| Ccopyable_unique_ptr< Engine > | |
| Ccopyable_unique_ptr< drake::geometry::Shape > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< T > > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< double > > | |
| Ccopyable_unique_ptr< drake::solvers::MathematicalProgram > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< double > > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< drake::ad::AutoDiff > > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< drake::ad::AutoDiff > > | |
| Ccopyable_unique_ptr< internal::CollisionFilterGroupsImpl< std::string > > | |
| Ccopyable_unique_ptr< drake::multibody::fem::FemModel< T > > | |
| Ccopyable_unique_ptr< drake::multibody::ForceDensityFieldBase< T > > | |
| Ccopyable_unique_ptr< drake::systems::Context< T > > | |
| Ccopyable_unique_ptr< drake::AbstractValue > | |
| Ccopyable_unique_ptr< Impl > | |
| Ccopyable_unique_ptr< drake::systems::CacheEntryValue > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< T > > | |
| Ccopyable_unique_ptr< drake::systems::FixedInputPortValue > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< drake::symbolic::Expression > > | |
| Ccopyable_unique_ptr< drake::trajectories::Trajectory< double > > | |
| Ccopyable_unique_ptr< drake::trajectories::Trajectory< T > > | |
| Ccopyable_unique_ptr< T > | A smart pointer with deep copy semantics |
| CUnrevisedLemkeSolverId | Non-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 |
| CValueConverter< T, U > | Converts a scalar U u to its corresponding scalar T t |
| CValueConverter< T, T > | |
| CValueProducer | ValueProducer computes an AbstractValue output based on a ContextBase input |
| CVariable | Represents a symbolic variable |
| CVariables | Represents 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 |
| CBasicVector< T > | BasicVector is a semantics-free wrapper around an Eigen vector that satisfies VectorBase |
| CAcrobotInput< T > | Specializes BasicVector with specific getters and setters |
| CAcrobotParams< T > | Specializes BasicVector with specific getters and setters |
| CAcrobotState< T > | Specializes BasicVector with specific getters and setters |
| CSpongControllerParams< T > | Specializes BasicVector with specific getters and setters |
| CCompassGaitContinuousState< T > | Specializes BasicVector with specific getters and setters |
| CCompassGaitParams< T > | Specializes BasicVector with specific getters and setters |
| CPendulumInput< T > | Specializes BasicVector with specific getters and setters |
| CPendulumParams< T > | Specializes BasicVector with specific getters and setters |
| CPendulumState< T > | Specializes BasicVector with specific getters and setters |
| CRimlessWheelContinuousState< T > | Specializes BasicVector with specific getters and setters |
| CRimlessWheelParams< T > | Specializes BasicVector with specific getters and setters |
| CSchunkWsgTrajectoryGeneratorStateVector< T > | Specializes BasicVector with specific getters and setters |
| CBeamModelParams< T > | Specializes BasicVector with specific getters and setters |
| 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< double > | |
| CBasicVector< double > | |
| CVectorBase< drake::ad::AutoDiff > | |
| CBasicVector< drake::ad::AutoDiff > | |
| CVectorBase< drake::symbolic::Expression > | |
| CBasicVector< drake::symbolic::Expression > | |
| CVectorLog< T > | This utility class serves as an in-memory cache of time-dependent vector values |
| CGraphOfConvexSets::Vertex | Each vertex in the graph has a corresponding ConvexSet, and a std::string name |
| CVisualizationConfig | Settings for what MultibodyPlant and SceneGraph should send to Meshcat and/or Meldis |
| CVolumeElement | VolumeElement represents a tetrahedral element in a VolumeMesh |
| CVolumeMesh< T > | VolumeMesh represents a tetrahedral volume mesh |
| CVolumeMeshTester< T > | |
| CVoxelOccupancyMap | |
| CVoxelSignedDistanceField | Container for voxelized signed distance fields |
| CVoxelTaggedObjectOccupancyMap | |
| CWarn | When constructed, logs a message (at "warn" severity); the destructor is guaranteed to be trivial |
| 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) |
| CWitnessTriggeredEventData< T > | An event data variant for storing data from a witness function triggering to be passed to event handlers |
| CZeroForceDriver | A driver that applies zero actuation to every joint of a model |
| CZmpPlanner | Given 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) |
| Cconst ContextConstraintCalc< double > | |
| Cconst ContextConstraintCalc< drake::ad::AutoDiff > | |
| Cconst ContextConstraintCalc< drake::symbolic::Expression > | |
| Cconst MeshType * | |
| Cconst SystemConstraintCalc< double > | |
| Cconst SystemConstraintCalc< drake::ad::AutoDiff > | |
| CKinematicsData< double > | |
| CKinematicsData< drake::ad::AutoDiff > | |
| CMatrix3< double > | |
| Coptional< drake::ad::AutoDiff > | |
| Coptional< drake::symbolic::Expression > | |
| Csize_t | |
| Cstatic constexpr size_t | |
| Cstring_map< drake::TypeSafeIndex< class InputPortTag > > | |
| Cvariant< drake::geometry::InMemoryMesh, std::filesystem::path > | |
| CVector3< T > | |
| CVector6< double > | |
| CVector6< T > | |
| CVectorX< double > | |
| CVectorX< drake::ad::AutoDiff > | |
| CVectorX< drake::symbolic::Variable > | |
