DART  6.10.1
dart::dynamics Namespace Reference

Namespaces

 detail
 

Classes

class  ArrowShape
 
class  AssimpInputResourceRetrieverAdaptor
 
class  AssimpInputResourceAdaptor
 
class  BallJoint
 class BallJoint More...
 
class  BodyNode
 BodyNode class represents a single node of the skeleton. More...
 
class  BoxShape
 
class  Branch
 Branch is a specialized type of Linkage that represents a complete subtree of a Skeleton. More...
 
class  CapsuleShape
 CapsuleShape represents a three-dimensional geometric shape consisting of a cylinder with hemispherical ends. More...
 
class  Chain
 Chain is a specialized type of Linkage that represents a single unbranching and fully connected sequence of BodyNodes. More...
 
class  CompositeStateNode
 
class  CompositePropertiesNode
 
class  CompositeNode
 
class  ConeShape
 ConeShape represents a three-dimensional geometric shape that tapers smoothly from a flat circular base to a point called the apex or vertex. More...
 
class  CylinderShape
 
class  DegreeOfFreedom
 DegreeOfFreedom class is a proxy class for accessing single degrees of freedom (aka generalized coordinates) of the Skeleton. More...
 
struct  MutexedWeakSkeletonPtr
 
class  SkeletonRefCountingBase
 
class  TemplateBodyNodePtr
 TemplateBodyNodePtr is a templated class that enables users to create a reference-counting BodyNodePtr. More...
 
class  TemplateWeakBodyNodePtr
 TemplateWeakBodyNodePtr is a templated class that enables users to create a non-reference-holding WeakBodyNodePtr. More...
 
class  TemplateDegreeOfFreedomPtr
 TemplateDegreeOfFreedomPtr is a templated class that enables users to create a reference-counting DegreeOfFreedomPtr. More...
 
class  TemplateWeakDegreeOfFreedomPtr
 TemplateWeakDegreeOfFreedomPtr is a templated class that enables users to create a non-reference-holding WeakDegreeOfFreedomPtr. More...
 
class  EntityNode
 
class  GenericJoint
 
class  TemplateInverseKinematicsPtr
 TemplateInverseKinematicsPtr is a templated class that enables users to create a reference-counting InverseKinematicsPtr. More...
 
class  TemplateWeakInverseKinematicsPtr
 TemplateWeakInverseKinematicsPtr is a templated class that enables users to create a non-reference-holding WeakInverseKinematicsPtr. More...
 
class  TemplateJointPtr
 TemplateJointPtr is a templated class that enables users to create a strong reference-counting JointPtr. More...
 
class  TemplateWeakJointPtr
 TemplateWeakJointPtr is a templated class that enables users to create a non-reference-holding WeakJointPtr. More...
 
class  TemplateNodePtr
 TemplateNodePtr is a templated class that enables users to create a strong reference-counting NodePtr. More...
 
class  TemplateWeakNodePtr
 TemplateWeakNodePtr is a templated class that enables users to create a weak non-reference-holding WeakNodePtr. More...
 
class  EllipsoidShape
 
class  Support
 
class  EndEffector
 
class  Entity
 Entity class is a base class for any objects that exist in the kinematic tree structure of DART. More...
 
class  Detachable
 The Detachable class is a special case of the Entity base class. More...
 
class  EulerJoint
 class EulerJoint More...
 
class  FixedFrame
 The FixedFrame class represents a Frame with zero relative velocity and zero relative acceleration. More...
 
class  FixedJacobianNode
 
class  Frame
 The Frame class serves as the backbone of DART's kinematic tree structure. More...
 
class  WorldFrame
 The WorldFrame class is a class that is used internally to create the singleton World Frame. More...
 
class  FreeJoint
 class FreeJoint More...
 
class  Group
 
class  HeightmapShape
 Shape for a height map. More...
 
class  HierarchicalIK
 The HierarchicalIK class provides a convenient way of setting up a hierarchical inverse kinematics optimization problem which combines several InverseKinematics problems into one. More...
 
class  CompositeIK
 The CompositeIK class allows you to specify an arbitrary hierarchy of InverseKinematics modules for a single Skeleton. More...
 
class  WholeBodyIK
 The WholeBodyIK class provides an interface for simultaneously solving all the IK constraints of all BodyNodes and EndEffectors belonging to a single Skeleton. More...
 
class  IkFast
 A base class for IkFast-based analytical inverse kinematics classes. More...
 
class  Inertia
 
class  InverseKinematics
 The InverseKinematics class provides a convenient way of setting up an IK optimization problem. More...
 
class  JacobianNode
 The JacobianNode class serves as a common interface for BodyNodes and EndEffectors to both be used as references for IK modules. More...
 
class  Joint
 class Joint More...
 
class  LineSegmentShape
 The LineSegmentShape facilitates creating graphs of line segments. More...
 
struct  Recording
 
class  Linkage
 A Linkage is a ReferentialSkeleton with the special property that all the BodyNodes included in it form a contiguous graph. More...
 
class  Marker
 
class  MeshShape
 
class  MetaSkeleton
 MetaSkeleton is a pure abstract base class that provides a common interface for obtaining data (such as Jacobians and Mass Matrices) from groups of BodyNodes. More...
 
class  MultiSphereConvexHullShape
 MultiSphereConvexHullShape represents the convex hull of a collection of spheres. More...
 
class  NodeDestructor
 
class  Node
 The Node class is a base class for BodyNode and any object that attaches to a BodyNode. More...
 
class  AccessoryNode
 AccessoryNode provides an interface for Nodes to get their index within the list of Nodes, as well as detach and reattach. More...
 
class  NodeManagerJoinerForBodyNode
 Declaration of the variadic template. More...
 
class  NodeManagerJoinerForBodyNode< Base1 >
 Special case of only having 1 class: we do nothing but inherit it. More...
 
class  NodeManagerJoinerForBodyNode< Base1, Base2 >
 NodeManagerJoiner allows classes that inherit from various SpecializedNodeManager types to be inherited by a single derived class. More...
 
class  NodeManagerJoinerForBodyNode< Base1, Base2, OtherBases... >
 This is the variadic version of the NodeManagerJoinerForBodyNode class which allows you to include arbitrarily many base classes in the joining. More...
 
class  NodeManagerJoinerForSkeleton
 Declaration of variadic template. More...
 
class  NodeManagerJoinerForSkeleton< Base1 >
 Special case of only having 1 class: we do nothing but inherit it. More...
 
class  NodeManagerJoinerForSkeleton< Base1, Base2 >
 
class  NodeManagerJoinerForSkeleton< Base1, Base2, OtherBases... >
 This is the variadic version of the NodeManagerJoinerForSkeleton class which allows you to include arbitrarily many base classes in the joining. More...
 
class  PlanarJoint
 PlanarJoint represents a 3-dof joint, which has two orthogonal translational axes and one rotational axis. More...
 
class  PlaneShape
 PlaneShape represents infinite plane has normal and offset as properties. More...
 
class  PointCloudShape
 The PointCloudShape represents point cloud data. More...
 
class  PointMass
 
class  PointMassNotifier
 
class  PrismaticJoint
 class RevoluteJoint More...
 
