Drake

Affine  DrakeFunction representing an affine map:
\[ f(x) = Ax + b \] 
AffineSystem  Implements xcdot = Ac*x + Bc*u + xcdot0 xdn = Ad*x + Bd*u + xdn0 y = C*x + D*u + y0 
AffineTransform  A coordinate transform of the form x_to = T*x_from + b 
AllBodiesClosestDistanceConstraint  Constraining the closest distance between all bodies to be within [lb,ub] 
AngleWrappingTransform  Wraps all coordinates with angle_flag = true to be inside [pi+q0,pi+q0] 
Biped  Interface class for a bipedal robot 
BipedPlanEval  A PlanEval which includes some bipedspecific tweaks 
BipedPlanEvalAndControlSystem  Neither PlanEval nor InstantaneousQPController implements the DrakeSystem interface 
BMIspotless  Please make sure you have spotless on your machine 
BodyMotionControlBlock  A simple PD control block for regulating a body pose given a desired position, velocity, and acceleration 
BodyMotionData  Data structure describing the desired motion of a single body on the robot 
BotVisualizer  Wraps the visualizer functionality around the drake libbot visualizer (externally compiled program) 
BoundingBoxConstraint  Enforce a bounding box constraint lb<=x<=ub 
CableLength  
CapabilityMap  
CartesianMotionPlanningTree  Concrete implementation of the MotionPlanningTree interface for planning on $R^n$ with a Euclidean distance metric 
CascadeSystem  
ClosedLoopObserverErrorSystem  Creates a system that is the result of the feedback combination of the plant, observer, and controller, with the output of the system being the estimation error of the observer 
CollisionFilterGroup  
ComDynamicsFullKinematicsPlanner  This planner impose the following dynamics constraint kc_com(q) = com at evey t_knot H(:,i) H(:,i1) = Hdot(:,i)*dt(i) Hdot(:,i) = sum_j cross(p_contact_jcom(:,i),F_j) com(:,i)  com(:,i1) = comdot(:,i)*dt(i) comdot(:,i)comdot(:,i1) = comddot(:,i)*dt(i) m*comddot(:,i) = sum_j F_jm*g q(:,i)q(:,i1) = v(:,i)*dt(i) A*v(:,i) = H(:,i) where A = robot.centroidalMomentumMatrix 
ComplementarityFrictionConeWrench  Implement the slack variable version of nonlinear function force >= 0 (nlcon) distance  gamma = 0 (nlcon) <force,gamma> = 0 (nlcon) gamma >= 0 (bcon) 
ComplementarityGraspWrench  Implement the slack variable version of complementarity constraint 
ComplementarityLinearFrictionConeWrench  Implement the slack variable version of complementarity constraint 
ComplementaritySingleSideStaticContactConstraint  Enforce the constraint force*(contact_pos(i)contact_pos(j)) = 0 
ComplementarityStaticContactConstraint  Enforces the constraint force_normal(i)*(contact_pos(i)contact_pos(i+1)) = 0 By contact_pos_x(i)contact_pos_x(i+1) <= gamma1 contact_pos_x(i)contact_pos_x(i+1) >= gamma1 contact_pos_y(i)contact_pos_y(i+1) <= gamma2 contact_pos_y(i)contact_pos_y(i+1) >= gamma2 <force_normal(i),gamma1> = 0 (elementwise) <force_normal(i),gamma2> = 0 (elementwise) gamma1 >= 0 gamma2 >= 0 
Composed  Composed DrakeFunction representing the composition of two functions Implements f = fcn_outer(fcn_inner(x)) 
CompositeConstraint  CompositeConstraint This is a container class for a set of general constraints and slack variables 
CompositeVertexArrayTree  Concrete impmlementation of the MotionPlanningTree interface which represents a tree composed of multiple trees, each in its own space 
Concatenated  DrakeFunction representing the concatenation of n functions 
ConstantConstraint  Enforce an equality constraint, x = desired_value 
ConstantMultiple  
ConstantPower  
ConstantTrajectory  Trivial instance of a trajectory as a constant 
ConstOrPassthroughSystem  Passes through a signal from input to output, optionally replacing some outputs with constant values 
Constraint  Constraint that will be used for Drake solvers 
ContactForceTorqueSensor  ContactForceTorqueSensor outputs the net force and torque applied to a given body by all contacts with other bodies 
ContactImplicitTrajectoryOptimization  Phi, lambda 
ContactWrenchVisualizer  This is a hack to visualize the contact wrenches and the centroidal momenta, together with the robot 
ControllerData  ControllerData is designed to be the parent of classes that contain data shared between controller modules 
CoordinateFrame  Every input, state, and output in a DynamicalSystem has a coordinate frame attached to it 
CoordinateTransform  
CubicPostureError  Approximate the posture as a cubic spline, and penalize the cost sum_i (q(:,i)q_nom(:,i))'Q(q(:,i)q_nom(:,i))+ sum_i qdot(:,i)'Qv*qdot(:,i) + sum_i qddot(:,i)'*Qa*qddot(:,i) [qdot(:,2);qdot(:,3);;qdot(:,obj.nT1)] = % velocity_mat[q(:,1);q(:,2);;q(:,obj.nT)]+velocity_mat_qd0*qdot(:,1)+velocity_mat_qdf*qdot(:,obj.nT) % 
DesiredQuatDiff  Given a quaternion quat, and the desired quaternion quat_des, compute the geodesic distance between those two quaternions as 2(quat'*quat_des)^21 
Difference  DrakeFunction representing the first difference between a series of points: 
DircolTrajectoryOptimization  Direct colocation approach Over each interval, f(x(k),u(k)) and f(x(k+1),u(k+1)) are evaluated to determine d/dt x(k) and d/dt x(k+1) 
DirectTrajectoryOptimization  DIRECTTRAJECTORYOPTIMIZATION An abstract class for direct method approaches to trajectory optimization 
DirtranTrajectoryOptimization  Direct transcription trajectory optimization implements multiple possible integration schemes for the dynamics constraints xdot = f(x,u) and for for integrating the running cost term 
DrakeConstraintMexPointer  This would be used to determine if a mex pointer refers to a RigidBodyConstraint object 
DrakeFunction  DrakeFunction.DrakeFunction Abstract parent class for all DrakeFunction classes A DrakeFunction represents a vectorvalued function of a single vector input 
DrakeFunctionConstraint  
DrakeMexPointer  My attempt to cleanup the mexmatlab sharing pointer interface 
DrakeSystem  A DynamicalSystem with the functionality (dynamics, update, outputs, etc) implemented in matlab, so that it is amenable to, for instance, symbolic manipulations 
DrakeSystemWGaussianNoise  This is a wrapper class which adds Gaussian process and measurement noise to an existing DrakeSystem 
DTTrajectory  
DynamicalSystem  An interface class for a statespace dynamical system with a single (vector) input u, a single (vector) output y, and a single (vector) state x composed of a combination of continuous time and discrete time variables 
EulerConstraint  Constraint the roll, pitch, yaw angles (in intrinsic zy'x'' order) to be within the bounding box [lb ub]; 
ExpPlusPPTrajectory  Useful for solutions to linear systems driven by pptrajectory inputs in interval j, we have y(t) = K * exp(A*(ttj)) * alpha(:,j) + sum_i gamma(:,j,i) (ttj)^i 
FeedbackSystem  
FinalPoseProblem  
FixedPointProgram  
FootContactBlock  
Footstep  A data structure for a single footstep position 
FootstepPlan  A container for footstep plans 
ForceTorque  
FrictionCone  The nonlinear friction cone defined by unit cone axis cone_axis and friction coefficient mu_face 
FrictionConeWrench  Constrain the friction force to be within a friction cone 
FrozenPlan  
FullStateFeedbackSensor  
FunctionHandleConstraint  FUNCTIONHANDLECONSTRAINT A Constraint implementation where the constraint is given by a function handle 
FunctionHandleCoordinateTransform  
FunctionHandleLyapunovFunction  
FunctionHandleObjective  The Drake optimization classes treat objectives as constraints 
FunctionHandleSystem  
FunctionHandleTrajectory  
FunctionHandleVisualizer  Visualizer class where the draw methods is provided by a function handle 
FunctionWrapper  FUNCTIONWRAPPER A simple class to wrap a function handle 
FunnelLibrary  
GazeConstraint  
GazeDirConstraint  
GazeOrientConstraint  
GazeTargetConstraint  
GraspedCylinder  The cylinder is parameterized as R_cylinder*[r_cylinder*cos(theta);r_cylinder*sin(theta);z]+b_cylinder, where R_cylinder is a rotation matrix, and b_cylinder is the translation 
GraspedEllipsoid  
GraspedGeometry  
GraspedPolyhedron  
GraspedSphere  
GraspFrictionConeWrench  When consider hand contact, the usual case is that we have a contact patch on the hand, but the contact normal direction is specified on the object being grasped 
GraspWrench  A force and a torque can be applied at a single contact point 
GravityCompensationTorqueConstraint  Constraint on the torque required to keep specified joints static in the face of gravity 
handle  
hgsetget  
HybridDrakeSystem  Some restrictions on the mode systems: must be CT only 
HybridRigidBodyManipulator  
HybridRigidBodyMode  Simple shell around an RBM which adds extra (discrete) variables to store the "mode", but avoids the pitfalls of having many copies of nearly identical systems stored as different modes in the HybridDrakeSystem 
HybridStateTransform  
HybridSystemSampleTimeTest  
HybridTrajectory  Container class for a set of continuous trajectories punctuated by collision events 
HybridTrajectoryOptimization  HybridTrajectoryOptimization 
Identity  DrakeFunction representing the identity transform in a given frame 
IKoptions  
IKPDBlock  Outputs a desired q_ddot (including floating dofs) 
InstantaneousQPController  A QPbased balancing and walking controller that exploits TVLQR solutions for (timevaring) linear COM/ZMP dynamics 
InverseKinematics  Solve the inverse kinematics problem min_q 0.5*(qqnom)'Q(qqnom)+cost1(q)+cost2(q)+ % s.t lb<= kc(q) <=ub q_lb<= q <=q_ub where cost1, cost2 are functions defined by user 
InverseKinematicsBMI  
InverseKinematicsTrajectory  Solve IK min_q sum_i qdd(:,i)'Qa*qdd(:,i)+qd(:,i)'*Qv*qd(:,i)+(q(:,i)q_nom(:,i))'*Q(q(:,i)q_nom(:,i))]+additional_cost1+additional_cost2+ % subject to constraint1 at t_samples(i) constraint2 at t_samples(i) % constraint(k) at [t_samples(1) t_samples(2) t_samples(nT)] % constraint(k+1) at [t_samples(1) t_samples(2) t_samples(nT)] % 
JLCMCoder  
JointSpaceMotionPlanningTree  
Kinematic  Abstract parent class for kinematic functions All children of this class take the jointangles of a specific RigidBodyManipulator as their input 
KinematicDirtran  Trajectory planning problem in which the acceleration of the joints is taken to be directly controllable 
KinematicDummyPlant  
KinematicMotionPlanningProblem  
KinematicTrajectoryOptimization  Abstract class for kinematic planning 
LCMCoder  An LCM coder translates an LCM type into a vector of doubles used in Drake 
LCMCoderFromType  Note: might be better (faster) to move this to java 
LCMCoordinateFrame  
LCMCoordinateFrameWCoder  
LCMPublisher  Defines an interface for an object that can publish a double on an LCM channel 
LCMSignalCoder  Handle the lcmt_drake_signal type 
LCMSubscriber  Defines an interface for LCM objects that get wrapped up in matlab vectors 
LeggedRobot  Interface class for legged robots 
LeggedRobotPlanningProblem  Factory class for motion planning problems involving robots that implement the 'LeggedRobot' interface 
Linear  DrakeFunction of the form: 
LinearCombination  DrakeFunction which given n points in the same frame, as well as n weights, returns the linear combination of those points with those weights 
LinearComplementarityConstraint  LinearComplementarityConstraint A constraint of the form z >= 0, Wz + Mx + q >= 0, <z,Wz + q> = 0 for given W,q Constraints are applied to the stacked vector [x;z;gamma] wherever there are slack variables gamma 
LinearConstraint  Linear Constraint 
LinearFrictionConeWrench  Constrain the contact force to be in a linearized friction cone The contact force f_contact = [edge1 edge2 edgeN] *[f1;f2;;fN] where edgeK is % the K'th edge of the linearized friction cone, fK is the force paramter along the K'th % edge 
LinearGaussianDT  
LinearizedFrictionCone  The linearized friction cone defined by friction cone edges 
LinearSystem  
LQRTree  
LuenbergerObserver  A potentially nonlinear observer with linear (possibly timevarying) observer gains {gather*} {xdot}_c(t) = f_c(t,{x},u) + L_c(t) ( y  {y} ) \ {x}_d[n+1] = f_d(t,{x},u) + L_d(t) (y  {y} ) \ {y} = g(t,{x},u) \ y = {x} {gather*} 
LyapunovFunction  Interface class for Lyapunov functions 
Manipulator  An abstract class that wraps H(q)vdot + C(q,v,f_ext) = B(q)u 
MarkovDecisionProcess  Implements a modelbased (transition probabilities are known) finitestate, finiteaction, discrete time markov decision process 
MarkovDecisionProcessPolicy  Takes a probability distribution over discrete states in and outputs the expected action 
MIMODrakeSystem  For DrakeSystems with MultiCoordinateFrame inputs and/or outputs, this method simply provides a helper routine which splits up the input into pieces and reassembles the output 
MinDistanceConstraint  Constrains the closest distance between all bodies to be greater than min_distance 
MixedIntegerConvexProgram  This class is meant to represent general mixedinteger linear, quadratic, quadraticallyconstrained, and secondordercone programs 
MixedIntegerFootstepPlanningProblem  A general structure for various footstep planning approaches 
MixedTrajectory  Creates a trajectory that concatenates dynamics 
MotionPlanningProblem  Defines a feasible motion planning problem using Constraint class objects 
MotionPlanningTree  
MultiCoordinateFrame  Makes a mux'd coordinate frame out of a list of other frames 
MultipleTimeKinematicConstraint  A abstract class, that its eval function takes multiple time points as the input, instead of being evluated at a single time 
MultipleTimeLinearPostureConstraint  A linear constraint on the robot posture for multiple times 
MultipleTreeProblem  
MultiVisualizer  Stack a bunch of visualizers together so that they draw at the same time 
NonlinearComplementarityConstraint  NonlinearComplementarityConstraint A constraint of the form z >= 0, f(x,z) >= 0, <z,f(x,z)> = 0 
NonlinearConstraint  
NonlinearConstraint1  NOTEST 
NonlinearProgram  Minimize_x objective(x) subject to cin_lb<=nonlinear_inequality_constraints(x) <= cin_ub nonlinear_equality_constraints(x) = 0 Ain*x <= bin Aeq*x = beq x_lb <= x <= x_ub 
NormSquared  DrakeFunction representing the square of the Euclidean norm (or weighted Euclidean norm) for points in a given frame 
NullConstraint  This constraint does nothing, but having it is easier that handling the possibility of empty matrices in lists of constraints 
NullVisualizer  Visualizer that doesn't visualize (helpful for simulink simulation) 
Observer  An interface class that sets up a system as an observer, or stateestimator, for an existing system 
ObserverErrorSystem  The input of this system is the input to observed system, and the output is the error in the estimate of the state of the observed system 
OcTree  Wrapper class for octomap library octree functionality 
OcTreeSystem  Builds a system which takes a state estimate (of a rigid body manipulator) and a point cloud sensor stream as inputs and writes it into an OcTree object 
ODESolTrajectory  
OnlinePlannerMex  
OptimalTaskSpaceMotionPlanningTree  Subclass of motion planning tree that override and add functions to be used with asymptotically optimal versions of RRT algorithms 
PassByValueMap  This class provides a passbyvalue version of the containers.Map class 
PlanarRigidBodyManipulator  This class wraps the planar pieces of the spatial vector library (v1) provided by Roy Featherstone on his website: http://users.cecs.anu.edu.au/~roy/spatial/documentation.html 
PlanarRigidBodyVisualizer  Loads a URDF file and implements the draw function 
PlanEval  A PlanEval represents one half of a complete control system 
Point  
Point2DVisualizer  Adds a point to an existing 2D scene 
Point2LineSegDistConstraint  This constrain the distance between a point on a body to a line segment is within a range 
Point2PointDistanceConstraint  Constrain the distance between ptA(:,i) on body A to ptB(:,i) on body B to be within the range of [lb(i) ub(i)] 
PointMassBiped  
PointMassBipedPlan  
PolyhedronNoCollision  Search for separating hyperplane c'x+d between two polyhedron to avoid contact 
PolynomialLyapunovFunction  
PolynomialSystem  A dynamical system described by rational polynomial dynamics, and polynomial outputs 
PolynomialTrajectory  Like a trajectory object, but it returns an msspoly for each t (via function handles) 
PolynomialTrajectorySystem  Dynamics, update, output are polynomial in x and u, but not necessarily polynomial in t 
PolynomialWTimeVaryingCoefficients  Defines a polynomial (represented by an msspoly) with timevarying coefficients (represented as a trajectory) 
PolytopicPolynomialSystem  
PolytopicSystem  Defines a piecewise smooth system with piecewise segments defined on a polytope 
PolyToTrigTransform  For trigpoly dynamical systems (e.g., xdot = [x(2); sin(x(1))]), we often analyze the polynomial system given where y=[sin(x(1);cos(x(1));x(2)]; This transformation converts from y to x 
PositionConstraint  
PostureChangeConstraint  This constrains that the change of joint i within time tspan must be within [lb,ub] 
PostureConstraint  A bounding box constraint on robot posture 
PostureError  Penalize the cost sum_i (q(:,i)q_nom(:,i))'Q(q(:,i)q_nom(:,i)) 
PPRateTransition  PIECEWISEPOLYNOMIAL RATE TRANSITION SYSTEM Some systems, such as a trajectory planner running as a modelpredictive controller, run at low sample rates, but think enough about the future to be able to produce continuous outputs 
PPTrajectory  
PseudoSpectralMethodTrajOpt  Pseudospectral (PS) method for trajectory optimization 
QPController  A QPbased balancing and walking controller that exploits TVLQR solutions for (timevaring) linear COM/ZMP dynamics 
QPControllerData  Class that contains data needed by the QPController and cascaded modules 
QPControllerPlan  
QPControllerPlanMatlabImplementation  
QPLocomotionPlanCPPWrapper  
QPLocomotionPlanSettings  
QTrajEvalBlock  Passes through the robot state and reads evals qtraj at the current t 
QuadraticConstraint  Quadratic constraint of the form lb <= .5 * x'*Q*x + b'*x <= ub 
QuadraticLyapunovFunction  X'*S*x + x'*s1 + s2 S,s1,s2 can be doubles or trajectories (yielding a timevarying quadratic) 
QuadraticProgram  Provides a common interface to the wealth of QP solvers that we have kicking around 
QuadraticSumConstraint  Lb <= sum_i (x(:,i)v(:,i))'Qa(x(:,i)v(:,i)) <= ub 
QuasiStaticConstraint  Constrain the Center of Mass to lie inside the shrunk support polygon 
QuatConstraint  Constrain the quaternion to satisfy the following conditions: 2*(quat'*quat_des)^21 in [cos(tol) 1] 
R3MotionPlanningTree  
RecoveryPlanner  
Reduction  
RelativeFixedPositionConstraint  Constrain the position of point body_pts_A on body_A to be fixed in a given body body_B 
RelativeGazeDirConstraint  This constrains that an axis on body A is aligned with a direction on body B to within a given threshold 
RelativeGazeOrientConstraint  
RelativeGazeTargetConstraint  This constrains that a camera on body_a can gaze at a point on body_b 
RelativePosition  Position of points in frame A relative to frame B 
RelativePositionConstraint  Constraining points in body A to be within a bounding box in B' frame on body B 
RelativeQuatConstraint  Constrains the orientation of the body reference frame of link A relative to the frame of Body B 
RelativeQuaternion  Quaternion from frame A to frame B 
RigidBody  
RigidBodyActuator  Trivial definition of the actuators allows us to define the mapping from input to joint torques 
RigidBodyAddedMass  
RigidBodyBluffBody  Element that provides an aerodynamic drag force at a point 
RigidBodyBox  
RigidBodyBuoyant  
RigidBodyCapsule  
RigidBodyConstraint  
RigidBodyContactVisualizer  
RigidBodyContactWrench  Constrain the contact forces 
RigidBodyCylinder  
RigidBodyDepthSensor  Uses collision detection framework to simulate a depth camera rangefinder 
RigidBodyDepthSensorMeasurementsToOcTree  Dynamical system which takes in depth sensor points and a state estimate, and writes those points to an octree 
RigidBodyElement  Handles lazy binding of urdf parameters to rigid body element values 
RigidBodyFlatTerrain  This class provides an implementation of RigidBodyTerrain with z=0 everywhere 
RigidBodyFlatTerrainNoGeometry  This class provides an implementation of RigidBodyTerrain with z=0 everywhere 
RigidBodyForceElement  
RigidBodyFrame  A number of RigidBodyElements (e.g 
RigidBodyGeometry  
RigidBodyHeightMapTerrain  
RigidBodyInertialMeasurementUnit  Outputs angular orientation, angular velocity, and linear acceleration 
RigidBodyJointSensor  Outputs a (vector of) joint positions, given a mask specifying which DOF to include 
RigidBodyLidar  
RigidBodyLoop  
RigidBodyManipulator  This class wraps the spatial vector library (v1) provided by Roy Featherstone on his website: http://users.cecs.anu.edu.au/~roy/spatial/documentation.html 
RigidBodyManipulatorFunction  Abstract parent class for functions that need to store a RigidBodyManipulator 
RigidBodyMesh  
RigidBodyMeshPoints  RigidBodyMeshPoints Represents the convex hull of a set of points This class allows for the programatic creation of geometries consisting of the convex hull of a set of points 
RigidBodyPropellor  
RigidBodySensor  This is an interface class for sensors that are composed to form the output output of a RigidBodyManipulator 
RigidBodySphere  
RigidBodySpringDamper  
RigidBodySupportState  RigidBodySupportState defines a set of supporting bodies and contacts for a rigid body manipulator 
RigidBodyTerrain  Basic interface class for terrain 
RigidBodyThrust  
RigidBodyTorsionalSpring  Adds torsionals linear springs, with torque = k*(rest_angle  current_angle), to rigid body manipulators 
RigidBodyVisualizer  
RigidBodyWing  This class implements a wing element, supporting flat plates and airfoils defined with NACA numbers, a geometry profile (with xfoil and AVL backend) and .mat files defining wing performance 
RigidBodyWingWithControlSurface  Implements functionality similar to RigidBodyWing but with a control surface attached to the wing 
RigidBodyWRLVisualizer  Loads a URDF file and implements the draw function 
RobotiqControlBlock  
RobustDrakeSystem  Interface a nonlinear stochastic discrete/continuous system with (bandlimited) white noise input 
ScopeSystem  A simple system that will pass the input through to the output, but publish it to the lcmscope on the way 
ScopeVisualizer  Simple utility to plot one particular index of a coordinate frame 
SE3MotionPlanningTree  
SecondOrderSystem  An abstract class that wraps qddot = f(t,q,qdot,u) 
SharedDataHandle  Utility class to make it convenient to make a piece of data behave like a handle class example usage: mex_model_ptr = SharedDataHandle(mex_model_ptr); now mex_model_ptr continues to act like it did before, but will internally be accessing the shared data structure 
SignedDistanceToHyperplane  DrakeFunction representing the distance from a point to a hyperplane 
SimpleDynamicsDummyPlant  
SimpleDynamicsFullKinematicsPlanner  
SimulationControlBlock  This block provides an easy way to halt your running simulation gently (i.e 
SimulinkBlock  
SimulinkModel  Implements the DynamicalSystem interface for any existing simulink model with one (vector) input and one (vector) output 
SimulinkModelHandle  Utility class to make it convenient to make a piece of data behave like a handle class example usage: mex_model_ptr = SharedDataHandle(mex_model_ptr); now mex_model_ptr continues to act like it did before, but will internally be accessing the shared data structure 
SingleBodyDynamicsFullKinematicsPlanner  Only compute the centroidal dynamics on the object being grasped 
SingleTimeKinematicConstraint  An abstract class 
SingleTimeLinearPostureConstraint  A linear constraint on the robot posture for a single time lb<=sparse(iAfun,jAvar,A,max(jAvar),robot.nq)*q<=ub 
Singleton  Implements a singleton design pattern 
SingletonCoordinateFrame  
SmoothDistancePenalty  DrakeFunction penalizing all distances less than a given minimum between bodies of a RigidBodyManipulator 
SmoothNorm  DrakeFunction representing the smooth norm of a vector: 
SO3MotionPlanningTree  
SpotPolynomialConstraint  Polynomial constraint of the form lb <= p(x) <= ub, where p is stored as an msspoly column vector 
SpotPolynomialLyapunovFunction  
SpotPolynomialSystem  
spotsosprog  
StereographicPoly  Effectively overloads msspoly with trig functions which are implemented using the stereographic projection 
StochasticDrakeSystem  Interface a nonlinear stochastic discrete/continuous system with (bandlimited) white noise input 
StochasticPolynomialSystem  
Sum  Sum of N vectors of size M 
SWFWriter  Implements export to Adobe SWF (vectorized movie graphics) 
TaskSpaceMotionPlanningTree  
TaylorVar  Does inline autodiff overloads operators: http://www.mathworks.com/help/techdoc/matlab_oop/br02znk1.html 
testClass  
TimeSteppingRigidBodyManipulator  A discrete time system which simulates (an Euler approximation of) the manipulator equations, with contact / limits resolved using the linear complementarity problem formulation of contact in Stewart96 
TimeSteppingRigidBodySensor  Analogous to RigidBodySensor, but for TimeStepping manipulators 
TimeSteppingRigidBodySensorWithState  Sensors that have internal dynamics we want to model, or sensors that need to be prevented from being direct feedthrough 
Trajectory  
TrajectoryLibrary  
TrajectoryLibraryGenerator  
TransversalSurface  Transversal surfaces for orbital stabilization irm@m it.e du 
TransverseLinearControl  Orbital stabilization via the transverse linearization 
TrigPoly  Support class for parsing functions into their polynomial and trigonemetric components 
TrigToPolyTransform  For trigpoly dynamical systems (e.g., xdot = [x(2); sin(x(1))]), we often analyze the polynomial system given where y=[sin(x(1);cos(x(1));x(2)]; This transformation converts from x to y 
VertexArrayMotionPlanningTree  Partial implementation of MotionPlanningTree that uses the "checkConstraints" functionality of MotionPlanningProblem and stores the vertices of the tree in a num_varsbyn array 
Visualizer  An interface class which draws (e.g., produces a plot) the output of another dynamical system 
VisualizerWithObstacles  Visualizer that also draws obstacles 
WaitForRobotStatePlan  
WarningManager  Carry this object around (e.g 
WaypointTrajectoryLibraryGenerator  
WorldCoMConstraint  
WorldEulerConstraint  Constraint the roll, pitch, yaw angles (in intrinsic zy'x'' order) to be within the bounding box [lb ub]; 
WorldFixedBodyPoseConstraint  Constrain the posture (position and orientation) of a body to be fixed within a time interval 
WorldFixedOrientConstraint  Constrain a certain body to be in a fixed orientation for a time interval 
WorldFixedPositionConstraint  Constraint some points on a certain body to be in a fixed position for a time interval 
WorldGazeDirConstraint  
WorldGazeOrientConstraint  
WorldGazeTargetConstraint  
WorldPositionConstraint  
WorldPositionInFrameConstraint  
WorldQuatConstraint  Constrain the body satisfies 2*(quat'*quat_des)^21 in [cos(tol), 1]; 
Zeros  DrakeFunction representing the zerotransformation from one CoordinateFrame to another 