All Classes Files Functions Variables
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
oCAffineDrakeFunction representing an affine map:

\[ f(x) = Ax + b \]

oCAffineSystemImplements xcdot = Ac*x + Bc*u + xcdot0 xdn = Ad*x + Bd*u + xdn0 y = C*x + D*u + y0
oCAffineTransformA coordinate transform of the form x_to = T*x_from + b
oCAllBodiesClosestDistanceConstraintConstraining the closest distance between all bodies to be within [lb,ub]
oCAngleWrappingTransformWraps all coordinates with angle_flag = true to be inside [-pi+q0,pi+q0]
oCBipedInterface class for a bipedal robot
oCBipedPlanEvalA PlanEval which includes some biped-specific tweaks
oCBipedPlanEvalAndControlSystemNeither PlanEval nor InstantaneousQPController implements the DrakeSystem interface
oCBMIspotlessPlease make sure you have spotless on your machine
oCBodyMotionControlBlockA simple PD control block for regulating a body pose given a desired position, velocity, and acceleration
oCBodyMotionDataData structure describing the desired motion of a single body on the robot
oCBotVisualizerWraps the visualizer functionality around the drake libbot visualizer (externally compiled program)
oCBoundingBoxConstraintEnforce a bounding box constraint lb<=x<=ub
oCCartesianMotionPlanningTreeConcrete implementation of the MotionPlanningTree interface for planning on $R^n$ with a Euclidean distance metric
oCClosedLoopObserverErrorSystemCreates 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
oCComDynamicsFullKinematicsPlannerThis planner impose the following dynamics constraint kc_com(q) = com at evey t_knot H(:,i) -H(:,i-1) = Hdot(:,i)*dt(i) Hdot(:,i) = sum_j cross(p_contact_j-com(:,i),F_j) com(:,i) - com(:,i-1) = comdot(:,i)*dt(i) comdot(:,i)-comdot(:,i-1) = comddot(:,i)*dt(i) m*comddot(:,i) = sum_j F_j-m*g q(:,i)-q(:,i-1) = v(:,i)*dt(i) A*v(:,i) = H(:,i) where A = robot.centroidalMomentumMatrix
oCComplementarityFrictionConeWrenchImplement the slack variable version of nonlinear function force >= 0 (nlcon) distance - gamma = 0 (nlcon) <force,gamma> = 0 (nlcon) gamma >= 0 (bcon)
oCComplementarityGraspWrenchImplement the slack variable version of complementarity constraint
oCComplementarityLinearFrictionConeWrenchImplement the slack variable version of complementarity constraint
oCComplementaritySingleSideStaticContactConstraintEnforce the constraint force*(contact_pos(i)-contact_pos(j)) = 0
oCComplementarityStaticContactConstraintEnforces 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
oCComposedComposed DrakeFunction representing the composition of two functions Implements f = fcn_outer(fcn_inner(x))
oCCompositeConstraintCompositeConstraint This is a container class for a set of general constraints and slack variables
oCCompositeVertexArrayTreeConcrete impmlementation of the MotionPlanningTree interface which represents a tree composed of multiple trees, each in its own space
oCConcatenatedDrakeFunction representing the concatenation of n functions
oCConstantConstraintEnforce an equality constraint, x = desired_value
oCConstantTrajectoryTrivial instance of a trajectory as a constant
oCConstOrPassthroughSystemPasses through a signal from input to output, optionally replacing some outputs with constant values
oCConstraintConstraint that will be used for Drake solvers
oCContactForceTorqueSensorContactForceTorqueSensor outputs the net force and torque applied to a given body by all contacts with other bodies
oCContactImplicitTrajectoryOptimizationPhi, lambda
oCContactWrenchVisualizerThis is a hack to visualize the contact wrenches and the centroidal momenta, together with the robot
oCControllerDataControllerData is designed to be the parent of classes that contain data shared between controller modules
oCCoordinateFrameEvery input, state, and output in a DynamicalSystem has a coordinate frame attached to it
oCCubicPostureErrorApproximate 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.nT-1)] = % velocity_mat[q(:,1);q(:,2);;q(:,obj.nT)]+velocity_mat_qd0*qdot(:,1)+velocity_mat_qdf*qdot(:,obj.nT) %
oCDesiredQuatDiffGiven a quaternion quat, and the desired quaternion quat_des, compute the geodesic distance between those two quaternions as 2(quat'*quat_des)^2-1
oCDifferenceDrakeFunction representing the first difference between a series of points:
oCDircolTrajectoryOptimizationDirect 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)
oCDirectTrajectoryOptimizationDIRECTTRAJECTORYOPTIMIZATION An abstract class for direct method approaches to trajectory optimization
oCDirtranTrajectoryOptimizationDirect transcription trajectory optimization implements multiple possible integration schemes for the dynamics constraints xdot = f(x,u) and for for integrating the running cost term
oCDrakeConstraintMexPointerThis would be used to determine if a mex pointer refers to a RigidBodyConstraint object
oCDrakeFunctionDrakeFunction.DrakeFunction Abstract parent class for all DrakeFunction classes A DrakeFunction represents a vector-valued function of a single vector input
oCDrakeMexPointerMy attempt to clean-up the mex-matlab sharing pointer interface
oCDrakeSystemA DynamicalSystem with the functionality (dynamics, update, outputs, etc) implemented in matlab, so that it is amenable to, for instance, symbolic manipulations
oCDrakeSystemWGaussianNoiseThis is a wrapper class which adds Gaussian process and measurement noise to an existing DrakeSystem
oCDynamicalSystemAn interface class for a state-space 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
oCEulerConstraintConstraint the roll, pitch, yaw angles (in intrinsic z-y'-x'' order) to be within the bounding box [lb ub];
oCExpPlusPPTrajectoryUseful for solutions to linear systems driven by pptrajectory inputs in interval j, we have y(t) = K * exp(A*(t-tj)) * alpha(:,j) + sum_i gamma(:,j,i) (t-tj)^i
oCFootstepA data structure for a single footstep position
oCFootstepPlanA container for footstep plans
oCFrictionConeThe nonlinear friction cone defined by unit cone axis cone_axis and friction coefficient mu_face
oCFrictionConeWrenchConstrain the friction force to be within a friction cone
oCFunctionHandleConstraintFUNCTIONHANDLECONSTRAINT A Constraint implementation where the constraint is given by a function handle
oCFunctionHandleObjectiveThe Drake optimization classes treat objectives as constraints
oCFunctionHandleVisualizerVisualizer class where the draw methods is provided by a function handle
oCFunctionWrapperFUNCTIONWRAPPER A simple class to wrap a function handle
oCGraspedCylinderThe 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
oCGraspFrictionConeWrenchWhen 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
oCGraspWrenchA force and a torque can be applied at a single contact point
oCGravityCompensationTorqueConstraintConstraint on the torque required to keep specified joints static in the face of gravity
oCHybridDrakeSystemSome restrictions on the mode systems: must be CT only
oCHybridRigidBodyModeSimple 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
oCHybridTrajectoryContainer class for a set of continuous trajectories punctuated by collision events
oCIdentityDrakeFunction representing the identity transform in a given frame
oCIKPDBlockOutputs a desired q_ddot (including floating dofs)
oCInstantaneousQPControllerA QP-based balancing and walking controller that exploits TV-LQR solutions for (time-varing) linear COM/ZMP dynamics
oCInverseKinematicsSolve the inverse kinematics problem min_q 0.5*(q-qnom)'Q(q-qnom)+cost1(q)+cost2(q)+ % s.t lb<= kc(q) <=ub q_lb<= q <=q_ub where cost1, cost2 are functions defined by user
oCInverseKinematicsTrajectorySolve 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)] %
oCKinematicAbstract parent class for kinematic functions All children of this class take the joint-angles of a specific RigidBodyManipulator as their input
oCKinematicDirtranTrajectory planning problem in which the acceleration of the joints is taken to be directly controllable
oCKinematicTrajectoryOptimizationAbstract class for kinematic planning
oCLCMCoderAn LCM coder translates an LCM type into a vector of doubles used in Drake
oCLCMCoderFromTypeNote: might be better (faster) to move this to java
oCLCMPublisherDefines an interface for an object that can publish a double on an LCM channel
oCLCMSignalCoderHandle the lcmt_drake_signal type
oCLCMSubscriberDefines an interface for LCM objects that get wrapped up in matlab vectors
oCLeggedRobotInterface class for legged robots
oCLeggedRobotPlanningProblemFactory class for motion planning problems involving robots that implement the 'LeggedRobot' interface
oCLinearDrakeFunction of the form:
oCLinearCombinationDrakeFunction which given n points in the same frame, as well as n weights, returns the linear combination of those points with those weights
oCLinearComplementarityConstraintLinearComplementarityConstraint 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
oCLinearConstraintLinear Constraint
oCLinearFrictionConeWrenchConstrain 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
oCLinearizedFrictionConeThe linearized friction cone defined by friction cone edges
oCLuenbergerObserverA potentially nonlinear observer with linear (possibly time-varying) 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*}
oCLyapunovFunctionInterface class for Lyapunov functions
oCManipulatorAn abstract class that wraps H(q)vdot + C(q,v,f_ext) = B(q)u
oCMarkovDecisionProcessImplements a model-based (transition probabilities are known) finite-state, finite-action, discrete time markov decision process
oCMarkovDecisionProcessPolicyTakes a probability distribution over discrete states in and outputs the expected action
oCMIMODrakeSystemFor 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
oCMinDistanceConstraintConstrains the closest distance between all bodies to be greater than min_distance
oCMixedIntegerConvexProgramThis class is meant to represent general mixed-integer linear, quadratic, quadratically-constrained, and second-order-cone programs
oCMixedIntegerFootstepPlanningProblemA general structure for various footstep planning approaches
oCMixedTrajectoryCreates a trajectory that concatenates dynamics
oCMotionPlanningProblemDefines a feasible motion planning problem using Constraint class objects
oCMultiCoordinateFrameMakes a mux'd coordinate frame out of a list of other frames
oCMultipleTimeKinematicConstraintA abstract class, that its eval function takes multiple time points as the input, instead of being evluated at a single time
oCMultipleTimeLinearPostureConstraintA linear constraint on the robot posture for multiple times
oCMultiVisualizerStack a bunch of visualizers together so that they draw at the same time
oCNonlinearComplementarityConstraintNonlinearComplementarityConstraint A constraint of the form z >= 0, f(x,z) >= 0, <z,f(x,z)> = 0
oCNonlinearProgramMinimize_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
oCNormSquaredDrakeFunction representing the square of the Euclidean norm (or weighted Euclidean norm) for points in a given frame
oCNullConstraintThis constraint does nothing, but having it is easier that handling the possibility of empty matrices in lists of constraints
oCNullVisualizerVisualizer that doesn't visualize (helpful for simulink simulation)
oCObserverAn interface class that sets up a system as an observer, or state-estimator, for an existing system
oCObserverErrorSystemThe 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
oCOcTreeWrapper class for octomap library octree functionality
oCOcTreeSystemBuilds 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
oCOptimalTaskSpaceMotionPlanningTreeSubclass of motion planning tree that override and add functions to be used with asymptotically optimal versions of RRT algorithms
oCPassByValueMapThis class provides a pass-by-value version of the containers.Map class
oCPlanarRigidBodyManipulatorThis 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
oCPlanarRigidBodyVisualizerLoads a URDF file and implements the draw function
oCPlanEvalA PlanEval represents one half of a complete control system
oCPoint2DVisualizerAdds a point to an existing 2D scene
oCPoint2LineSegDistConstraintThis constrain the distance between a point on a body to a line segment is within a range
oCPoint2PointDistanceConstraintConstrain the distance between ptA(:,i) on body A to ptB(:,i) on body B to be within the range of [lb(i) ub(i)]
oCPolyhedronNoCollisionSearch for separating hyperplane c'x+d between two polyhedron to avoid contact
oCPolynomialSystemA dynamical system described by rational polynomial dynamics, and polynomial outputs
oCPolynomialTrajectoryLike a trajectory object, but it returns an msspoly for each t (via function handles)
oCPolynomialTrajectorySystemDynamics, update, output are polynomial in x and u, but not necessarily polynomial in t
oCPolynomialWTimeVaryingCoefficientsDefines a polynomial (represented by an msspoly) with time-varying coefficients (represented as a trajectory)
oCPolytopicSystemDefines a piecewise smooth system with piecewise segments defined on a polytope
oCPolyToTrigTransformFor trig-poly 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
oCPostureChangeConstraintThis constrains that the change of joint i within time tspan must be within [lb,ub]
oCPostureConstraintA bounding box constraint on robot posture
oCPostureErrorPenalize the cost sum_i (q(:,i)-q_nom(:,i))'Q(q(:,i)-q_nom(:,i))
oCPPRateTransitionPIECEWISE-POLYNOMIAL RATE TRANSITION SYSTEM Some systems, such as a trajectory planner running as a model-predictive controller, run at low sample rates, but think enough about the future to be able to produce continuous outputs
oCPseudoSpectralMethodTrajOptPseudospectral (PS) method for trajectory optimization
oCQPControllerA QP-based balancing and walking controller that exploits TV-LQR solutions for (time-varing) linear COM/ZMP dynamics
oCQPControllerDataClass that contains data needed by the QPController and cascaded modules
oCQTrajEvalBlockPasses through the robot state and reads evals qtraj at the current t
oCQuadraticConstraintQuadratic constraint of the form lb <= .5 * x'*Q*x + b'*x <= ub
oCQuadraticLyapunovFunctionX'*S*x + x'*s1 + s2 S,s1,s2 can be doubles or trajectories (yielding a time-varying quadratic)
oCQuadraticProgramProvides a common interface to the wealth of QP solvers that we have kicking around
oCQuadraticSumConstraintLb <= sum_i (x(:,i)-v(:,i))'Qa(x(:,i)-v(:,i)) <= ub
oCQuasiStaticConstraintConstrain the Center of Mass to lie inside the shrunk support polygon
oCQuatConstraintConstrain the quaternion to satisfy the following conditions: 2*(quat'*quat_des)^2-1 in [cos(tol) 1]
oCRelativeFixedPositionConstraintConstrain the position of point body_pts_A on body_A to be fixed in a given body body_B
oCRelativeGazeDirConstraintThis constrains that an axis on body A is aligned with a direction on body B to within a given threshold
oCRelativeGazeTargetConstraintThis constrains that a camera on body_a can gaze at a point on body_b
oCRelativePositionPosition of points in frame A relative to frame B
oCRelativePositionConstraintConstraining points in body A to be within a bounding box in B' frame on body B
oCRelativeQuatConstraintConstrains the orientation of the body reference frame of link A relative to the frame of Body B
oCRelativeQuaternionQuaternion from frame A to frame B
oCRigidBodyActuatorTrivial definition of the actuators allows us to define the mapping from input to joint torques
oCRigidBodyBluffBodyElement that provides an aerodynamic drag force at a point
oCRigidBodyContactWrenchConstrain the contact forces
oCRigidBodyDepthSensorUses collision detection framework to simulate a depth camera rangefinder
oCRigidBodyDepthSensorMeasurementsToOcTreeDynamical system which takes in depth sensor points and a state estimate, and writes those points to an octree
oCRigidBodyElementHandles lazy binding of urdf parameters to rigid body element values
oCRigidBodyFlatTerrainThis class provides an implementation of RigidBodyTerrain with z=0 everywhere
oCRigidBodyFlatTerrainNoGeometryThis class provides an implementation of RigidBodyTerrain with z=0 everywhere
oCRigidBodyFrameA number of RigidBodyElements (e.g
oCRigidBodyInertialMeasurementUnitOutputs angular orientation, angular velocity, and linear acceleration
oCRigidBodyJointSensorOutputs a (vector of) joint positions, given a mask specifying which DOF to include
oCRigidBodyManipulatorThis class wraps the spatial vector library (v1) provided by Roy Featherstone on his website: http://users.cecs.anu.edu.au/~roy/spatial/documentation.html
oCRigidBodyManipulatorFunctionAbstract parent class for functions that need to store a RigidBodyManipulator
oCRigidBodyMeshPointsRigidBodyMeshPoints 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
oCRigidBodySensorThis is an interface class for sensors that are composed to form the output output of a RigidBodyManipulator
oCRigidBodySupportStateRigidBodySupportState defines a set of supporting bodies and contacts for a rigid body manipulator
oCRigidBodyTerrainBasic interface class for terrain
oCRigidBodyTorsionalSpringAdds torsionals linear springs, with torque = k*(rest_angle - current_angle), to rigid body manipulators
oCRigidBodyWingThis 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
oCRigidBodyWingWithControlSurfaceImplements functionality similar to RigidBodyWing but with a control surface attached to the wing
oCRigidBodyWRLVisualizerLoads a URDF file and implements the draw function
oCRobustDrakeSystemInterface a nonlinear stochastic discrete/continuous system with (band-limited) white noise input
oCScopeSystemA simple system that will pass the input through to the output, but publish it to the lcmscope on the way
oCScopeVisualizerSimple utility to plot one particular index of a coordinate frame
oCSecondOrderSystemAn abstract class that wraps qddot = f(t,q,qdot,u)
oCSharedDataHandleUtility 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
oCSignedDistanceToHyperplaneDrakeFunction representing the distance from a point to a hyperplane
oCSimulationControlBlockThis block provides an easy way to halt your running simulation gently (i.e
oCSimulinkModelImplements the DynamicalSystem interface for any existing simulink model with one (vector) input and one (vector) output
oCSimulinkModelHandleUtility 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
oCSingleBodyDynamicsFullKinematicsPlannerOnly compute the centroidal dynamics on the object being grasped
oCSingleTimeKinematicConstraintAn abstract class
oCSingleTimeLinearPostureConstraintA linear constraint on the robot posture for a single time lb<=sparse(iAfun,jAvar,A,max(jAvar),robot.nq)*q<=ub
oCSingletonImplements a singleton design pattern
oCSmoothDistancePenaltyDrakeFunction penalizing all distances less than a given minimum between bodies of a RigidBodyManipulator
oCSmoothNormDrakeFunction representing the smooth norm of a vector:
oCSpotPolynomialConstraintPolynomial constraint of the form lb <= p(x) <= ub, where p is stored as an msspoly column vector
oCStereographicPolyEffectively overloads msspoly with trig functions which are implemented using the stereographic projection
oCStochasticDrakeSystemInterface a nonlinear stochastic discrete/continuous system with (band-limited) white noise input
oCSumSum of N vectors of size M
oCSWFWriterImplements export to Adobe SWF (vectorized movie graphics)
oCTaylorVarDoes inline autodiff overloads operators: http://www.mathworks.com/help/techdoc/matlab_oop/br02znk-1.html
oCTimeSteppingRigidBodyManipulatorA 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
oCTimeSteppingRigidBodySensorAnalogous to RigidBodySensor, but for TimeStepping manipulators
oCTimeSteppingRigidBodySensorWithStateSensors that have internal dynamics we want to model, or sensors that need to be prevented from being direct feedthrough
oCTransversalSurfaceTransversal surfaces for orbital stabilization irm@m.nosp@m.it.e.nosp@m.du
oCTransverseLinearControlOrbital stabilization via the transverse linearization
oCTrigPolySupport class for parsing functions into their polynomial and trigonemetric components
oCTrigToPolyTransformFor trig-poly 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
oCVertexArrayMotionPlanningTreePartial implementation of MotionPlanningTree that uses the "checkConstraints" functionality of MotionPlanningProblem and stores the vertices of the tree in a num_vars-by-n array
oCVisualizerAn interface class which draws (e.g., produces a plot) the output of another dynamical system
oCVisualizerWithObstaclesVisualizer that also draws obstacles
oCWarningManagerCarry this object around (e.g
oCWorldEulerConstraintConstraint the roll, pitch, yaw angles (in intrinsic z-y'-x'' order) to be within the bounding box [lb ub];
oCWorldFixedBodyPoseConstraintConstrain the posture (position and orientation) of a body to be fixed within a time interval
oCWorldFixedOrientConstraintConstrain a certain body to be in a fixed orientation for a time interval
oCWorldFixedPositionConstraintConstraint some points on a certain body to be in a fixed position for a time interval
oCWorldQuatConstraintConstrain the body satisfies 2*(quat'*quat_des)^2-1 in [cos(tol), 1];
\CZerosDrakeFunction representing the zero-transformation from one CoordinateFrame to another