class  PyramidShape
 PyramidShape represents a polyhedron formed by connecting a rectangular base and a point (apex) where each base edge and apex form a triangle. More...
 
class  ReferentialSkeleton
 ReferentialSkeleton is a base class used to implement Linkage, Group, and other classes that are used to reference subsections of Skeletons. More...
 
class  RevoluteJoint
 class RevoluteJoint More...
 
class  ScrewJoint
 class ScrewJoint More...
 
class  Shape
 
class  VisualAspect
 
class  CollisionAspect
 
class  DynamicsAspect
 
class  ShapeFrame
 
class  ShapeNode
 
class  SharedLibraryIkFast
 IkFast-based analytical inverse kinematics class. More...
 
class  SimpleFrame
 The SimpleFrame class offers a user-friendly way of creating arbitrary Frames within the kinematic tree structure of DART. More...
 
class  Skeleton
 class Skeleton More...
 
class  SoftBodyNode
 SoftBodyNode represent a soft body that has one deformable skin. More...
 
class  SoftBodyNodeHelper
 
class  SoftMeshShape
 
class  BodyNodeSpecializedFor
 Declaration of the variadic template. More...
 
class  BodyNodeSpecializedFor< SpecNode >
 BodyNodeSpecializedFor allows classes that inherit BodyNode to have constant-time access to a specific type of Node. More...
 
class  BodyNodeSpecializedFor< SpecNode1, OtherSpecNodes... >
 This is the variadic version of the BodyNodeSpecializedFor class which allows you to include arbitrarily many specialized types in the specialization. More...
 
class  SkeletonSpecializedFor
 Declaration of the variadic template. More...
 
class  SkeletonSpecializedFor< SpecNode >
 SkeletonSpecializedForNode allows classes that inherit Skeleton to have constant-time access to a specific type of Node. More...
 
class  SkeletonSpecializedFor< SpecNode1, OtherSpecNodes... >
 This is the variadic version of the SkeletonSpecializedForNode class which allows you to include arbitrarily many specialized types in the specialization. More...
 
class  SphereShape
 
class  TemplatedJacobianNode
 TemplatedJacobianNode provides a curiously recurring template pattern implementation of the various JacobianNode non-caching functions. More...
 
class  TranslationalJoint
 class TranslationalJoint More...
 
class  TranslationalJoint2D
 TranslationalJoint2D represents a 2-dof joint, which has two orthogonal translational axes. More...
 
class  UniversalJoint
 class UniversalJoint More...
 
class  WeldJoint
 class WeldJoint More...
 
class  ZeroDofJoint
 class ZeroDofJoint More...
 

Typedefs

typedef std::set< Entity * > EntityPtrSet
 
typedef std::set< Frame * > FramePtrSet
 
using HeightmapShapef = HeightmapShape< float >
 
using HeightmapShaped = HeightmapShape< double >
 
typedef std::vector< std::vector< std::shared_ptr< InverseKinematics > > > IKHierarchy
 An IKHierarchy is a sorted set of IK modules. More...
 
typedef InverseKinematics IK
 
typedef MultiSphereConvexHullShape MultiSphereShape
 
using ShapeFramePtr = std::shared_ptr< ShapeFrame >
 
using ConstShapeFramePtr = std::shared_ptr< const ShapeFrame >
 
using WeakShapeFramePtr = std::weak_ptr< ShapeFrame >
 
using WeakConstShapeFramePtr = std::weak_ptr< const ShapeFrame >
 
using SimpleFramePtr = std::shared_ptr< SimpleFrame >
 
using ConstSimpleFramePtr = std::shared_ptr< const SimpleFrame >
 
using WeakSimpleFramePtr = std::weak_ptr< SimpleFrame >
 
using WeakConstSimpleFramePtr = std::weak_ptr< const SimpleFrame >
 
using NodeDestructorPtr = std::shared_ptr< NodeDestructor >
 
using ConstNodeDestructorPtr = std::shared_ptr< const NodeDestructor >
 
using WeakNodeDestructorPtr = std::weak_ptr< NodeDestructor >
 
using WeakConstNodeDestructorPtr = std::weak_ptr< const NodeDestructor >
 
using SkeletonPtr = std::shared_ptr< Skeleton >
 
using ConstSkeletonPtr = std::shared_ptr< const Skeleton >
 
using WeakSkeletonPtr = std::weak_ptr< Skeleton >
 
using WeakConstSkeletonPtr = std::weak_ptr< const Skeleton >
 
using MetaSkeletonPtr = std::shared_ptr< MetaSkeleton >
 
using ConstMetaSkeletonPtr = std::shared_ptr< const MetaSkeleton >
 
using WeakMetaSkeletonPtr = std::weak_ptr< MetaSkeleton >
 
using WeakConstMetaSkeletonPtr = std::weak_ptr< const MetaSkeleton >
 
using ReferentialSkeletonPtr = std::shared_ptr< ReferentialSkeleton >
 
using ConstReferentialSkeletonPtr = std::shared_ptr< const ReferentialSkeleton >
 
using WeakReferentialSkeletonPtr = std::weak_ptr< ReferentialSkeleton >
 
using WeakConstReferentialSkeletonPtr = std::weak_ptr< const ReferentialSkeleton >
 
using GroupPtr = std::shared_ptr< Group >
 
using ConstGroupPtr = std::shared_ptr< const Group >
 
using WeakGroupPtr = std::weak_ptr< Group >
 
using WeakConstGroupPtr = std::weak_ptr< const Group >
 
using LinkagePtr = std::shared_ptr< Linkage >
 
using ConstLinkagePtr = std::shared_ptr< const Linkage >
 
using WeakLinkagePtr = std::weak_ptr< Linkage >
 
using WeakConstLinkagePtr = std::weak_ptr< const Linkage >
 
using BranchPtr = std::shared_ptr< Branch >
 
using ConstBranchPtr = std::shared_ptr< const Branch >
 
using WeakBranchPtr = std::weak_ptr< Branch >
 
using WeakConstBranchPtr = std::weak_ptr< const Branch >
 
using ChainPtr = std::shared_ptr< Chain >
 
using ConstChainPtr = std::shared_ptr< const Chain >
 
using WeakChainPtr = std::weak_ptr< Chain >
 
using WeakConstChainPtr = std::weak_ptr< const Chain >
 
using ShapePtr = std::shared_ptr< Shape >
 
using ConstShapePtr = std::shared_ptr< const Shape >
 
using WeakShapePtr = std::weak_ptr< Shape >
 
using WeakConstShapePtr = std::weak_ptr< const Shape >
 
using ArrowShapePtr = std::shared_ptr< ArrowShape >
 
using ConstArrowShapePtr = std::shared_ptr< const ArrowShape >
 
using WeakArrowShapePtr = std::weak_ptr< ArrowShape >
 
using WeakConstArrowShapePtr = std::weak_ptr< const ArrowShape >
 
using BoxShapePtr = std::shared_ptr< BoxShape >
 
using ConstBoxShapePtr = std::shared_ptr< const BoxShape >
 
using WeakBoxShapePtr = std::weak_ptr< BoxShape >
 
using WeakConstBoxShapePtr = std::weak_ptr< const BoxShape >
 
using CylinderShapePtr = std::shared_ptr< CylinderShape >
 
