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::Function >	cloneIkFunc (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::Function >	cloneIkFunc (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

using dart::dynamics::BodyNodePtr = typedef TemplateBodyNodePtr< BodyNode >

◆ 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

using dart::dynamics::ConstBodyNodePtr = typedef TemplateBodyNodePtr<const BodyNode >

◆ 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

using dart::dynamics::ConstDegreeOfFreedomPtr = typedef TemplateDegreeOfFreedomPtr<const DegreeOfFreedom , const BodyNode>

◆ ConstEllipsoidShapePtr

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

◆ ConstEndEffectorPtr

using dart::dynamics::ConstEndEffectorPtr = typedef TemplateNodePtr<const EndEffector , const BodyNode>

◆ ConstGroupPtr

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

◆ ConstInverseKinematicsPtr

using dart::dynamics::ConstInverseKinematicsPtr = typedef TemplateInverseKinematicsPtr<const InverseKinematics , ConstJacobianNodePtr>

◆ ConstJacobianNodePtr

using dart::dynamics::ConstJacobianNodePtr = typedef TemplateNodePtr<const JacobianNode , const BodyNode>

◆ ConstJointPtr

using dart::dynamics::ConstJointPtr = typedef TemplateJointPtr<const Joint , const BodyNode>

◆ 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

using dart::dynamics::ConstNodePtr = typedef TemplateNodePtr<const Node , const BodyNode>

◆ 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

using dart::dynamics::ConstShapeNodePtr = typedef TemplateNodePtr<const ShapeNode , const BodyNode>

◆ 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

using dart::dynamics::ConstSoftBodyNodePtr = typedef TemplateBodyNodePtr<const SoftBodyNode >

◆ ConstSoftMeshShapePtr

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

◆ CylinderShapePtr

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

◆ DegreeOfFreedomPtr

using dart::dynamics::DegreeOfFreedomPtr = typedef TemplateDegreeOfFreedomPtr< DegreeOfFreedom , BodyNode>

◆ EllipsoidShapePtr

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

◆ EndEffectorPtr

using dart::dynamics::EndEffectorPtr = typedef TemplateNodePtr< EndEffector , BodyNode>

◆ 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

using dart::dynamics::HeightmapShaped = typedef HeightmapShape<double>

◆ HeightmapShapef

using dart::dynamics::HeightmapShapef = typedef HeightmapShape<float>

◆ IK

typedef InverseKinematics dart::dynamics::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

using dart::dynamics::InverseKinematicsPtr = typedef TemplateInverseKinematicsPtr< InverseKinematics , JacobianNodePtr>

◆ JacobianNodePtr

using dart::dynamics::JacobianNodePtr = typedef TemplateNodePtr< JacobianNode , BodyNode>

◆ JointPtr

using dart::dynamics::JointPtr = typedef TemplateJointPtr< Joint , BodyNode>

◆ 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

typedef MultiSphereConvexHullShape dart::dynamics::MultiSphereShape

◆ NodeDestructorPtr

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

◆ NodePtr

using dart::dynamics::NodePtr = typedef TemplateNodePtr< Node , BodyNode>

◆ 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

using dart::dynamics::ShapeNodePtr = typedef TemplateNodePtr< ShapeNode , BodyNode>

◆ 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

using dart::dynamics::SoftBodyNodePtr = typedef TemplateBodyNodePtr< SoftBodyNode >

◆ SoftMeshShapePtr

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

◆ WeakArrowShapePtr

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

◆ WeakBodyNodePtr

using dart::dynamics::WeakBodyNodePtr = typedef TemplateWeakBodyNodePtr< BodyNode >

◆ 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

using dart::dynamics::WeakConstBodyNodePtr = typedef TemplateWeakBodyNodePtr<const BodyNode >

◆ 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

using dart::dynamics::WeakConstDegreeOfFreedomPtr = typedef TemplateWeakDegreeOfFreedomPtr<const DegreeOfFreedom , const BodyNode>

◆ WeakConstEllipsoidShapePtr

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

◆ WeakConstEndEffectorPtr

using dart::dynamics::WeakConstEndEffectorPtr = typedef TemplateWeakNodePtr<const EndEffector , const BodyNode>

◆ WeakConstGroupPtr

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

◆ WeakConstInverseKinematicsPtr

using dart::dynamics::WeakConstInverseKinematicsPtr = typedef TemplateWeakInverseKinematicsPtr<const InverseKinematics , ConstJacobianNodePtr>

◆ WeakConstJacobianNodePtr

using dart::dynamics::WeakConstJacobianNodePtr = typedef TemplateWeakNodePtr<const JacobianNode , const BodyNode>

◆ WeakConstJointPtr

using dart::dynamics::WeakConstJointPtr = typedef TemplateWeakJointPtr<const Joint , const BodyNode>

◆ 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

using dart::dynamics::WeakConstNodePtr = typedef TemplateWeakNodePtr<const Node , const BodyNode>

◆ WeakConstPlaneShapePtr

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

◆ WeakConstReferentialSkeletonPtr

using dart::dynamics::WeakConstReferentialSkeletonPtr = typedef std::weak_ptr<const ReferentialSkeleton >

◆ WeakConstShapeFramePtr

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

◆ WeakConstShapeNodePtr

using dart::dynamics::WeakConstShapeNodePtr = typedef TemplateWeakNodePtr<const ShapeNode , const BodyNode>

◆ 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

using dart::dynamics::WeakConstSoftBodyNodePtr = typedef TemplateWeakBodyNodePtr<const SoftBodyNode >

◆ WeakConstSoftMeshShapePtr

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

◆ WeakCylinderShapePtr

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

◆ WeakDegreeOfFreedomPtr

using dart::dynamics::WeakDegreeOfFreedomPtr = typedef TemplateWeakDegreeOfFreedomPtr< DegreeOfFreedom , BodyNode>

◆ WeakEllipsoidShapePtr

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

◆ WeakEndEffectorPtr

using dart::dynamics::WeakEndEffectorPtr = typedef TemplateWeakNodePtr< EndEffector , BodyNode>

◆ WeakGroupPtr

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

◆ WeakInverseKinematicsPtr

using dart::dynamics::WeakInverseKinematicsPtr = typedef TemplateWeakInverseKinematicsPtr< InverseKinematics , JacobianNodePtr>

◆ WeakJacobianNodePtr

using dart::dynamics::WeakJacobianNodePtr = typedef TemplateWeakNodePtr< JacobianNode , BodyNode>

◆ WeakJointPtr

using dart::dynamics::WeakJointPtr = typedef TemplateWeakJointPtr< Joint , BodyNode>

◆ WeakLineSegmentShapePtr

using dart::dynamics::WeakLineSegmentShapePtr = typedef std::weak_ptr< LineSegmentShape >

◆ 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

using dart::dynamics::WeakNodePtr = typedef TemplateWeakNodePtr< Node , BodyNode>

◆ WeakPlaneShapePtr

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

◆ WeakReferentialSkeletonPtr

using dart::dynamics::WeakReferentialSkeletonPtr = typedef std::weak_ptr< ReferentialSkeleton >

◆ WeakShapeFramePtr

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

◆ WeakShapeNodePtr

using dart::dynamics::WeakShapeNodePtr = typedef TemplateWeakNodePtr< ShapeNode , BodyNode>

◆ 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

using dart::dynamics::WeakSoftBodyNodePtr = typedef TemplateWeakBodyNodePtr< SoftBodyNode >

◆ 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]	curr	The current joint positions before solving IK.
[in]	lb	The lower joint position limit.
[in]	ub	The upper joint position limit.
[in,out]	sol	The 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

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ ArrowShapePtr

◆ BodyNodePtr

◆ BoxShapePtr

◆ BranchPtr

◆ ChainPtr

◆ ConstArrowShapePtr

◆ ConstBodyNodePtr

◆ ConstBoxShapePtr

◆ ConstBranchPtr

◆ ConstChainPtr

◆ ConstCylinderShapePtr

◆ ConstDegreeOfFreedomPtr

◆ ConstEllipsoidShapePtr

◆ ConstEndEffectorPtr

◆ ConstGroupPtr

◆ ConstInverseKinematicsPtr

◆ ConstJacobianNodePtr

◆ ConstJointPtr

◆ ConstLineSegmentShapePtr

◆ ConstLinkagePtr

◆ ConstMeshShapePtr

◆ ConstMetaSkeletonPtr

◆ ConstNodeDestructorPtr

◆ ConstNodePtr

◆ ConstPlaneShapePtr

◆ ConstReferentialSkeletonPtr

◆ ConstShapeFramePtr

◆ ConstShapeNodePtr

◆ ConstShapePtr

◆ ConstSimpleFramePtr

◆ ConstSkeletonPtr

◆ ConstSoftBodyNodePtr

◆ ConstSoftMeshShapePtr

◆ CylinderShapePtr

◆ DegreeOfFreedomPtr

◆ EllipsoidShapePtr

◆ EndEffectorPtr

◆ EntityPtrSet

◆ FramePtrSet

◆ GroupPtr

◆ HeightmapShaped

◆ HeightmapShapef

◆ IK

◆ IKHierarchy

◆ InverseKinematicsPtr

◆ JacobianNodePtr

◆ JointPtr

◆ LineSegmentShapePtr

◆ LinkagePtr

◆ MeshShapePtr

◆ MetaSkeletonPtr

◆ MultiSphereShape

◆ NodeDestructorPtr

◆ NodePtr

◆ PlaneShapePtr

◆ ReferentialSkeletonPtr

◆ ShapeFramePtr

◆ ShapeNodePtr

◆ ShapePtr

◆ SimpleFramePtr

◆ SkeletonPtr

◆ SoftBodyNodePtr

◆ SoftMeshShapePtr

◆ WeakArrowShapePtr

◆ WeakBodyNodePtr

◆ WeakBoxShapePtr

◆ WeakBranchPtr

◆ WeakChainPtr

◆ WeakConstArrowShapePtr

◆ WeakConstBodyNodePtr

◆ WeakConstBoxShapePtr

◆ WeakConstBranchPtr

◆ WeakConstChainPtr

◆ WeakConstCylinderShapePtr