| ►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 |
| CAcrobotParameters | This class is used to store the numerical parameters defining the model of an acrobot with the method MakeAcrobotPlant() |
| 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 |
| CAllegroHandMotionState | Detecting the state of the fingers: whether the joints are moving, or reached the destination, or got stuck by external collisions in the midway |
| 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 |
| 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< drake::solvers::BoundingBoxConstraint > | |
| CBinding< drake::solvers::Constraint > | |
| CBinding< drake::solvers::Cost > | |
| CBinding< drake::solvers::ExponentialConeConstraint > | |
| CBinding< drake::solvers::L2NormCost > | |
| CBinding< drake::solvers::LinearComplementarityConstraint > | |
| CBinding< drake::solvers::LinearConstraint > | |
| CBinding< drake::solvers::LinearCost > | |
| CBinding< drake::solvers::LinearEqualityConstraint > | |
| CBinding< drake::solvers::LinearMatrixInequalityConstraint > | |
| CBinding< drake::solvers::LorentzConeConstraint > | |
| CBinding< drake::solvers::PositiveSemidefiniteConstraint > | |
| CBinding< drake::solvers::QuadraticConstraint > | |
| CBinding< drake::solvers::QuadraticCost > | |
| CBinding< drake::solvers::RotatedLorentzConeConstraint > | |
| CBinding< drake::solvers::VisualizationCallback > | |
| CBinding< internal::StaticFrictionConeComplementarityNonlinearConstraint > | |
| CJoint< T >::BluePrint | (Advanced) Structure containing all the information needed to build the MultibodyTree implementation for a Joint |
| 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 |
| ►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 |
| CBsplineBasis< double > | |
| CBsplineBasis< drake::symbolic::Expression > | |
| CFemModel< T >::Builder | Builder that builds the FemModel |
| 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 | |
| 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 |
| CCollisionCheckerConstructionParams | |
| 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 |
| CCollisionCheckerTestConfigurationData | |
| CCollisionCheckerTestParams | |
| 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 |
| CColorPalette< IdType > | Creates and holds a palette of colors for visualizing different objects in a scene (the intent is for a different color to be applied to each identified object) |
| CColorRenderCamera | Collection of camera properties for cameras to be used with color/label images |
| ►CCompositeEventCollection< T > | This class bundles an instance of each EventCollection<EventType> into one object that stores the heterogeneous collection |
| CDiagramCompositeEventCollection< T > | CompositeEventCollection for a Diagram |
| CLeafCompositeEventCollection< T > | A CompositeEventCollection for a LeafSystem |
| ►CCompositeEventCollection< AutoDiffXd > | |
| CLeafCompositeEventCollection< AutoDiffXd > | |
| ►CCompositeEventCollection< double > | |
| CLeafCompositeEventCollection< double > | |
| ►CCompositeEventCollection< Element::T > | |
| CLeafCompositeEventCollection< Element::T > | |
| CConditionTraits< symbolic::Formula > | |
| CPidControlledSystem< T >::ConnectResult | The return type of ConnectController |
| CConstraintAccelProblemData< T > | Structure for holding constraint data for computing forces due to constraints and the resulting multibody accelerations |
| CConstraintRelaxingIk | A wrapper class around the IK planner |
| CConstraintSolver< T > | Solves constraint problems for constraint forces |
| CConstraintVelProblemData< T > | Structure for holding constraint data for computing constraint forces at the velocity-level (i.e., impact problems) |
| 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< AutoDiffXd > | |
| CContext< double > | |
| CContext< drake::symbolic::Expression > | |
| ►CContext< T > | Context is an abstract class template that represents all the typed values that are used in a System's computations: time, 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 |
| CContinuousState< AutoDiffXd > | |
| CContinuousState< double > | |
| CContinuousState< drake::symbolic::Expression > | |
| ►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ₙ} |
| 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₂ ∩ .. |
| CMinkowskiSum | A convex set that represents the Minkowski sum of multiple sets: S = 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 |
| CCSpaceSeparatingPlane< drake::symbolic::Variable > | |
| 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 | (FUTURE) 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 |
| 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 |
| CDescriptorType | Describes an descriptor field with a name and the descriptor's size |
| CDiagramBuilder< T > | DiagramBuilder is a factory class for Diagram |
| CDiagramBuilder< double > | |
| CDifferentialInverseKinematicsParameters | Contains parameters for differential inverse kinematics |
| 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 |
| CDiscreteValues< AutoDiffXd > | |
| CDiscreteValues< double > | |
| CDiscreteValues< drake::symbolic::Expression > | |
| CDiscreteValues< Element::T > | |
| ►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 |
| ►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 |
| CDoorHingeConfig | Configuration structure for the DoorHinge |
| CDrakeKukaIIwaRobot< T > | This class is a MultibodyTree model for a 7-DOF Kuka iiwa robot arm |
| ►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 |
| CEigenPtr< const MatrixX< T > > | |
| CEigenPtr< const VectorX< T > > | |
| CEncodedData | |
| 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 |
| CBrickStaticEquilibriumNonlinearConstraint | Given the set of contacts between the fingertips and the brick, impose the static equilibrium as a nonlinear constraint, that the total force/torque applied on the brick is 0 |
| 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
\[ F_0 + x_1 F_1 + ... + x_n F_n \text{ is p.s.d} \]
where p.s.d stands for positive semidefinite |
| CLorentzConeConstraint | Constraining the linear expression \( z=Ax+b \) lies within the Lorentz cone |
| 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
\[\text{ S is p.s.d }\]
namely, all eigen values of S are non-negative |
| 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 |
| ►CEvaluatorConstraint< PolynomialEvaluator > | |
| CPolynomialConstraint | A constraint on the values of multivariate polynomials |
| ►CCost | Provides an abstract base for all costs |
| 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‖₂ |
| CLinearCost | Implements a cost of the form
\[ a'x + b \]
|
| CLInfNormCost | Implements a cost of the form ‖Ax + b‖∞ |
| CPerspectiveQuadraticCost | If \( z = Ax + b,\) implements a cost of the form:
\[ (z_1^2 + z_2^2 + ... + z_{n-1}^2) / z_0. \]
Note that this cost is convex when we additionally constrain z_0 > 0 |
| CQuadraticCost | Implements a cost of the form
\[ .5 x'Qx + b'x + c \]
|
| ►CEvaluatorCost< PolynomialEvaluator > | |
| CPolynomialCost | Implements a cost of the form P(x, y...) where P is a multivariate polynomial in x, y, .. |
| CFunctionEvaluator< F > | An evaluator that may be specified using a callable object |
| CPolynomialEvaluator | Implements an evaluator of the form P(x, y...) where P is a multivariate polynomial in x, y, .. |
| CVisualizationCallback | Defines a simple evaluator with no outputs that takes a callback function pointer |
| ►CEvent< T > | Abstract base class that represents an event |
| CDiscreteUpdateEvent< T > | This class represents a discrete update event |
| CPublishEvent< T > | This class represents a publish event |
| CUnrestrictedUpdateEvent< T > | This class represents an unrestricted update event |
| CEvent< double > | |
| ►CEventCollection< EventType > | There are three concrete event types for any System: publish, discrete state update, and unrestricted state update, listed in order of increasing ability to change the state (i.e., zero to all) |
| CDiagramEventCollection< EventType > | A concrete class that holds all simultaneous homogeneous events for a Diagram |
| CLeafEventCollection< EventType > | A concrete class that holds all simultaneous homogeneous events for a LeafSystem |
| CEventCollection< drake::systems::DiscreteUpdateEvent< AutoDiffXd > > | |
| CEventCollection< drake::systems::DiscreteUpdateEvent< double > > | |
| CEventCollection< drake::systems::DiscreteUpdateEvent< drake::symbolic::Expression > > | |
| CEventCollection< drake::systems::DiscreteUpdateEvent< Element::T > > | |
| CEventCollection< drake::systems::DiscreteUpdateEvent< T > > | |
| CEventCollection< drake::systems::PublishEvent< AutoDiffXd > > | |
| CEventCollection< drake::systems::PublishEvent< double > > | |
| CEventCollection< drake::systems::PublishEvent< drake::symbolic::Expression > > | |
| CEventCollection< drake::systems::PublishEvent< Element::T > > | |
| CEventCollection< drake::systems::PublishEvent< T > > | |
| CEventCollection< drake::systems::UnrestrictedUpdateEvent< AutoDiffXd > > | |
| CEventCollection< drake::systems::UnrestrictedUpdateEvent< double > > | |
| CEventCollection< drake::systems::UnrestrictedUpdateEvent< drake::symbolic::Expression > > | |
| CEventCollection< drake::systems::UnrestrictedUpdateEvent< Element::T > > | |
| CEventCollection< drake::systems::UnrestrictedUpdateEvent< T > > | |
| 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 |
| CExpressionAddFactory | Factory class to help build ExpressionAdd expressions |
| ►CExpressionCell | Represents an abstract class which is the base of concrete symbolic-expression classes |
| ►CBinaryExpressionCell | Represents the base class for binary expressions |
| CExpressionAtan2 | Symbolic expression representing atan2 function (arctangent function with two arguments) |
| CExpressionDiv | Symbolic expression representing division |
| CExpressionMax | Symbolic expression representing max function |
| CExpressionMin | Symbolic expression representing min function |
| CExpressionPow | Symbolic expression representing power function |
| CExpressionAdd | Symbolic expression representing an addition which is a sum of products |
| CExpressionIfThenElse | Symbolic expression representing if-then-else expression |
| CExpressionMul | Symbolic expression representing a multiplication of powers |
| CExpressionNaN | Symbolic expression representing NaN (not-a-number) |
| CExpressionUninterpretedFunction | Symbolic expression representing an uninterpreted function |
| CExpressionVar | Symbolic expression representing a variable |
| ►CUnaryExpressionCell | Represents the base class for unary expressions |
| CExpressionAbs | Symbolic expression representing absolute value function |
| CExpressionAcos | Symbolic expression representing arccosine function |
| CExpressionAsin | Symbolic expression representing arcsine function |
| CExpressionAtan | Symbolic expression representing arctangent function |
| CExpressionCeiling | Symbolic expression representing ceil function |
| CExpressionCos | Symbolic expression representing cosine function |
| CExpressionCosh | Symbolic expression representing hyperbolic cosine function |
| CExpressionExp | Symbolic expression representing exponentiation using the base of natural logarithms |
| CExpressionFloor | Symbolic expression representing floor function |
| CExpressionLog | Symbolic expression representing logarithms |
| CExpressionSin | Symbolic expression representing sine function |
| CExpressionSinh | Symbolic expression representing hyperbolic sine function |
| CExpressionSqrt | Symbolic expression representing square-root |
| CExpressionTan | Symbolic expression representing tangent function |
| CExpressionTanh | Symbolic expression representing hyperbolic tangent function |
| CExpressionMulFactory | Factory class to help build ExpressionMul expressions |
| 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) |
| ►CForceDensityField< T > | The ForceDensityField class is an abstract base class that represents a force density field affecting deformable bodies in a MultibodyPlant |
| CGravityForceField< T > | A uniform gravitational force density field for a uniform density object |
| ►CForceDensityField< double > | |
| CPointSourceForceField | |
| ►Cformatter | |
| ►Costream_formatter | When using fmt >= 9, this is an alias for fmt::ostream_formatter |
| Cformatter< drake::AutoDiffXd > | |
| Cformatter< drake::geometry::GeometryProperties > | |
| Cformatter< drake::geometry::render::RenderLabel > | |
| Cformatter< drake::geometry::Role > | |
| Cformatter< drake::Identifier< Tag > > | |
| Cformatter< drake::math::RigidTransform< T > > | |
| Cformatter< drake::math::RollPitchYaw< T > > | |
| Cformatter< drake::multibody::CollisionFilterGroups > | |
| Cformatter< drake::multibody::DifferentialInverseKinematicsStatus > | |
| Cformatter< drake::multibody::PackageMap > | |
| Cformatter< drake::multibody::RotationalInertia< T > > | |
| Cformatter< drake::multibody::SpatialInertia< T > > | |
| Cformatter< drake::multibody::SpatialVector< SpatialQuantity, T > > | |
| Cformatter< drake::perception::pc_flags::Fields > | |
| Cformatter< drake::Polynomial< double >::Monomial > | |
| Cformatter< drake::Polynomial< T > > | |
| Cformatter< drake::solvers::Binding< C > > | |
| Cformatter< drake::solvers::CommonSolverOption > | |
| Cformatter< drake::solvers::MixedIntegerRotationConstraintGenerator::Approach > | |
| Cformatter< drake::solvers::ProgramAttribute > | |
| Cformatter< drake::solvers::ProgramAttributes > | |
| Cformatter< drake::solvers::ProgramType > | |
| Cformatter< drake::solvers::SolverId > | |
| Cformatter< drake::solvers::SolverOptions > | |
| Cformatter< drake::symbolic::ChebyshevBasisElement > | |
| Cformatter< drake::symbolic::ChebyshevPolynomial > | |
| Cformatter< drake::symbolic::GenericPolynomial< BasisElement > > | |
| Cformatter< drake::symbolic::MonomialBasisElement > | |
| Cformatter< drake::symbolic::Polynomial > | |
| Cformatter< drake::symbolic::RationalFunction > | |
| Cformatter< drake::symbolic::Variable > | |
| Cformatter< drake::symbolic::Variable::Type > | |
| Cformatter< drake::systems::VectorBase< T > > | |
| Cformatter< drake::TypeSafeIndex< Tag > > | |
| Cformatter< drake::yaml::LoadYamlOptions > | |
| Cformatter< T, std::enable_if_t< std::is_base_of_v< drake::solvers::EvaluatorBase, T >, char > > | |
| Cformatter< drake::geometry::GeometryId > | |
| CFormula | Represents a symbolic form of a first-order logic formula |
| ►CFormulaCell | Represents an abstract class which is the base of concrete symbolic-formula classes (i.e |
| CFormulaFalse | Symbolic formula representing false |
| CFormulaForall | Symbolic formula representing universal quantifications (∀ x₁, ..., * xn |
| CFormulaIsnan | Symbolic formula representing isnan predicate |
| CFormulaNot | Symbolic formula representing negations (¬f) |
| CFormulaPositiveSemidefinite | Symbolic formula representing positive-semidefinite (PSD) constraint |
| CFormulaTrue | Symbolic formula representing true |
| CFormulaVar | Symbolic formula representing a Boolean variable |
| ►CNaryFormulaCell | Represents the base class for N-ary logic operators (∧ and ∨) |
| CFormulaAnd | Symbolic formula representing conjunctions (f1 ∧ .. |
| CFormulaOr | Symbolic formula representing disjunctions (f1 ∨ .. |
| ►CRelationalFormulaCell | Represents the base class for relational operators (==, !=, <, <=, >, >=) |
| CFormulaEq | Symbolic formula representing equality (e1 = e2) |
| CFormulaGeq | Symbolic formula representing 'greater-than-or-equal-to' (e1 ≥ e2) |
| CFormulaGt | Symbolic formula representing 'greater-than' (e1 > e2) |
| CFormulaLeq | Symbolic formula representing 'less-than-or-equal-to' (e1 ≤ e2) |
| CFormulaLt | Symbolic formula representing 'less-than' (e1 < e2) |
| CFormulaNeq | Symbolic formula representing disequality (e1 ≠ e2) |
| 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 |
| 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 |
| 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 |
| CGeometrySetTester | |
| CGeometryState< T > | The context-dependent state of SceneGraph |
| CGeometryState< AutoDiffXd > | |
| CGeometryState< double > | |
| 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 |
| CGripperBrickHelper< T > | The helper class that contains the diagram of the planar gripper (3 planar fingers) with a brick |
| CGripperBrickHelper< double > | |
| 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 |
| CHydroelasticQuadraturePointData< T > | Results from intermediate calculations used during the quadrature routine |
| CIdentifier< Tag > | A simple identifier class |
| CIdentifier< class FrameTag > | |
| ►CIdentifier< class GeometryTag > | |
| CGeometryId | Type used to identify geometry instances in SceneGraph |
| CIdentifier< class RoleVersionTag > | |
| CIdentifier< class SourceTag > | |
| 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 > | |
| CImageTraits< systems::sensors::PixelType::kLabel16I > | |
| 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₀; 𝐤) = 𝐱₀ |
| ►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 |
| 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 |
| 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 fourth order error estimate |
| CSemiExplicitEulerIntegrator< T > | A first-order, semi-explicit Euler integrator |
| CIntegratorBase< AutoDiffXd > | |
| CIntegratorBase< double > | |
| 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 | |
| CIrisOptions | Configuration options for the IRIS 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 |
| 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 |
| CJoint< T >::JointImplementation | (Advanced) A Joint is implemented in terms of MultibodyTree elements, typically a Mobilizer |
| 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 |
| CKukaRobotJointReactionForces< T > | Utility struct to assist with returning joint torques/forces |
| 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 |
| CLimitMalloc | Instantiate this class in a unit test scope where malloc (and realloc, etc.) should be disallowed or curtailed |
| CLimitMallocParams | Parameters to control malloc limits |
| 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 |
| 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 |
| 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 |
| CImageIo::Metadata | Some characteristics of an image file |
| 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 |
| CConstraintSolver< T >::MlcpToLcpData | Structure used to convert a mixed linear complementarity problem to a pure linear complementarity problem (by solving for free variables) |
| CMobyLcpSolverId | Non-template class for MobyLcpSolver<T> constants |
| 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 |
| CMonomial | Represents a monomial, a product of powers of variables with non-negative integer exponents |
| CPolynomial< T >::Monomial | An additive atom of a Polynomial: The product of any number of Terms and a coefficient |
| 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 |
| ►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 |
| 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 |
| ►CFrameBase< T > | FrameBase is an abstract representation of the concept of a frame in multibody dynamics |
| ►CFrame< T > | Frame is an abstract class representing a material frame (also called a physical frame), meaning that the Frame's origin is a material point of a Body |
| 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 |
| ►CFrame< double > | |
| CRigidBodyFrame< double > | |
| ►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 |
| 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 > | |
| 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 |
| CMultibodyPlantTester | |
| ►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< drake::multibody::meshcat::ContactVisualizer > | |
| CTraits< examples::rimless_wheel::RimlessWheel > | |
| CTraits< geometry::DrakeVisualizer > | |
| CTraits< geometry::MeshcatPointCloudVisualizer > | |
| CTraits< geometry::MeshcatVisualizer > | |
| CTraits< LinearTransformDensity > | |
| CTraits< RandomSource > | |
| CTraits< sensors::BeamModel > | |
| CTraits< TrajectoryAffineSystem > | |
| CTraits< TrajectoryLinearSystem > | |
| 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 | |
| CObject | Provides a publicly visible, but minimal, re-implementation of py::object so that a public type can be used with drake::Value<T>, while still maintaining the revelant semantics with its generic implementation (#13207) |
| CCspaceFreePolytopeBase::Options | Optional argument for constructing CspaceFreePolytopeBase |
| CMixedIntegerBranchAndBound::Options | Configuration settings for the MixedIntegerBranchAndBound constructor |
| CGlobalInverseKinematics::Options | |
| 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 |
| Coverload_cast_impl< Return, Args > | |
| 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 |
| CParameters< AutoDiffXd > | |
| CParameters< double > | |
| CParameters< drake::symbolic::Expression > | |
| CParser | Parses model description input into a MultibodyPlant and (optionally) a SceneGraph |
| CPdControllerGains | PD controller gains |
| CPendulumParameters | This class is used to store the numerical parameters defining the model of a simple pendulum with the method MakePendulumPlant() |
| CPenetrationAsPointPair< T > | A characterization of the intersection of two penetrating geometries |
| CDynamicProgrammingOptions::PeriodicBoundaryCondition | For algorithms that rely on approximations of the 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 | Structure for comparing two PeriodicEventData objects for use in a map container, using an arbitrary comparison method |
| CMeshcat::PerspectiveCamera | Properties for a perspective camera in three.js: https://threejs.org/docs/#api/en/cameras/PerspectiveCamera |
| 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: |
| CPolygonSurfaceMesh< T > | PolygonSurfaceMesh represents a surface comprised of polygonal elements (three or more sides) |
| CPolygonSurfaceMesh< double > | |
| CPolygonSurfaceMeshTest< T > | |
| CPolynomial | Represents symbolic polynomials |
| CPolynomial< T > | A scalar multi-variate polynomial, modeled after the msspoly in spotless |
| ►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< T > | An InputPort is a System resource that describes the kind of input a System accepts, on a given port |
| CInputPort< AutoDiffXd > | |
| CInputPort< double > | |
| ►COutputPortBase | OutputPortBase handles the scalar type-independent aspects of an OutputPort |
| ►COutputPort< T > | An OutputPort belongs to a System and represents the properties of one of that System's output ports |
| CDiagramOutputPort< T > | (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 |
| COutputPort< double > | |
| 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 |
| 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_after_move< Id > | |
| Creset_after_move< int > | |
| Creset_after_move< int64_t > | |
| Creset_after_move< size_t > | |
| Creset_on_copy< T > | Type wrapper that performs value-initialization on copy construction or assignment |
| Creset_on_copy< const internal::ContextMessageInterface * > | |
| Creset_on_copy< const MeshType * > | |
| Creset_on_copy< drake::systems::ContextBase * > | |
| 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 |
| CRigidTransform< double > | |
| 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 |
| CRotationMatrix< double > | |
| 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 |
| ►CScalarConvertibleComponent< AutoDiffXd > | |
| CPhysicalModel< AutoDiffXd > | |
| ►CScalarConvertibleComponent< double > | |
| CPhysicalModel< double > | |
| CScalarInitialValueProblem< T > | A thin wrapper of the InitialValueProblem class to provide a simple interface when solving scalar initial value problems i.e |
| CSceneGraphConfig | (FUTURE) 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 |
| CSceneGraphInspector< AutoDiffXd > | |
| CSceneGraphInspector< double > | |
| CSchunkWsgDriver | This config struct specifies how to wire up Drake systems between an LCM interface and the actuation input ports of a MultibodyPlant |
| CScopedName | A delimited string name for a multibody element, e.g., "robot1::torso" |
| CDiagnosticPolicyTestBase::ScopedTrace | |
| 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 |
| 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 |
| 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} |
| CVPolytope | A polytope described using the vertex representation |
| CShapeName | |
| CShapeToString | |
| 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 |
| CSimulator< double > | |
| 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 | |
| CLinearSystemSolver | Finds the least-square solution to the linear system A * x = b |
| CMobyLCPSolver< T > | 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 | |
| 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) |
| 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 |
| CSortedPair< drake::geometry::GeometryId > | |
| CSortedPair< drake::TypeSafeIndex > | |
| CSortedPair< std::string > | |
| CSpatialInertia< T > | This class represents the physical concept of a Spatial Inertia |
| CSpatialInertia< double > | |
| CSpatialKinematicsPVA< T > | Utility class containing the transform and spatial velocity/acceleration of an arbitrary frame B in another arbitrary frame N (e.g., the world) |
| CSpatialVector< SV, T > | This class 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, 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) |
| ►CState< T > | State is a container for all the data comprising the complete state of a particular System at a particular moment |
| CDiagramState< T > | DiagramState is a State, annotated with pointers to all the mutable substates that it spans |
| CState< double > | |
| ►CStateFeedbackControllerInterface< T > | Interface for state feedback controllers |
| CKukaTorqueController< T > | Controller that take emulates the kuka_iiwa_arm when operated in torque control mode |
| CInverseDynamicsController< T > | A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics |
| CPidController< T > | Implements the PID controller |
| ►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 |
| CSystemConstraint< T > | A SystemConstraint is a generic base-class for constraints on Systems |
| CSystemConstraint< AutoDiffXd > | |
| CSystemConstraint< double > | |
| CSystemConstraint< drake::symbolic::Expression > | |
| CSystemConstraint< Element::T > | |
| 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< 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 |
| CKukaTorqueController< T > | Controller that take emulates the kuka_iiwa_arm when operated in torque control mode |
| CManipulationStation< T > | A system that represents the complete manipulation station, including exactly one robotic arm (a Kuka IIWA LWR), one gripper (a Schunk WSG 50), and anything a user might want to load into the model |
| CSimIiwaDriver< T > | SimIiwaDriver simulates the IIWA control and status interface using a MultibodyPlant |
| CRobotDiagram< T > | Storage for a combined diagram, plant, and scene graph |
| CInverseDynamicsController< T > | A state feedback controller that uses a PidController to generate desired accelerations, which are then converted into torques using InverseDynamics |
| CPidControlledSystem< T > | A system that encapsulates a PidController and a controlled System (a.k.a the "plant") |
| CPidControlledSpringMassSystem< T > | A model of a one-dimensional spring-mass system controlled to achieve a given target position using a PID controller |
| 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 |
| ►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 |
| CBeadOnAWire< T > | Dynamical system of a point (unit) mass constrained to lie on a wire |
| CBouncingBall< T > | Dynamical representation of the idealized hybrid dynamics of a ball dropping from a height and bouncing on a surface |
| 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 |
| CClothSpringModel< T > | A system that models a rectangular piece of cloth using as a model a structured grid of springs and dampers |
| CPendulumPlant< T > | A model of a simple pendulum
\[ ml^2 \ddot\theta + b\dot\theta + mgl\sin\theta = \tau \]
|
| CQuadrotorPlant< T > | The Quadrotor - an underactuated aerial vehicle |
| CRimlessWheel< T > | Dynamical representation of the idealized hybrid dynamics of a "rimless
wheel", as described in http://underactuated.mit.edu/underactuated.html?chapter=simple_legs In addition, this model has two additional (discrete) state variables that are not required in the mathematical model: |
| CRod2D< T > | Dynamical system representation of a rod contacting a half-space in two dimensions |
| CBouncingBallPlant< T > | A model of a bouncing ball with Hunt-Crossley compliant contact model |
| CSolarSystem< T > | A model of an orrery – a simple mechanical model of the solar system |
| 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> |
| ►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 |
| CAxiallySymmetricFreeBodyPlant< T > | This plant models the free motion of a torque free body in space |
| CMultibodyPlant< AutoDiffXd > | |
| 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 |
| 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) |
| CAdder< T > | An adder for arbitrarily many inputs of equal size |
| CRobertsonSystem< T > | Robertson's stiff chemical reaction problem |
| CStiffDoubleMassSpringSystem< T > | A coupled, mass spring system taken from the SD/FAST user's manual |
| CLogisticSystem< T > | System with state evolution yielding a logistic function, for purposes of witness function testing using the differential equation dx/dt = α⋅(1 - (x/k)^ν)⋅t, where ν > 0 (affects the shape of the curve), α > 0 (growth rate), and k is the upper asymptote |
| CStatelessSystem< T > | System with no state for testing a simplistic witness function |
| CStationarySystem< T > | System with no state evolution for testing numerical differencing in integrators that use it |
| CConstantValueSource< T > | A source block that always outputs a constant value |
| CInverseDynamics< T > | Solves inverse dynamics with no consideration for joint actuator force limits |
| CJointStiffnessController< T > | Implements a joint-space stiffness controller of the form |
| CLinearModelPredictiveController< T > | Implements a basic Model Predictive Controller that linearizes the system about an equilibrium condition and regulates to the same point by solving an optimal control problem over a finite time horizon |
| CPidController< T > | Implements the PID controller |
| 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 |
| CLuenbergerObserver< T > | A simple state observer for a dynamical system of the form:
\[\dot{x} = f(x,u) \]
\[y = g(x,u) \]
the observer dynamics takes the form
\[\dot{\hat{x}} = f(\hat{x},u) + L(y - g(\hat{x},u)) \]
where \(\hat{x}\) is the estimated state of the original system |
| 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 |
| 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() |
| 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: |
| 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 |
| 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 |
| ►CSpringMassSystem< T > | A model of a one-dimensional spring-mass system |
| CMySpringMassSystem< T > | |
| ►CSpringMassDamperSystem< T > | |
| CDiscontinuousSpringMassDamperSystem< T > | |
| 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) |
| 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 |
| ►CSystem< AutoDiffXd > | |
| ►CLeafSystem< AutoDiffXd > | |
| CSceneGraph< AutoDiffXd > | |
| ►CSystem< double > | |
| ►CDiagram< double > | |
| CLcmPlanInterpolator | A Diagram that adapts a RobotPlanInterpolator for use with an Iiwa arm |
| CManipulationStationHardwareInterface | A System that connects via message-passing to the hardware manipulation station |
| 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 |
| CRgbdSensorDiscrete | Wraps a continuous RgbdSensor with a zero-order hold to create a discrete sensor |
| CRobotDiagram< double > | |
| CStateInterpolatorWithDiscreteDerivative< double > | |
| ►CLeafSystem< double > | |
| CDiscreteDerivative< double > | |
| CAcrobotCommandReceiver | Receives the output of an LcmSubscriberSystem that subscribes to the acrobot input channel with LCM type lcmt_acrobot_u, and outputs the acrobot input as a BasicVector |
| CAcrobotCommandSender | Receives the output of an acrobot controller, and outputs it as an LCM message with type lcm_acrobot_u |
| CAcrobotGeometry | Expresses an AcrobotPlant's geometry to a SceneGraph |
| CAcrobotStateReceiver | Receives the output of an LcmSubsriberSystem that subsribes to the acrobot state channel with LCM type lcmt_acrobot_x, and outputs the acrobot states as an AcrobotState |
| CAcrobotStateSender | Receives the output of an acrobot_plant, and outputs it as an LCM message with type lcm_acrobot_x |
| CAllegroCommandReceiver | Handles lcmt_allegro_command messages from a LcmSubscriberSystem |
| CAllegroStatusSender | Creates and outputs lcmt_allegro_status messages |
| CCompassGaitGeometry | Expresses a CompassGait's geometry to a SceneGraph |
| CParallelGripperController | |
| CSuctionCupController | |
| CFibonacciDifferenceEquation | A pure discrete system that generates the Fibonacci sequence F_n using a difference equation |
| CClothSpringModelGeometry | Expresses a ClothSpringModel's visualization geometry to a SceneGraph |
| CPendulumGeometry | Expresses a PendulumPlants's geometry to a SceneGraph |
| CGripperCommandDecoder | Handles lcmt_planar_gripper_command messages from a LcmSubscriberSystem |
| CGripperCommandEncoder | Creates and outputs lcmt_planar_gripper_command messages |
| CGripperStatusDecoder | Handles lcmt_planar_gripper_status messages from a LcmSubscriberSystem |
| CGripperStatusEncoder | Creates and outputs lcmt_planar_gripper_status messages |
| CPlanarManipulandStatusDecoder | Handles lcmt_planar_manipuland_status messages from a LcmSubscriberSystem |
| CPlanarManipulandStatusEncoder | Creates and outputs lcmt_planar_manipuland_status messages |
| CQuadrotorGeometry | Expresses a QuadrotorPlant's geometry to a SceneGraph |
| CRimlessWheelGeometry | Expresses a RimlessWheel's geometry to a SceneGraph |
| CRod2dGeometry | |
| 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 |
| CDepthImageToPointCloud | Converts a depth image to a point cloud |
| CPointCloudToLcm | Converts PointCloud inputs to lcmt_point_cloud output messages |
| CPleidesSystem | A system of ODEs that can be used to test performance of the initial value problem (IVP) solvers |
| CCubicScalarSystem | System where the state at (scalar) time t corresponds to the cubic equation t³ + t² + 12t + 5 |
| CLinearScalarSystem | System where the state at (scalar) time t corresponds to the linear equation St + 3, where S is 4 by default |
| CQuadraticScalarSystem | System where the state at (scalar) time t corresponds to the quadratic equation St² + St + 3, where S is a user-defined Scalar (4 by default) |
| CQuarticScalarSystem | System where the state at (scalar) time t corresponds to the quartic equation t⁴ + 2t³ + 3t² + 4t + 5 |
| CQuinticScalarSystem | System where the state at (scalar) time t corresponds to the quintic equation t⁵ + 2t⁴ + 3t³ + 4t² + 5t + 6 |
| CInitializationTestSystem | A LeafSystem which declares all possible initialization events, and records information (in mutable variables and in the context) about whether the events have been processed |
| 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 |
| ►CMultibodyTreeSystem< double > | |
| CMultibodyPlant< double > | |
| CSceneGraph< double > | |
| ►CSpringMassSystem< double > | |
| CMySpringMassSystem< double > | |
| ►CSpringMassDamperSystem< double > | |
| CDiscontinuousSpringMassDamperSystem< double > | |
| CStiffDoubleMassSpringSystem< double > | |
| ►CTimeVaryingAffineSystem< double > | |
| ►CAffineSystem< double > | |
| CLinearSystem< double > | |
| CSystem< drake::symbolic::Expression > | |
| ►CSystem< Element::T > | |
| CLeafSystem< Element::T > | |
| CSystemOutput< T > | Conveniently stores a snapshot of the values of every output port of a System |
| CSystemOutput< drake::symbolic::Expression > | |
| ►CSystemParentServiceInterface | |
| CDiagram< double > | |
| CDiagram< T > | Diagram is a System composed of one or more constituent Systems, arranged in a directed graph where the vertices are the constituent Systems themselves, and the edges connect the output of one constituent System to the input of another |
| CSystemScalarConverter | Helper class to convert a System 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 > | |
| 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 |
| Ctemplate_single_tag< Tpl > | Provides a tag for single-parameter templates |
| CPolynomial< T >::Term | An individual variable raised to an integer power; e.g. x**2 |
| ►CTest | |
| CMultibodyPlantRemodeling | |
| CExplicitErrorControlledIntegratorTest< T > | |
| CGenericIntegratorTest< T > | |
| CImplicitIntegratorTest< IntegratorType > | |
| CPleidesTest< T > | |
| CDiagnosticPolicyTestBase | A base class for test fixtures that involve DiagnosticPolicy output |
| ►CTestWithParam | |
| CCollisionCheckerAbstractTestSuite | |
| ►CTimer | Abstract base class for timing utility |
| 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 |
| 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:
\[ x(t) = K e^{A (t - t_j)} \alpha_j + \sum_{i=0}^k \beta_{j,i}(t-t_j)^i, \]
where \(k\) is the order of the piecewise_polynomial_part and \(t_j\) is the start time of the \(j\)-th segment |
| 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< AutoDiffXd > | |
| ►CPiecewiseTrajectory< AutoDiffXd > | |
| CPiecewisePolynomial< AutoDiffXd > | |
| ►CTrajectory< double > | |
| CBezierCurve< double > | |
| ►CPiecewiseTrajectory< double > | |
| CExponentialPlusPiecewisePolynomial< double > | |
| CPiecewisePolynomial< double > | |
| ►CTrajectory< drake::symbolic::Expression > | |
| CBsplineTrajectory< drake::symbolic::Expression > | |
| 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 > > | |
| Ctype_at< I, Ts > | Extracts the Ith type from a sequence of types |
| Ctype_check_different_from< T > | Provides a check which returns whether T is different than U |
| Ctype_pack< Ts > | Provides a tag to pass a parameter packs for ease of inference |
| Ctype_tag< T > | Provides a tag to pass a type for ease of inference |
| Ctype_visit_with_default | Visit a type by constructing its default value |
| Ctype_visit_with_tag< Tag > | Visits a type by construct a template tag's default value |
| CTypeSafeIndex< Tag > | A type-safe non-negative index class |
| CTypeSafeIndex< class AbstractParameterTag > | |
| CTypeSafeIndex< class AbstractStateTag > | |
| CTypeSafeIndex< class BodyTag > | |
| CTypeSafeIndex< class CacheTag > | |
| CTypeSafeIndex< class DependencyTag > | |
| CTypeSafeIndex< class DiscreteStateTag > | |
| CTypeSafeIndex< class InputPortTag > | |
| CTypeSafeIndex< class JointElementTag > | |
| CTypeSafeIndex< class ModelInstanceTag > | |
| CTypeSafeIndex< class NumericParameterTag > | |
| CTypeSafeIndex< class OutputPortTag > | |
| ►Cuhash< HashAlgorithm > | A hashing functor, somewhat like std::hash |
| Chash< drake::geometry::render::RenderLabel > | Enables use of the label to serve as a key in STL containers |
| Chash< drake::Identifier< Tag > > | Enables use of the identifier to serve as a key in STL containers |
| Chash< drake::solvers::Binding< C > > | |
| Chash< drake::solvers::SolverId > | |
| Chash< drake::SortedPair< T > > | Provides std::hash<SortedPair<T>> |
| 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::Variables > | |
| Chash< drake::systems::sensors::PixelType > | |
| Chash< drake::TypeSafeIndex< Tag > > | Enables use of the type-safe index to serve as a key in STL containers |
| 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< ConvexSet > | |
| Ccopyable_unique_ptr< drake::AbstractValue > | |
| Ccopyable_unique_ptr< drake::geometry::render::RenderEngine > | |
| Ccopyable_unique_ptr< drake::geometry::Shape > | |
| Ccopyable_unique_ptr< drake::solvers::MathematicalProgram > | |
| Ccopyable_unique_ptr< drake::systems::CacheEntryValue > | |
| Ccopyable_unique_ptr< drake::systems::Context< T > > | |
| Ccopyable_unique_ptr< drake::systems::FixedInputPortValue > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< AutoDiffXd > > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< double > > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< drake::symbolic::Expression > > | |
| Ccopyable_unique_ptr< drake::systems::Parameters< T > > | |
| Ccopyable_unique_ptr< drake::trajectories::BsplineTrajectory< drake::symbolic::Expression > > | |
| Ccopyable_unique_ptr< drake::trajectories::Trajectory< double > > | |
| Ccopyable_unique_ptr< drake::trajectories::Trajectory< T > > | |
| Ccopyable_unique_ptr< Engine > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< AutoDiffXd > > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< double > > | |
| Ccopyable_unique_ptr< internal::ProximityEngine< 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 |
| CMyVector< T, N > | A simple subclass of BasicVector<T> for testing, particularly for cases where BasicVector subtyping must be preserved through the framework |
| CSpringMassStateVector< T > | The state of a one-dimensional spring-mass system, consisting of the position and velocity of the mass, in meters and meters/s |
| CSubvector< T > | Subvector is a concrete class template that implements VectorBase by providing a sliced view of a VectorBase |
| CSupervector< T > | Supervector is a concrete class template that implements VectorBase by concatenating multiple VectorBases, which it does not own |
| ►CVectorBase< AutoDiffXd > | |
| CBasicVector< AutoDiffXd > | |
| ►CVectorBase< double > | |
| CBasicVector< double > | |
| ►CVectorBase< drake::symbolic::Expression > | |
| CBasicVector< drake::symbolic::Expression > | |
| ►CVectorBase< Element::T > | |
| CBasicVector< Element::T > | |
| 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 > | |
| CvtkCommand | |
| CWitnessFunction< T > | Class that stores a function that is able to help determine the time and state at which a step of the initial value problem integration of a System should end, which may be done for any number of purposes, including publishing or state reinitialization (i.e., event handling) |
| CWitnessFunction< double > | |
| CWitnessTriggeredEventData< T > | An event data variant for storing data from a witness function triggering to be passed to event handlers |
| Cwrap_arg_default< T > | Default case for argument wrapping, with pure pass-through |
| 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) |
| CZmpTestTraj | A structure for storing trajectories from simulating a linear inverted pendulum model (LIPM) using the policy from a ZmpPlanner |
| Cconst ContextConstraintCalc< double > | |
| Cconst ContextConstraintCalc< Element::T > | |
| Cconst SystemConstraintCalc< double > | |
| Cconst SystemConstraintCalc< Element::T > | |
| Cdouble | |
| CInputPortLocator | |
| Cint | |
| Cint64_t | |
| COutputPortLocator | |
| CVector6< T > | |
| CVectorX< double > | |
| CVectorX< Element::T > | |