using ConstCylinderShapePtr = std::shared_ptr< const CylinderShape >
 
using WeakCylinderShapePtr = std::weak_ptr< CylinderShape >
 
using WeakConstCylinderShapePtr = std::weak_ptr< const CylinderShape >
 
using EllipsoidShapePtr = std::shared_ptr< EllipsoidShape >
 
using ConstEllipsoidShapePtr = std::shared_ptr< const EllipsoidShape >
 
using WeakEllipsoidShapePtr = std::weak_ptr< EllipsoidShape >
 
using WeakConstEllipsoidShapePtr = std::weak_ptr< const EllipsoidShape >
 
using LineSegmentShapePtr = std::shared_ptr< LineSegmentShape >
 
using ConstLineSegmentShapePtr = std::shared_ptr< const LineSegmentShape >
 
using WeakLineSegmentShapePtr = std::weak_ptr< LineSegmentShape >
 
using WeakConstLineSegmentShapePtr = std::weak_ptr< const LineSegmentShape >
 
using MeshShapePtr = std::shared_ptr< MeshShape >
 
using ConstMeshShapePtr = std::shared_ptr< const MeshShape >
 
using WeakMeshShapePtr = std::weak_ptr< MeshShape >
 
using WeakConstMeshShapePtr = std::weak_ptr< const MeshShape >
 
using PlaneShapePtr = std::shared_ptr< PlaneShape >
 
using ConstPlaneShapePtr = std::shared_ptr< const PlaneShape >
 
using WeakPlaneShapePtr = std::weak_ptr< PlaneShape >
 
using WeakConstPlaneShapePtr = std::weak_ptr< const PlaneShape >
 
using SoftMeshShapePtr = std::shared_ptr< SoftMeshShape >
 
using ConstSoftMeshShapePtr = std::shared_ptr< const SoftMeshShape >
 
using WeakSoftMeshShapePtr = std::weak_ptr< SoftMeshShape >
 
using WeakConstSoftMeshShapePtr = std::weak_ptr< const SoftMeshShape >
 
using BodyNodePtr = TemplateBodyNodePtr< BodyNode >
 
using ConstBodyNodePtr = TemplateBodyNodePtr< const BodyNode >
 
using WeakBodyNodePtr = TemplateWeakBodyNodePtr< BodyNode >
 
using WeakConstBodyNodePtr = TemplateWeakBodyNodePtr< const BodyNode >
 
using SoftBodyNodePtr = TemplateBodyNodePtr< SoftBodyNode >
 
using ConstSoftBodyNodePtr = TemplateBodyNodePtr< const SoftBodyNode >
 
using WeakSoftBodyNodePtr = TemplateWeakBodyNodePtr< SoftBodyNode >
 
using WeakConstSoftBodyNodePtr = TemplateWeakBodyNodePtr< const SoftBodyNode >
 
using JointPtr = TemplateJointPtr< Joint, BodyNode >
 
using ConstJointPtr = TemplateJointPtr< const Joint, const BodyNode >
 
using WeakJointPtr = TemplateWeakJointPtr< Joint, BodyNode >
 
using WeakConstJointPtr = TemplateWeakJointPtr< const Joint, const BodyNode >
 
using DegreeOfFreedomPtr = TemplateDegreeOfFreedomPtr< DegreeOfFreedom, BodyNode >
 
using ConstDegreeOfFreedomPtr = TemplateDegreeOfFreedomPtr< const DegreeOfFreedom, const BodyNode >
 
using WeakDegreeOfFreedomPtr = TemplateWeakDegreeOfFreedomPtr< DegreeOfFreedom, BodyNode >
 
using WeakConstDegreeOfFreedomPtr = TemplateWeakDegreeOfFreedomPtr< const DegreeOfFreedom, const BodyNode >
 
using NodePtr = TemplateNodePtr< Node, BodyNode >
 
using ConstNodePtr = TemplateNodePtr< const Node, const BodyNode >
 
using WeakNodePtr = TemplateWeakNodePtr< Node, BodyNode >
 
using WeakConstNodePtr = TemplateWeakNodePtr< const Node, const BodyNode >
 
using JacobianNodePtr = TemplateNodePtr< JacobianNode, BodyNode >
 
using ConstJacobianNodePtr = TemplateNodePtr< const JacobianNode, const BodyNode >
 
using WeakJacobianNodePtr = TemplateWeakNodePtr< JacobianNode, BodyNode >
 
using WeakConstJacobianNodePtr = TemplateWeakNodePtr< const JacobianNode, const BodyNode >
 
using EndEffectorPtr = TemplateNodePtr< EndEffector, BodyNode >
 
using ConstEndEffectorPtr = TemplateNodePtr< const EndEffector, const BodyNode >
 
using WeakEndEffectorPtr = TemplateWeakNodePtr< EndEffector, BodyNode >
 
using WeakConstEndEffectorPtr = TemplateWeakNodePtr< const EndEffector, const BodyNode >
 
using ShapeNodePtr = TemplateNodePtr< ShapeNode, BodyNode >
 
using ConstShapeNodePtr = TemplateNodePtr< const ShapeNode, const BodyNode >
 
using WeakShapeNodePtr = TemplateWeakNodePtr< ShapeNode, BodyNode >
 
using WeakConstShapeNodePtr = TemplateWeakNodePtr< const ShapeNode, const BodyNode >
 
using InverseKinematicsPtr = TemplateInverseKinematicsPtr< InverseKinematics, JacobianNodePtr >
 
using ConstInverseKinematicsPtr = TemplateInverseKinematicsPtr< const InverseKinematics, ConstJacobianNodePtr >
 
using WeakInverseKinematicsPtr = TemplateWeakInverseKinematicsPtr< InverseKinematics, JacobianNodePtr >
 
using WeakConstInverseKinematicsPtr = TemplateWeakInverseKinematicsPtr< const InverseKinematics, ConstJacobianNodePtr >
 

Functions

static void constructArrowTip (aiMesh *mesh, double base, double tip, const ArrowShape::Properties &properties)
 
static void constructArrowBody (aiMesh *mesh, double z1, double z2, const ArrowShape::Properties &properties)
 
aiFileIO createFileIO (Assimp::IOSystem *_system)
 
template<class DataType , std::unique_ptr< DataType >(Node::*)() const getData, typename VectorType = common::CloneableVector<std::unique_ptr<DataType> >, typename DataMap = std::map<std::type_index, std::unique_ptr<VectorType> >>
static void extractDataFromNodeTypeMap (DataMap &dataMap, const BodyNode::NodeMap &nodeMap)
 
template<class DataType , void(Node::*)(const DataType &) setData, typename VectorType = common::CloneableVector<std::unique_ptr<DataType> >, typename DataMap = std::map<std::type_index, std::unique_ptr<VectorType> >>
static void setNodesFromDataTypeMap (BodyNode::NodeMap &nodeMap, const DataMap &dataMap)
 
void checkMass (const BodyNode &bodyNode, const double mass)
 
static bool checkSkeletonNodeAgreement (const BodyNode *_bodyNode, const ConstSkeletonPtr &_newSkeleton, const BodyNode *_newParent, const std::string &_function, const std::string &_operation)
 
template<class IkType , class BodyNodeT >
bool operator== (const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &_ik, std::nullptr_t)
 
