Affine  
Linear  DrakeFunction of the form: 
SignedDistanceToHyperplane  DrakeFunction representing the distance from a point to a hyperplane 
BodyMotionData  Data structure describing the desired motion of a single body on the robot 
CapabilityMap  
CollisionFilterGroup  
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 
CompositeConstraint  CompositeConstraint This is a container class for a set of general constraints and slack variables 
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 
NonlinearComplementarityConstraint  NonlinearComplementarityConstraint A constraint of the form z >= 0, f(x,z) >= 0, <z,f(x,z)> = 0 
Constraint  Constraint that will be used for Drake solvers 
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) % 
DrakeFunctionConstraint  
FunctionHandleConstraint  FUNCTIONHANDLECONSTRAINT A Constraint implementation where the constraint is given by a function handle 
FunctionHandleObjective  The Drake optimization classes treat objectives as constraints 
LinearConstraint  Linear Constraint 
BoundingBoxConstraint  Enforce a bounding box constraint lb<=x<=ub 
ConstantConstraint  Enforce an equality constraint, x = desired_value 
NullConstraint  This constraint does nothing, but having it is easier that handling the possibility of empty matrices in lists of constraints 
PostureError  Penalize the cost sum_i (q(:,i)q_nom(:,i))'Q(q(:,i)q_nom(:,i)) 
QuadraticConstraint  Quadratic constraint of the form lb <= .5 * x'*Q*x + b'*x <= ub 
QuadraticSumConstraint  Lb <= sum_i (x(:,i)v(:,i))'Qa(x(:,i)v(:,i)) <= ub 
RelativeFixedPositionConstraint  Constrain the position of point body_pts_A on body_A to be fixed in a given body body_B 
SpotPolynomialConstraint  Polynomial constraint of the form lb <= p(x) <= ub, where p is stored as an msspoly column vector 
DrakeFunction  DrakeFunction.DrakeFunction Abstract parent class for all DrakeFunction classes A DrakeFunction represents a vectorvalued function of a single vector input 
DrakeFunction  
Affine  DrakeFunction representing an affine map:
\[ f(x) = Ax + b \]