template<class IkType , class BodyNodeT >
bool operator== (std::nullptr_t, const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &_ik)
 
template<class IkType , class BodyNodeT >
bool operator!= (const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &_ik, std::nullptr_t)
 
template<class IkType , class BodyNodeT >
bool operator!= (std::nullptr_t, const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &_ik)
 
template<typename T >
static std::set< const T * > convertToConstSet (const std::set< T * > &_set)
 
static std::shared_ptr< optimizer::FunctioncloneIkFunc (const std::shared_ptr< optimizer::Function > &_function, const std::shared_ptr< HierarchicalIK > &_ik)
 
bool wrapCyclicSolution (double curr, double lb, double ub, double &sol)
 Tries to wrap a single dof IK solution, from IKFast, in the range of joint limits. More...
 
static std::shared_ptr< optimizer::FunctioncloneIkFunc (const std::shared_ptr< optimizer::Function > &_function, InverseKinematics *_ik)
 
void stepToNextChild (std::vector< Recording > &_recorder, std::vector< BodyNode * > &_bns, Recording &_r, const std::unordered_map< BodyNode *, bool > &_terminalMap, int _initValue)
 
void stepToParent (std::vector< Recording > &_recorder, std::vector< BodyNode * > &_bns, Recording &_r, const std::unordered_map< BodyNode *, bool > &_terminalMap)
 
Linkage::Criteria::Target createTargetFromClone (Skeleton &skelClone, const Linkage::Criteria::Target &target)
 
Linkage::Criteria::Terminal createTerminalFromClone (Skeleton &skelClone, const Linkage::Criteria::Terminal &terminal)
 
static bool checkIndexArrayValidity (const MetaSkeleton *skel, const std::vector< std::size_t > &_indices, const std::string &_fname)
 
static bool checkIndexArrayAgreement (const MetaSkeleton *skel, const std::vector< std::size_t > &_indices, const Eigen::VectorXd &_values, const std::string &_fname, const std::string &_vname)
 
template<void(DegreeOfFreedom::*)(double _value) setValue>
static void setValuesFromVector (MetaSkeleton *skel, const std::vector< std::size_t > &_indices, const Eigen::VectorXd &_values, const std::string &_fname, const std::string &_vname)
 
template<void(DegreeOfFreedom::*)(double _value) setValue>
static void setAllValuesFromVector (MetaSkeleton *skel, const Eigen::VectorXd &_values, const std::string &_fname, const std::string &_vname)
 
template<double(DegreeOfFreedom::*)() const getValue>
static Eigen::VectorXd getValuesFromVector (const MetaSkeleton *skel, const std::vector< std::size_t > &_indices, const std::string &_fname)
 
template<double(DegreeOfFreedom::*)() const getValue>
static Eigen::VectorXd getValuesFromAllDofs (const MetaSkeleton *skel, const std::string &_fname)
 
template<void(DegreeOfFreedom::*)() apply>
static void applyToAllDofs (MetaSkeleton *skel)
 
template<void(DegreeOfFreedom::*)(double _value) setValue>
static void setValueFromIndex (MetaSkeleton *skel, std::size_t _index, double _value, const std::string &_fname)
 
template<double(DegreeOfFreedom::*)() const getValue>
static double getValueFromIndex (const MetaSkeleton *skel, std::size_t _index, const std::string &_fname)
 
template<class T1 , class T2 >
static std::vector< T2 > & convertVector (const std::vector< T1 > &t1_vec, std::vector< T2 > &t2_vec)
 
static bool isValidBodyNode (const ReferentialSkeleton *, const JacobianNode *_node, const std::string &_fname)
 
template<typename JacobianType >
void assignJacobian (JacobianType &_J, const ReferentialSkeleton *_refSkel, const JacobianNode *_node, const JacobianType &_JBodyNode)
 