Composed  Composed DrakeFunction representing the composition of two functions Implements f = fcn_outer(fcn_inner(x)) 
Concatenated  DrakeFunction representing the concatenation of n functions 
ConstantPower  
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 
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 
NormSquared  DrakeFunction representing the square of the Euclidean norm (or weighted Euclidean norm) for points in a given frame 
RigidBodyManipulatorFunction  Abstract parent class for functions that need to store a RigidBodyManipulator 
SmoothNorm  DrakeFunction representing the smooth norm of a vector: 
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 
DrakeSystem  A DynamicalSystem with the functionality (dynamics, update, outputs, etc) implemented in matlab, so that it is amenable to, for instance, symbolic manipulations 
BipedPlanEvalAndControlSystem  Neither PlanEval nor InstantaneousQPController implements the DrakeSystem interface 
BodyMotionControlBlock  A simple PD control block for regulating a body pose given a desired position, velocity, and acceleration 
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 
CoordinateTransform  
AffineTransform  A coordinate transform of the form x_to = T*x_from + b 
AngleWrappingTransform  Wraps all coordinates with angle_flag = true to be inside [pi+q0,pi+q0] 
FunctionHandleCoordinateTransform  
HybridStateTransform  
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 
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 
FeedbackSystem  
FunctionHandleSystem  
FunctionHandleCoordinateTransform  
HybridDrakeSystem  Some restrictions on the mode systems: must be CT only 
HybridRigidBodyManipulator  
LQRTree  
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 
HybridSystemSampleTimeTest  
Manipulator  An abstract class that wraps H(q)vdot + C(q,v,f_ext) = B(q)u 
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 
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 
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 
FootContactBlock  
IKPDBlock  Outputs a desired q_ddot (including floating dofs) 
QPController  A QPbased balancing and walking controller that exploits TVLQR solutions for (timevaring) linear COM/ZMP dynamics 
QTrajEvalBlock  Passes through the robot state and reads evals qtraj at the current t 
RobotiqControlBlock  
Observer  An interface class that sets up a system as an observer, or stateestimator, for an existing system 
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*} 
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 
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 
OnlinePlannerMex  
PolynomialSystem  A dynamical system described by rational polynomial dynamics, and polynomial outputs 
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 
ConstOrPassthroughSystem  Passes through a signal from input to output, optionally replacing some outputs with constant values 
ScopeSystem  A simple system that will pass the input through to the output, but publish it to the lcmscope on the way 
LinearSystem  
KinematicDummyPlant  
PointMassBiped  
PolynomialTrajectorySystem  Dynamics, update, output are polynomial in x and u, but not necessarily polynomial in t 
SpotPolynomialSystem  
StochasticPolynomialSystem  
PolytopicSystem  Defines a piecewise smooth system with piecewise segments defined on a polytope 
PolytopicPolynomialSystem  
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 
RigidBodyDepthSensorMeasurementsToOcTree  Dynamical system which takes in depth sensor points and a state estimate, and writes those points to an octree 
RobustDrakeSystem  Interface a nonlinear stochastic discrete/continuous system with (bandlimited) white noise input 
SecondOrderSystem  An abstract class that wraps qddot = f(t,q,qdot,u) 
SimpleDynamicsDummyPlant  
SimulationControlBlock  This block provides an easy way to halt your running simulation gently (i.e 
StochasticDrakeSystem  Interface a nonlinear stochastic discrete/continuous system with (bandlimited) white noise input 
DrakeSystemWGaussianNoise  This is a wrapper class which adds Gaussian process and measurement noise to an existing DrakeSystem 
LinearGaussianDT  
StochasticPolynomialSystem  
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 
Trajectory  
ConstantTrajectory  Trivial instance of a trajectory as a constant 
DTTrajectory  
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 
FunctionHandleTrajectory  
HybridTrajectory  Container class for a set of continuous trajectories punctuated by collision events 
MixedTrajectory  Creates a trajectory that concatenates dynamics 
ODESolTrajectory  
PPTrajectory  
TransverseLinearControl  Orbital stabilization via the transverse linearization 
Visualizer  An interface class which draws (e.g., produces a plot) the output of another dynamical system 
FunctionHandleVisualizer  Visualizer class where the draw methods is provided by a function handle 
MultiVisualizer  Stack a bunch of visualizers together so that they draw at the same time 
NullVisualizer  Visualizer that doesn't visualize (helpful for simulink simulation) 
Point2DVisualizer  Adds a point to an existing 2D scene 
RigidBodyContactVisualizer  
RigidBodyVisualizer  
BotVisualizer  Wraps the visualizer functionality around the drake libbot visualizer (externally compiled program) 
ContactWrenchVisualizer  This is a hack to visualize the contact wrenches and the centroidal momenta, together with the robot 
PlanarRigidBodyVisualizer  Loads a URDF file and implements the draw function 
RigidBodyWRLVisualizer  Loads a URDF file and implements the draw function 
ScopeVisualizer  Simple utility to plot one particular index of a coordinate frame 
VisualizerWithObstacles  Visualizer that also draws obstacles 
Reduction  
SimulinkModel  Implements the DynamicalSystem interface for any existing simulink model with one (vector) input and one (vector) output 
SimulinkBlock  
FinalPoseProblem  
Footstep  A data structure for a single footstep position 
FootstepPlan  A container for footstep plans 
FrictionCone  The nonlinear friction cone defined by unit cone axis cone_axis and friction coefficient mu_face 
LinearizedFrictionCone  The linearized friction cone defined by friction cone edges 
FunctionWrapper  FUNCTIONWRAPPER A simple class to wrap a function handle 
FunnelLibrary  
GraspedGeometry  
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  
GraspedPolyhedron  
GraspedSphere  
handle  
CoordinateFrame  Every input, state, and output in a DynamicalSystem has a coordinate frame attached to it 
LCMCoordinateFrame  
ForceTorque  
LCMCoordinateFrameWCoder  
MultiCoordinateFrame  Makes a mux'd coordinate frame out of a list of other frames 
SingletonCoordinateFrame  
DrakeMexPointer  My attempt to cleanup the mexmatlab sharing pointer interface 
DrakeConstraintMexPointer  This would be used to determine if a mex pointer refers to a RigidBodyConstraint object 
LCMPublisher  Defines an interface for an object that can publish a double on an LCM channel 
LCMCoordinateFrame  
LCMSubscriber  Defines an interface for LCM objects that get wrapped up in matlab vectors 
LCMCoordinateFrame  
OcTree  Wrapper class for octomap library octree functionality 
PlanEval  A PlanEval represents one half of a complete control system 
BipedPlanEval  A PlanEval which includes some bipedspecific tweaks 
QPControllerPlan  
QPControllerPlanMatlabImplementation  
FrozenPlan  
WaitForRobotStatePlan  
QPLocomotionPlanCPPWrapper  
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 
ControllerData  ControllerData is designed to be the parent of classes that contain data shared between controller modules 
QPControllerData  Class that contains data needed by the QPController and cascaded modules 
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 
Singleton  Implements a singleton design pattern 
ForceTorque  
SingletonCoordinateFrame  
WarningManager  Carry this object around (e.g 
hgsetget  
SWFWriter  Implements export to Adobe SWF (vectorized movie graphics) 
IKoptions  
InstantaneousQPController  A QPbased balancing and walking controller that exploits TVLQR solutions for (timevaring) linear COM/ZMP dynamics 
Kinematic  
CableLength  
RelativePosition  Position of points in frame A relative to frame B 
RelativeQuaternion  Quaternion from frame A to frame B 
SmoothDistancePenalty  DrakeFunction penalizing all distances less than a given minimum between bodies of a RigidBodyManipulator 
KinematicTrajectoryOptimization  Abstract class for kinematic planning 
KinematicDirtran  Trajectory planning problem in which the acceleration of the joints is taken to be directly controllable 
testClass  
LCMCoder  An LCM coder translates an LCM type into a vector of doubles used in Drake 
JLCMCoder  
LCMCoderFromType  Note: might be better (faster) to move this to java 
LCMSignalCoder  Handle the lcmt_drake_signal type 
LeggedRobot  Interface class for legged robots 
Biped  Interface class for a bipedal robot 
LeggedRobotPlanningProblem  Factory class for motion planning problems involving robots that implement the 'LeggedRobot' interface 
Linear  
ConstantMultiple  
Difference  DrakeFunction representing the first difference between a series of points: 
Identity  DrakeFunction representing the identity transform in a given frame 
Sum  Sum of N vectors of size M 
Zeros  DrakeFunction representing the zerotransformation from one CoordinateFrame to another 
LyapunovFunction  Interface class for Lyapunov functions 
FunctionHandleLyapunovFunction  
PolynomialLyapunovFunction  
QuadraticLyapunovFunction  X'*S*x + x'*s1 + s2 S,s1,s2 can be doubles or trajectories (yielding a timevarying quadratic) 
SpotPolynomialLyapunovFunction  
MixedIntegerConvexProgram  This class is meant to represent general mixedinteger linear, quadratic, quadraticallyconstrained, and secondordercone programs 
MixedIntegerFootstepPlanningProblem  A general structure for various footstep planning approaches 
RecoveryPlanner  
MotionPlanningProblem  Defines a feasible motion planning problem using Constraint class objects 
KinematicMotionPlanningProblem  
VertexArrayMotionPlanningTree  Partial implementation of MotionPlanningTree that uses the "checkConstraints" functionality of MotionPlanningProblem and stores the vertices of the tree in a num_varsbyn array 
CartesianMotionPlanningTree  Concrete implementation of the MotionPlanningTree interface for planning on $R^n$ with a Euclidean distance metric 
JointSpaceMotionPlanningTree  
R3MotionPlanningTree  
CompositeVertexArrayTree  Concrete impmlementation of the MotionPlanningTree interface which represents a tree composed of multiple trees, each in its own space 
SE3MotionPlanningTree  
TaskSpaceMotionPlanningTree  
OptimalTaskSpaceMotionPlanningTree  Subclass of motion planning tree that override and add functions to be used with asymptotically optimal versions of RRT algorithms 
SO3MotionPlanningTree  
MotionPlanningTree  
VertexArrayMotionPlanningTree  Partial implementation of MotionPlanningTree that uses the "checkConstraints" functionality of MotionPlanningProblem and stores the vertices of the tree in a num_varsbyn array 
MultipleTreeProblem  
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 
DirectTrajectoryOptimization  DIRECTTRAJECTORYOPTIMIZATION An abstract class for direct method approaches to trajectory optimization 
ContactImplicitTrajectoryOptimization  Phi, lambda 
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) 
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 
KinematicDirtran  Trajectory planning problem in which the acceleration of the joints is taken to be directly controllable 
PseudoSpectralMethodTrajOpt  Pseudospectral (PS) method for trajectory optimization 
SimpleDynamicsFullKinematicsPlanner  
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 
SingleBodyDynamicsFullKinematicsPlanner  Only compute the centroidal dynamics on the object being grasped 
FixedPointProgram  
HybridTrajectoryOptimization  HybridTrajectoryOptimization 
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 
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)] % 
QuadraticProgram  Provides a common interface to the wealth of QP solvers that we have kicking around 
testClass  
PassByValueMap  This class provides a passbyvalue version of the containers.Map class 
Point  
PointMassBipedPlan  
PolynomialTrajectory  Like a trajectory object, but it returns an msspoly for each t (via function handles) 
PolynomialWTimeVaryingCoefficients  Defines a polynomial (represented by an msspoly) with timevarying coefficients (represented as a trajectory) 
QPLocomotionPlanSettings  
RigidBodyConstraint  
MultipleTimeKinematicConstraint  A abstract class, that its eval function takes multiple time points as the input, instead of being evluated at a single time 
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 
MultipleTimeLinearPostureConstraint  A linear constraint on the robot posture for multiple times 
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 
QuasiStaticConstraint  Constrain the Center of Mass to lie inside the shrunk support polygon 
SingleTimeKinematicConstraint  An abstract class 
AllBodiesClosestDistanceConstraint  Constraining the closest distance between all bodies to be within [lb,ub] 
EulerConstraint  Constraint the roll, pitch, yaw angles (in intrinsic zy'x'' order) to be within the bounding box [lb ub]; 
WorldEulerConstraint  Constraint the roll, pitch, yaw angles (in intrinsic zy'x'' order) to be within the bounding box [lb ub]; 
GazeConstraint  
GazeDirConstraint  
RelativeGazeDirConstraint  This constrains that an axis on body A is aligned with a direction on body B to within a given threshold 
WorldGazeDirConstraint  
GazeOrientConstraint  
RelativeGazeOrientConstraint  
WorldGazeOrientConstraint  
GazeTargetConstraint  
RelativeGazeTargetConstraint  This constrains that a camera on body_a can gaze at a point on body_b 
WorldGazeTargetConstraint  
GravityCompensationTorqueConstraint  Constraint on the torque required to keep specified joints static in the face of gravity 
MinDistanceConstraint  Constrains the closest distance between all bodies to be greater than min_distance 
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)] 
PositionConstraint  
RelativePositionConstraint  Constraining points in body A to be within a bounding box in B' frame on body B 
WorldCoMConstraint  
WorldPositionConstraint  
WorldPositionInFrameConstraint  
QuatConstraint  Constrain the quaternion to satisfy the following conditions: 2*(quat'*quat_des)^21 in [cos(tol) 1] 
RelativeQuatConstraint  Constrains the orientation of the body reference frame of link A relative to the frame of Body B 
WorldQuatConstraint  Constrain the body satisfies 2*(quat'*quat_des)^21 in [cos(tol), 1]; 
SingleTimeLinearPostureConstraint  A linear constraint on the robot posture for a single time lb<=sparse(iAfun,jAvar,A,max(jAvar),robot.nq)*q<=ub 
RigidBodyContactWrench  Constrain the contact forces 
FrictionConeWrench  Constrain the friction force to be within a friction cone 
ComplementarityFrictionConeWrench  Implement the slack variable version of nonlinear function force >= 0 (nlcon) distance  gamma = 0 (nlcon) <force,gamma> = 0 (nlcon) gamma >= 0 (bcon) 
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 
ComplementarityGraspWrench  Implement the slack variable version of complementarity 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 
ComplementarityLinearFrictionConeWrench  Implement the slack variable version of complementarity constraint 
RigidBodyElement  Handles lazy binding of urdf parameters to rigid body element values 
RigidBody  
RigidBodyActuator  Trivial definition of the actuators allows us to define the mapping from input to joint torques 
RigidBodyForceElement  
RigidBodyAddedMass  
RigidBodyBluffBody  Element that provides an aerodynamic drag force at a point 
RigidBodyBuoyant  
RigidBodyPropellor  
RigidBodySpringDamper  
RigidBodyThrust  
RigidBodyTorsionalSpring  Adds torsionals linear springs, with torque = k*(rest_angle  current_angle), to rigid body manipulators 
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 
RigidBodyGeometry  
RigidBodyBox  
RigidBodyCapsule  
RigidBodyCylinder  
RigidBodyHeightMapTerrain  
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 
RigidBodySphere  
RigidBodyLoop  
RigidBodyManipulatorFunction  Abstract parent class for functions that need to store a RigidBodyManipulator 
RigidBodySensor  This is an interface class for sensors that are composed to form the output output of a RigidBodyManipulator 
FullStateFeedbackSensor  
RigidBodyDepthSensor  Uses collision detection framework to simulate a depth camera rangefinder 
RigidBodyLidar  
RigidBodyInertialMeasurementUnit  Outputs angular orientation, angular velocity, and linear acceleration 
RigidBodyJointSensor  Outputs a (vector of) joint positions, given a mask specifying which DOF to include 
RigidBodyTerrain  Basic interface class for terrain 
RigidBodyFlatTerrain  This class provides an implementation of RigidBodyTerrain with z=0 everywhere 
RigidBodyFlatTerrainNoGeometry  This class provides an implementation of RigidBodyTerrain with z=0 everywhere 
RigidBodyHeightMapTerrain  
RigidBodyFrame  A number of RigidBodyElements (e.g 
RigidBodyManipulatorFunction  
Kinematic  Abstract parent class for kinematic functions All children of this class take the jointangles of a specific RigidBodyManipulator as their input 
RigidBodySupportState  RigidBodySupportState defines a set of supporting bodies and contacts for a rigid body manipulator 
spotsosprog  
BMIspotless  Please make sure you have spotless on your machine 
InverseKinematicsBMI  
PolyhedronNoCollision  Search for separating hyperplane c'x+d between two polyhedron to avoid contact 
StereographicPoly  Effectively overloads msspoly with trig functions which are implemented using the stereographic projection 
TaylorVar  Does inline autodiff overloads operators: http://www.mathworks.com/help/techdoc/matlab_oop/br02znk1.html 
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 
ContactForceTorqueSensor  ContactForceTorqueSensor outputs the net force and torque applied to a given body by all contacts with other bodies 
TrajectoryLibrary  
TrajectoryLibraryGenerator  
WaypointTrajectoryLibraryGenerator  
TransversalSurface  Transversal surfaces for orbital stabilization irm@m.nosp@m.it.e.nosp@m.du 
TrigPoly  Support class for parsing functions into their polynomial and trigonemetric components 