template<typename... Args>
math::Jacobian variadicGetJacobian (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetWorldJacobian (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::LinearJacobian variadicGetLinearJacobian (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::AngularJacobian variadicGetAngularJacobian (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetJacobianSpatialDeriv (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetJacobianClassicDeriv (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::LinearJacobian variadicGetLinearJacobianDeriv (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::AngularJacobian variadicGetAngularJacobianDeriv (const ReferentialSkeleton *_refSkel, const JacobianNode *_node, Args... args)
 
template<const Eigen::MatrixXd &(Skeleton::*)(std::size_t) const getMatrix>
const Eigen::MatrixXd & setMatrixFromSkeletonData (Eigen::MatrixXd &M, const std::vector< const DegreeOfFreedom * > &dofs)
 
template<const Eigen::VectorXd &(Skeleton::*)(std::size_t) const getVector>
const Eigen::VectorXd & setVectorFromSkeletonData (Eigen::VectorXd &V, const std::vector< const DegreeOfFreedom * > &dofs)
 
template<typename PropertyType , PropertyType(BodyNode::*)(const Frame *, const Frame *) const getProperty>
PropertyType getCOMPropertyTemplate (const ReferentialSkeleton *_refSkel, const Frame *_relativeTo, const Frame *_inCoordinatesOf)
 
template<typename JacType , JacType(TemplatedJacobianNode< BodyNode >::*)(const Eigen::Vector3d &, const Frame *) const getJacFn>
JacType getCOMJacobianTemplate (const ReferentialSkeleton *_refSkel, const Frame *_inCoordinatesOf)
 
template<class T >
static std::vector< const T * > & convertToConstPtrVector (const std::vector< T * > &vec, std::vector< const T * > &const_vec)
 
template<class ObjectT , std::size_t(ObjectT::*)() const getIndexInSkeleton>
static std::size_t templatedGetIndexOf (const Skeleton *_skel, const ObjectT *_obj, const std::string &_type, bool _warning)
 
static bool isValidBodyNode (const Skeleton *_skeleton, const JacobianNode *_node, const std::string &_fname)
 
template<typename JacobianType >
void assignJacobian (JacobianType &_J, const JacobianNode *_node, const JacobianType &_JBodyNode)
 
template<typename... Args>
math::Jacobian variadicGetJacobian (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetWorldJacobian (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::LinearJacobian variadicGetLinearJacobian (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::AngularJacobian variadicGetAngularJacobian (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetJacobianSpatialDeriv (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::Jacobian variadicGetJacobianClassicDeriv (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::LinearJacobian variadicGetLinearJacobianDeriv (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename... Args>
math::AngularJacobian variadicGetAngularJacobianDeriv (const Skeleton *_skel, const JacobianNode *_node, Args... args)
 
template<typename BodyNodeT >
static void recursiveConstructBodyNodeTree (std::vector< BodyNodeT * > &tree, BodyNodeT *_currentBodyNode)
 
static void computeSupportPolygon (const Skeleton *skel, math::SupportPolygon &polygon, math::SupportGeometry &geometry, std::vector< std::size_t > &ee_indices, Eigen::Vector3d &axis1, Eigen::Vector3d &axis2, Eigen::Vector2d &centroid, std::size_t treeIndex)
 
template<typename PropertyType , PropertyType(BodyNode::*)(const Frame *, const Frame *) const getPropertyFn>
PropertyType getCOMPropertyTemplate (const Skeleton *_skel, const Frame *_relativeTo, const Frame *_inCoordinatesOf)
 
template<typename JacType , JacType(TemplatedJacobianNode< BodyNode >::*)(const Eigen::Vector3d &, const Frame *) const getJacFn>
JacType getCOMJacobianTemplate (const Skeleton *_skel, const Frame *_inCoordinatesOf)
 

Variables

const double DART_DEFAULT_FRICTION_COEFF = 1.0
 
const double DART_DEFAULT_RESTITUTION_COEFF = 0.0
 
const double DART_DEFAULT_VERTEX_STIFFNESS = 1.0
 
const double DART_DEFAULT_EDGE_STIFNESS = 1.0
 
const double DART_DEFAULT_DAMPING_COEFF = 0.01
 
constexpr std::size_t INVALID_INDEX = static_cast<std::size_t>(-1)
 
const double DefaultIKTolerance = 1e-6
 
const double DefaultIKErrorClamp = 1.0
 
const double DefaultIKGradientComponentClamp = 0.2
 
const double DefaultIKGradientComponentWeight = 1.0
 
const double DefaultIKDLSCoefficient = 0.05
 
const double DefaultIKAngularWeight = 0.4
 
const double DefaultIKLinearWeight = 1.0
 

Typedef Documentation

◆ ArrowShapePtr

using dart::dynamics::ArrowShapePtr = typedef std::shared_ptr< ArrowShape >

◆ BodyNodePtr

◆ BoxShapePtr

using dart::dynamics::BoxShapePtr = typedef std::shared_ptr< BoxShape >

◆ BranchPtr

using dart::dynamics::BranchPtr = typedef std::shared_ptr< Branch >

◆ ChainPtr

using dart::dynamics::ChainPtr = typedef std::shared_ptr< Chain >

◆ ConstArrowShapePtr

using dart::dynamics::ConstArrowShapePtr = typedef std::shared_ptr<const ArrowShape >

◆ ConstBodyNodePtr

◆ ConstBoxShapePtr

using dart::dynamics::ConstBoxShapePtr = typedef std::shared_ptr<const BoxShape >

◆ ConstBranchPtr

using dart::dynamics::ConstBranchPtr = typedef std::shared_ptr<const Branch >

◆ ConstChainPtr

using dart::dynamics::ConstChainPtr = typedef std::shared_ptr<const Chain >

◆ ConstCylinderShapePtr

using dart::dynamics::ConstCylinderShapePtr = typedef std::shared_ptr<const CylinderShape >

◆ ConstDegreeOfFreedomPtr

◆ ConstEllipsoidShapePtr

using dart::dynamics::ConstEllipsoidShapePtr = typedef std::shared_ptr<const EllipsoidShape >

◆ ConstEndEffectorPtr

◆ ConstGroupPtr

using dart::dynamics::ConstGroupPtr = typedef std::shared_ptr<const Group >

◆ ConstInverseKinematicsPtr

◆ ConstJacobianNodePtr

◆ ConstJointPtr

◆ ConstLineSegmentShapePtr

using dart::dynamics::ConstLineSegmentShapePtr = typedef std::shared_ptr<const LineSegmentShape >

◆ ConstLinkagePtr

using dart::dynamics::ConstLinkagePtr = typedef std::shared_ptr<const Linkage >

◆ ConstMeshShapePtr

using dart::dynamics::ConstMeshShapePtr = typedef std::shared_ptr<const MeshShape >

◆ ConstMetaSkeletonPtr

using dart::dynamics::ConstMetaSkeletonPtr = typedef std::shared_ptr<const MetaSkeleton >

◆ ConstNodeDestructorPtr

using dart::dynamics::ConstNodeDestructorPtr = typedef std::shared_ptr<const NodeDestructor >

◆ ConstNodePtr

◆ ConstPlaneShapePtr

using dart::dynamics::ConstPlaneShapePtr = typedef std::shared_ptr<const PlaneShape >

◆ ConstReferentialSkeletonPtr

using dart::dynamics::ConstReferentialSkeletonPtr = typedef std::shared_ptr<const ReferentialSkeleton >

◆ ConstShapeFramePtr

using dart::dynamics::ConstShapeFramePtr = typedef std::shared_ptr<const ShapeFrame >

◆ ConstShapeNodePtr

◆ ConstShapePtr

using dart::dynamics::ConstShapePtr = typedef std::shared_ptr<const Shape >

◆ ConstSimpleFramePtr

using dart::dynamics::ConstSimpleFramePtr = typedef std::shared_ptr<const SimpleFrame >

◆ ConstSkeletonPtr

using dart::dynamics::ConstSkeletonPtr = typedef std::shared_ptr<const Skeleton >

◆ ConstSoftBodyNodePtr

◆ ConstSoftMeshShapePtr

using dart::dynamics::ConstSoftMeshShapePtr = typedef std::shared_ptr<const SoftMeshShape >

◆ CylinderShapePtr

using dart::dynamics::CylinderShapePtr = typedef std::shared_ptr< CylinderShape >

◆ DegreeOfFreedomPtr

◆ EllipsoidShapePtr

using dart::dynamics::EllipsoidShapePtr = typedef std::shared_ptr< EllipsoidShape >

◆ EndEffectorPtr

◆ EntityPtrSet

typedef std::set< Entity * > dart::dynamics::EntityPtrSet

◆ FramePtrSet

typedef std::set<Frame*> dart::dynamics::FramePtrSet

◆ GroupPtr

using dart::dynamics::GroupPtr = typedef std::shared_ptr< Group >

◆ HeightmapShaped

◆ HeightmapShapef

◆ IK

◆ IKHierarchy

typedef std::vector<std::vector<std::shared_ptr<InverseKinematics> > > dart::dynamics::IKHierarchy

An IKHierarchy is a sorted set of IK modules.

The outer vector represents the precedence of the IK modules. Modules with the same precedence will have their gradients added. Precedence of the modules decreases as the index of the outer vector increases. Modules with lower precedence will be projected through the null spaces of modules with higher precedence.

◆ InverseKinematicsPtr

◆ JacobianNodePtr

◆ JointPtr

◆ LineSegmentShapePtr

using dart::dynamics::LineSegmentShapePtr = typedef std::shared_ptr< LineSegmentShape >

◆ LinkagePtr

using dart::dynamics::LinkagePtr = typedef std::shared_ptr< Linkage >

◆ MeshShapePtr

using dart::dynamics::MeshShapePtr = typedef std::shared_ptr< MeshShape >

◆ MetaSkeletonPtr

using dart::dynamics::MetaSkeletonPtr = typedef std::shared_ptr< MetaSkeleton >

◆ MultiSphereShape

◆ NodeDestructorPtr

using dart::dynamics::NodeDestructorPtr = typedef std::shared_ptr< NodeDestructor >

◆ NodePtr

◆ PlaneShapePtr

using dart::dynamics::PlaneShapePtr = typedef std::shared_ptr< PlaneShape >

◆ ReferentialSkeletonPtr

using dart::dynamics::ReferentialSkeletonPtr = typedef std::shared_ptr< ReferentialSkeleton >

◆ ShapeFramePtr

using dart::dynamics::ShapeFramePtr = typedef std::shared_ptr< ShapeFrame >

◆ ShapeNodePtr

◆ ShapePtr

using dart::dynamics::ShapePtr = typedef std::shared_ptr< Shape >

◆ SimpleFramePtr

using dart::dynamics::SimpleFramePtr = typedef std::shared_ptr< SimpleFrame >

◆ SkeletonPtr

using dart::dynamics::SkeletonPtr = typedef std::shared_ptr< Skeleton >

◆ SoftBodyNodePtr

◆ SoftMeshShapePtr

using dart::dynamics::SoftMeshShapePtr = typedef std::shared_ptr< SoftMeshShape >

◆ WeakArrowShapePtr

using dart::dynamics::WeakArrowShapePtr = typedef std::weak_ptr< ArrowShape >

◆ WeakBodyNodePtr

◆ WeakBoxShapePtr

using dart::dynamics::WeakBoxShapePtr = typedef std::weak_ptr< BoxShape >

◆ WeakBranchPtr

using dart::dynamics::WeakBranchPtr = typedef std::weak_ptr< Branch >

◆ WeakChainPtr

using dart::dynamics::WeakChainPtr = typedef std::weak_ptr< Chain >

◆ WeakConstArrowShapePtr

using dart::dynamics::WeakConstArrowShapePtr = typedef std::weak_ptr<const ArrowShape >

◆ WeakConstBodyNodePtr

◆ WeakConstBoxShapePtr

using dart::dynamics::WeakConstBoxShapePtr = typedef std::weak_ptr<const BoxShape >

◆ WeakConstBranchPtr

using dart::dynamics::WeakConstBranchPtr = typedef std::weak_ptr<const Branch >

◆ WeakConstChainPtr

using dart::dynamics::WeakConstChainPtr = typedef std::weak_ptr<const Chain >

◆ WeakConstCylinderShapePtr

using dart::dynamics::WeakConstCylinderShapePtr = typedef std::weak_ptr<const CylinderShape >

◆ WeakConstDegreeOfFreedomPtr

◆ WeakConstEllipsoidShapePtr

using dart::dynamics::WeakConstEllipsoidShapePtr = typedef std::weak_ptr<const EllipsoidShape >

◆ WeakConstEndEffectorPtr

◆ WeakConstGroupPtr

using dart::dynamics::WeakConstGroupPtr = typedef std::weak_ptr<const Group >

◆ WeakConstInverseKinematicsPtr

◆ WeakConstJacobianNodePtr

◆ WeakConstJointPtr

◆ WeakConstLineSegmentShapePtr

using dart::dynamics::WeakConstLineSegmentShapePtr = typedef std::weak_ptr<const LineSegmentShape >

◆ WeakConstLinkagePtr

using dart::dynamics::WeakConstLinkagePtr = typedef std::weak_ptr<const Linkage >

◆ WeakConstMeshShapePtr

using dart::dynamics::WeakConstMeshShapePtr = typedef std::weak_ptr<const MeshShape >

◆ WeakConstMetaSkeletonPtr

using dart::dynamics::WeakConstMetaSkeletonPtr = typedef std::weak_ptr<const MetaSkeleton >

◆ WeakConstNodeDestructorPtr

using dart::dynamics::WeakConstNodeDestructorPtr = typedef std::weak_ptr<const NodeDestructor >

◆ WeakConstNodePtr

◆ WeakConstPlaneShapePtr

using dart::dynamics::WeakConstPlaneShapePtr = typedef std::weak_ptr<const PlaneShape >

◆ WeakConstReferentialSkeletonPtr

◆ WeakConstShapeFramePtr

using dart::dynamics::WeakConstShapeFramePtr = typedef std::weak_ptr<const ShapeFrame >

◆ WeakConstShapeNodePtr

◆ WeakConstShapePtr

using dart::dynamics::WeakConstShapePtr = typedef std::weak_ptr<const Shape >

◆ WeakConstSimpleFramePtr

using dart::dynamics::WeakConstSimpleFramePtr = typedef std::weak_ptr<const SimpleFrame >

◆ WeakConstSkeletonPtr

using dart::dynamics::WeakConstSkeletonPtr = typedef std::weak_ptr<const Skeleton >

◆ WeakConstSoftBodyNodePtr

◆ WeakConstSoftMeshShapePtr

using dart::dynamics::WeakConstSoftMeshShapePtr = typedef std::weak_ptr<const SoftMeshShape >

◆ WeakCylinderShapePtr

using dart::dynamics::WeakCylinderShapePtr = typedef std::weak_ptr< CylinderShape >

◆ WeakDegreeOfFreedomPtr

◆ WeakEllipsoidShapePtr

using dart::dynamics::WeakEllipsoidShapePtr = typedef std::weak_ptr< EllipsoidShape >

◆ WeakEndEffectorPtr

◆ WeakGroupPtr

using dart::dynamics::WeakGroupPtr = typedef std::weak_ptr< Group >

◆ WeakInverseKinematicsPtr

◆ WeakJacobianNodePtr

◆ WeakJointPtr

◆ WeakLineSegmentShapePtr

◆ WeakLinkagePtr

using dart::dynamics::WeakLinkagePtr = typedef std::weak_ptr< Linkage >

◆ WeakMeshShapePtr

using dart::dynamics::WeakMeshShapePtr = typedef std::weak_ptr< MeshShape >

◆ WeakMetaSkeletonPtr

using dart::dynamics::WeakMetaSkeletonPtr = typedef std::weak_ptr< MetaSkeleton >

◆ WeakNodeDestructorPtr

using dart::dynamics::WeakNodeDestructorPtr = typedef std::weak_ptr< NodeDestructor >

◆ WeakNodePtr

◆ WeakPlaneShapePtr

using dart::dynamics::WeakPlaneShapePtr = typedef std::weak_ptr< PlaneShape >

◆ WeakReferentialSkeletonPtr

◆ WeakShapeFramePtr

using dart::dynamics::WeakShapeFramePtr = typedef std::weak_ptr< ShapeFrame >

◆ WeakShapeNodePtr

◆ WeakShapePtr

using dart::dynamics::WeakShapePtr = typedef std::weak_ptr< Shape >

◆ WeakSimpleFramePtr

using dart::dynamics::WeakSimpleFramePtr = typedef std::weak_ptr< SimpleFrame >

◆ WeakSkeletonPtr

using dart::dynamics::WeakSkeletonPtr = typedef std::weak_ptr< Skeleton >

◆ WeakSoftBodyNodePtr

◆ WeakSoftMeshShapePtr

using dart::dynamics::WeakSoftMeshShapePtr = typedef std::weak_ptr< SoftMeshShape >

Function Documentation

◆ applyToAllDofs()

template<void(DegreeOfFreedom::*)() apply>
static void dart::dynamics::applyToAllDofs ( MetaSkeleton skel)
static

◆ assignJacobian() [1/2]

template<typename JacobianType >
void dart::dynamics::assignJacobian ( JacobianType &  _J,
const JacobianNode _node,
const JacobianType &  _JBodyNode 
)

◆ assignJacobian() [2/2]

template<typename JacobianType >
void dart::dynamics::assignJacobian ( JacobianType &  _J,
const ReferentialSkeleton _refSkel,
const JacobianNode _node,
const JacobianType &  _JBodyNode 
)

◆ checkIndexArrayAgreement()

static bool dart::dynamics::checkIndexArrayAgreement ( const MetaSkeleton skel,
const std::vector< std::size_t > &  _indices,
const Eigen::VectorXd &  _values,
const std::string &  _fname,
const std::string &  _vname 
)
static

◆ checkIndexArrayValidity()

static bool dart::dynamics::checkIndexArrayValidity ( const MetaSkeleton skel,
const std::vector< std::size_t > &  _indices,
const std::string &  _fname 
)
static

◆ checkMass()

void dart::dynamics::checkMass ( const BodyNode bodyNode,
const double  mass 
)

◆ checkSkeletonNodeAgreement()

static bool dart::dynamics::checkSkeletonNodeAgreement ( const BodyNode _bodyNode,
const ConstSkeletonPtr _newSkeleton,
const BodyNode _newParent,
const std::string &  _function,
const std::string &  _operation 
)
static

◆ cloneIkFunc() [1/2]

static std::shared_ptr<optimizer::Function> dart::dynamics::cloneIkFunc ( const std::shared_ptr< optimizer::Function > &  _function,
const std::shared_ptr< HierarchicalIK > &  _ik 
)
static

◆ cloneIkFunc() [2/2]

static std::shared_ptr<optimizer::Function> dart::dynamics::cloneIkFunc ( const std::shared_ptr< optimizer::Function > &  _function,
InverseKinematics _ik 
)
static

◆ computeSupportPolygon()

static void dart::dynamics::computeSupportPolygon ( const Skeleton skel,
math::SupportPolygon polygon,
math::SupportGeometry geometry,
std::vector< std::size_t > &  ee_indices,
Eigen::Vector3d &  axis1,
Eigen::Vector3d &  axis2,
Eigen::Vector2d &  centroid,
std::size_t  treeIndex 
)
static

◆ constructArrowBody()

static void dart::dynamics::constructArrowBody ( aiMesh *  mesh,
double  z1,
double  z2,
const ArrowShape::Properties properties 
)
static

◆ constructArrowTip()

static void dart::dynamics::constructArrowTip ( aiMesh *  mesh,
double  base,
double  tip,
const ArrowShape::Properties properties 
)
static

◆ convertToConstPtrVector()

template<class T >
static std::vector<const T*>& dart::dynamics::convertToConstPtrVector ( const std::vector< T * > &  vec,
std::vector< const T * > &  const_vec 
)
static

◆ convertToConstSet()

template<typename T >
static std::set<const T*> dart::dynamics::convertToConstSet ( const std::set< T * > &  _set)
static

◆ convertVector()

template<class T1 , class T2 >
static std::vector<T2>& dart::dynamics::convertVector ( const std::vector< T1 > &  t1_vec,
std::vector< T2 > &  t2_vec 
)
static

◆ createFileIO()

aiFileIO dart::dynamics::createFileIO ( Assimp::IOSystem *  _system)

◆ createTargetFromClone()

Linkage::Criteria::Target dart::dynamics::createTargetFromClone ( Skeleton skelClone,
const Linkage::Criteria::Target target 
)

◆ createTerminalFromClone()

Linkage::Criteria::Terminal dart::dynamics::createTerminalFromClone ( Skeleton skelClone,
const Linkage::Criteria::Terminal terminal 
)

◆ extractDataFromNodeTypeMap()

template<class DataType , std::unique_ptr< DataType >(Node::*)() const getData, typename VectorType = common::CloneableVector<std::unique_ptr<DataType> >, typename DataMap = std::map<std::type_index, std::unique_ptr<VectorType> >>
static void dart::dynamics::extractDataFromNodeTypeMap ( DataMap &  dataMap,
const BodyNode::NodeMap &  nodeMap 
)
static

◆ getCOMJacobianTemplate() [1/2]

template<typename JacType , JacType(TemplatedJacobianNode< BodyNode >::*)(const Eigen::Vector3d &, const Frame *) const getJacFn>
JacType dart::dynamics::getCOMJacobianTemplate ( const ReferentialSkeleton _refSkel,
const Frame _inCoordinatesOf 
)

◆ getCOMJacobianTemplate() [2/2]

template<typename JacType , JacType(TemplatedJacobianNode< BodyNode >::*)(const Eigen::Vector3d &, const Frame *) const getJacFn>
JacType dart::dynamics::getCOMJacobianTemplate ( const Skeleton _skel,
const Frame _inCoordinatesOf 
)

◆ getCOMPropertyTemplate() [1/2]

template<typename PropertyType , PropertyType(BodyNode::*)(const Frame *, const Frame *) const getProperty>
PropertyType dart::dynamics::getCOMPropertyTemplate ( const ReferentialSkeleton _refSkel,
const Frame _relativeTo,
const Frame _inCoordinatesOf 
)

◆ getCOMPropertyTemplate() [2/2]

template<typename PropertyType , PropertyType(BodyNode::*)(const Frame *, const Frame *) const getPropertyFn>
PropertyType dart::dynamics::getCOMPropertyTemplate ( const Skeleton _skel,
const Frame _relativeTo,
const Frame _inCoordinatesOf 
)

◆ getValueFromIndex()

template<double(DegreeOfFreedom::*)() const getValue>
static double dart::dynamics::getValueFromIndex ( const MetaSkeleton skel,
std::size_t  _index,
const std::string &  _fname 
)
static

◆ getValuesFromAllDofs()

template<double(DegreeOfFreedom::*)() const getValue>
static Eigen::VectorXd dart::dynamics::getValuesFromAllDofs ( const MetaSkeleton skel,
const std::string &  _fname 
)
static

◆ getValuesFromVector()

template<double(DegreeOfFreedom::*)() const getValue>
static Eigen::VectorXd dart::dynamics::getValuesFromVector ( const MetaSkeleton skel,
const std::vector< std::size_t > &  _indices,
const std::string &  _fname 
)
static

◆ isValidBodyNode() [1/2]

static bool dart::dynamics::isValidBodyNode ( const ReferentialSkeleton ,
const JacobianNode _node,
const std::string &  _fname 
)
static

◆ isValidBodyNode() [2/2]

static bool dart::dynamics::isValidBodyNode ( const Skeleton _skeleton,
const JacobianNode _node,
const std::string &  _fname 
)
static

◆ operator!=() [1/2]

template<class IkType , class BodyNodeT >
bool dart::dynamics::operator!= ( const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &  _ik,
std::nullptr_t   
)
inline

◆ operator!=() [2/2]

template<class IkType , class BodyNodeT >
bool dart::dynamics::operator!= ( std::nullptr_t  ,
const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &  _ik 
)
inline

◆ operator==() [1/2]

template<class IkType , class BodyNodeT >
bool dart::dynamics::operator== ( const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &  _ik,
std::nullptr_t   
)
inline

◆ operator==() [2/2]

template<class IkType , class BodyNodeT >
bool dart::dynamics::operator== ( std::nullptr_t  ,
const TemplateInverseKinematicsPtr< IkType, BodyNodeT > &  _ik 
)
inline

◆ recursiveConstructBodyNodeTree()

template<typename BodyNodeT >
static void dart::dynamics::recursiveConstructBodyNodeTree ( std::vector< BodyNodeT * > &  tree,
BodyNodeT *  _currentBodyNode 
)
static

◆ setAllValuesFromVector()

template<void(DegreeOfFreedom::*)(double _value) setValue>
static void dart::dynamics::setAllValuesFromVector ( MetaSkeleton skel,
const Eigen::VectorXd &  _values,
const std::string &  _fname,
const std::string &  _vname 
)
static

◆ setMatrixFromSkeletonData()

template<const Eigen::MatrixXd &(Skeleton::*)(std::size_t) const getMatrix>
const Eigen::MatrixXd& dart::dynamics::setMatrixFromSkeletonData ( Eigen::MatrixXd &  M,
const std::vector< const DegreeOfFreedom * > &  dofs 
)

◆ setNodesFromDataTypeMap()

template<class DataType , void(Node::*)(const DataType &) setData, typename VectorType = common::CloneableVector<std::unique_ptr<DataType> >, typename DataMap = std::map<std::type_index, std::unique_ptr<VectorType> >>
static void dart::dynamics::setNodesFromDataTypeMap ( BodyNode::NodeMap &  nodeMap,
const DataMap &  dataMap 
)
static

◆ setValueFromIndex()

template<void(DegreeOfFreedom::*)(double _value) setValue>
static void dart::dynamics::setValueFromIndex ( MetaSkeleton skel,
std::size_t  _index,
double  _value,
const std::string &  _fname 
)
static

◆ setValuesFromVector()

template<void(DegreeOfFreedom::*)(double _value) setValue>
static void dart::dynamics::setValuesFromVector ( MetaSkeleton skel,
const std::vector< std::size_t > &  _indices,
const Eigen::VectorXd &  _values,
const std::string &  _fname,
const std::string &  _vname 
)
static

◆ setVectorFromSkeletonData()

template<const Eigen::VectorXd &(Skeleton::*)(std::size_t) const getVector>
const Eigen::VectorXd& dart::dynamics::setVectorFromSkeletonData ( Eigen::VectorXd &  V,
const std::vector< const DegreeOfFreedom * > &  dofs 
)

◆ stepToNextChild()

void dart::dynamics::stepToNextChild ( std::vector< Recording > &  _recorder,
std::vector< BodyNode * > &  _bns,
Recording _r,
const std::unordered_map< BodyNode *, bool > &  _terminalMap,
int  _initValue 
)

◆ stepToParent()

void dart::dynamics::stepToParent ( std::vector< Recording > &  _recorder,
std::vector< BodyNode * > &  _bns,
Recording _r,
const std::unordered_map< BodyNode *, bool > &  _terminalMap 
)

◆ templatedGetIndexOf()

template<class ObjectT , std::size_t(ObjectT::*)() const getIndexInSkeleton>
static std::size_t dart::dynamics::templatedGetIndexOf ( const Skeleton _skel,
const ObjectT *  _obj,
const std::string &  _type,
bool  _warning 
)
static

◆ variadicGetAngularJacobian() [1/2]

template<typename... Args>
math::AngularJacobian dart::dynamics::variadicGetAngularJacobian ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetAngularJacobian() [2/2]

template<typename... Args>
math::AngularJacobian dart::dynamics::variadicGetAngularJacobian ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetAngularJacobianDeriv() [1/2]

template<typename... Args>
math::AngularJacobian dart::dynamics::variadicGetAngularJacobianDeriv ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetAngularJacobianDeriv() [2/2]

template<typename... Args>
math::AngularJacobian dart::dynamics::variadicGetAngularJacobianDeriv ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobian() [1/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobian ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobian() [2/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobian ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobianClassicDeriv() [1/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobianClassicDeriv ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobianClassicDeriv() [2/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobianClassicDeriv ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobianSpatialDeriv() [1/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobianSpatialDeriv ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetJacobianSpatialDeriv() [2/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetJacobianSpatialDeriv ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetLinearJacobian() [1/2]

template<typename... Args>
math::LinearJacobian dart::dynamics::variadicGetLinearJacobian ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetLinearJacobian() [2/2]

template<typename... Args>
math::LinearJacobian dart::dynamics::variadicGetLinearJacobian ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetLinearJacobianDeriv() [1/2]

template<typename... Args>
math::LinearJacobian dart::dynamics::variadicGetLinearJacobianDeriv ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetLinearJacobianDeriv() [2/2]

template<typename... Args>
math::LinearJacobian dart::dynamics::variadicGetLinearJacobianDeriv ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetWorldJacobian() [1/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetWorldJacobian ( const ReferentialSkeleton _refSkel,
const JacobianNode _node,
Args...  args 
)

◆ variadicGetWorldJacobian() [2/2]

template<typename... Args>
math::Jacobian dart::dynamics::variadicGetWorldJacobian ( const Skeleton _skel,
const JacobianNode _node,
Args...  args 
)

◆ wrapCyclicSolution()

bool dart::dynamics::wrapCyclicSolution ( double  curr,
double  lb,
double  ub,
double &  sol 
)

Tries to wrap a single dof IK solution, from IKFast, in the range of joint limits.

This function shouldn't be used for a non-cyclic DegreeOfFreedom.

If multiple solution are available (when the range is wider than 2*pi), returns the closest solution to the current joint position.

Parameters
[in]currThe current joint positions before solving IK.
[in]lbThe lower joint position limit.
[in]ubThe upper joint position limit.
[in,out]solThe IK solution to be wrapped. No assumption that the value initially in the bounds. This value is only updated if an available solution is found.
Returns
True if a solution is found. False, otherwise.

Variable Documentation

◆ DART_DEFAULT_DAMPING_COEFF

const double dart::dynamics::DART_DEFAULT_DAMPING_COEFF = 0.01

◆ DART_DEFAULT_EDGE_STIFNESS

const double dart::dynamics::DART_DEFAULT_EDGE_STIFNESS = 1.0

◆ DART_DEFAULT_FRICTION_COEFF

const double dart::dynamics::DART_DEFAULT_FRICTION_COEFF = 1.0

◆ DART_DEFAULT_RESTITUTION_COEFF

const double dart::dynamics::DART_DEFAULT_RESTITUTION_COEFF = 0.0

◆ DART_DEFAULT_VERTEX_STIFFNESS

const double dart::dynamics::DART_DEFAULT_VERTEX_STIFFNESS = 1.0

◆ DefaultIKAngularWeight

const double dart::dynamics::DefaultIKAngularWeight = 0.4

◆ DefaultIKDLSCoefficient

const double dart::dynamics::DefaultIKDLSCoefficient = 0.05

◆ DefaultIKErrorClamp

const double dart::dynamics::DefaultIKErrorClamp = 1.0

◆ DefaultIKGradientComponentClamp

const double dart::dynamics::DefaultIKGradientComponentClamp = 0.2

◆ DefaultIKGradientComponentWeight

const double dart::dynamics::DefaultIKGradientComponentWeight = 1.0

◆ DefaultIKLinearWeight

const double dart::dynamics::DefaultIKLinearWeight = 1.0

◆ DefaultIKTolerance

const double dart::dynamics::DefaultIKTolerance = 1e-6

◆ INVALID_INDEX

constexpr std::size_t dart::dynamics::INVALID_INDEX = static_cast<std::size_t>(-1)
constexpr