d0/d96/MetaSkeleton_8hpp_source.html

/*

 * Copyright (c) 2011-2022, The DART development contributors

 * All rights reserved.

 *

 * The list of contributors can be found at:

 *   https://github.com/dartsim/dart/blob/master/LICENSE

 *

 * This file is provided under the following "BSD-style" License:

 *   Redistribution and use in source and binary forms, with or

 *   without modification, are permitted provided that the following

 *   conditions are met:

 *   * Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *   * Redistributions in binary form must reproduce the above

 *     copyright notice, this list of conditions and the following

 *     disclaimer in the documentation and/or other materials provided

 *     with the distribution.

 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

 *   CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,

 *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

 *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 *   POSSIBILITY OF SUCH DAMAGE.

 */


#ifndef DART_DYNAMICS_METASKELETON_HPP_

#define DART_DYNAMICS_METASKELETON_HPP_


#include <string>

#include <vector>


#include <Eigen/Dense>


#include "dart/common/LockableReference.hpp"

#include "dart/common/Signal.hpp"

#include "dart/common/Subject.hpp"

#include "dart/dynamics/Frame.hpp"

#include "dart/dynamics/InvalidIndex.hpp"

#include "dart/math/Geometry.hpp"


namespace dart {

namespace dynamics {


class BodyNode;

class SoftBodyNode;

class PointMass;

class Joint;

class DegreeOfFreedom;


class MetaSkeleton : public common::Subject

{

public:

  using NameChangedSignal = common::Signal<void(

      std::shared_ptr<const MetaSkeleton> _skeleton,

      const std::string& _oldName,

      const std::string& _newName)>;


  MetaSkeleton(const MetaSkeleton&) = delete;


  virtual ~MetaSkeleton() = default;


  virtual MetaSkeletonPtr cloneMetaSkeleton(

      const std::string& cloneName) const = 0;

  // TODO: In DART7, rename this to clone() and change the current

  // Skeleton::clone() to override it.


  MetaSkeletonPtr cloneMetaSkeleton() const;


  virtual std::unique_ptr<common::LockableReference> getLockableReference()

      const = 0;

  // TODO: In DART7, rename this to getMutex() and change the current

  // Skeleton::getMutex() to override it.


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual const std::string& setName(const std::string& _name) = 0;


  virtual const std::string& getName() const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual std::size_t getNumBodyNodes() const = 0;


  virtual BodyNode* getBodyNode(std::size_t _idx) = 0;


  virtual const BodyNode* getBodyNode(std::size_t _idx) const = 0;


  virtual BodyNode* getBodyNode(const std::string& name) = 0;


  virtual const BodyNode* getBodyNode(const std::string& name) const = 0;


  DART_DEPRECATED(6.13)

  virtual const std::vector<BodyNode*>& getBodyNodes() = 0;


  DART_DEPRECATED(6.13)

  virtual const std::vector<const BodyNode*>& getBodyNodes() const = 0;


  virtual std::vector<BodyNode*> getBodyNodes(const std::string& name) = 0;


  virtual std::vector<const BodyNode*> getBodyNodes(

      const std::string& name) const = 0;


  virtual bool hasBodyNode(const BodyNode* bodyNode) const = 0;


  virtual std::size_t getIndexOf(

      const BodyNode* _bn, bool _warning = true) const = 0;


  virtual std::size_t getNumJoints() const = 0;


  virtual Joint* getJoint(std::size_t _idx) = 0;


  virtual const Joint* getJoint(std::size_t _idx) const = 0;


  virtual Joint* getJoint(const std::string& name) = 0;


  virtual const Joint* getJoint(const std::string& name) const = 0;


  DART_DEPRECATED(6.13)

  virtual std::vector<Joint*> getJoints() = 0;


  DART_DEPRECATED(6.13)

  virtual std::vector<const Joint*> getJoints() const = 0;


  virtual std::vector<Joint*> getJoints(const std::string& name) = 0;


  virtual std::vector<const Joint*> getJoints(

      const std::string& name) const = 0;


  virtual bool hasJoint(const Joint* joint) const = 0;


  virtual std::size_t getIndexOf(

      const Joint* _joint, bool _warning = true) const = 0;


  virtual std::size_t getNumDofs() const = 0;


  virtual DegreeOfFreedom* getDof(std::size_t _idx) = 0;


  virtual const DegreeOfFreedom* getDof(std::size_t _idx) const = 0;


  DART_DEPRECATED(6.13)

  virtual const std::vector<DegreeOfFreedom*>& getDofs() = 0;


  DART_DEPRECATED(6.13)

  virtual std::vector<const DegreeOfFreedom*> getDofs() const = 0;


  virtual std::size_t getIndexOf(

      const DegreeOfFreedom* _dof, bool _warning = true) const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setCommand(std::size_t _index, double _command);


  double getCommand(std::size_t _index) const;


  void setCommands(const Eigen::VectorXd& _commands);


  void setCommands(

      const std::vector<std::size_t>& _indices,

      const Eigen::VectorXd& _commands);


  Eigen::VectorXd getCommands() const;


  Eigen::VectorXd getCommands(const std::vector<std::size_t>& _indices) const;


  void resetCommands();


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setPosition(std::size_t index, double _position);


  double getPosition(std::size_t _index) const;


  void setPositions(const Eigen::VectorXd& _positions);


  void setPositions(

      const std::vector<std::size_t>& _indices,

      const Eigen::VectorXd& _positions);


  Eigen::VectorXd getPositions() const;


  Eigen::VectorXd getPositions(const std::vector<std::size_t>& _indices) const;


  void resetPositions();


  void setPositionLowerLimit(std::size_t _index, double _position);


  void setPositionLowerLimits(const Eigen::VectorXd& positions);


  void setPositionLowerLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& positions);


  double getPositionLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getPositionLowerLimits() const;


  Eigen::VectorXd getPositionLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setPositionUpperLimit(std::size_t _index, double _position);


  void setPositionUpperLimits(const Eigen::VectorXd& positions);


  void setPositionUpperLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& positions);


  double getPositionUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getPositionUpperLimits() const;


  Eigen::VectorXd getPositionUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setVelocity(std::size_t _index, double _velocity);


  double getVelocity(std::size_t _index) const;


  void setVelocities(const Eigen::VectorXd& _velocities);


  void setVelocities(

      const std::vector<std::size_t>& _indices,

      const Eigen::VectorXd& _velocities);


  Eigen::VectorXd getVelocities() const;


  Eigen::VectorXd getVelocities(const std::vector<std::size_t>& _indices) const;


  void resetVelocities();


  void setVelocityLowerLimit(std::size_t _index, double _velocity);


  void setVelocityLowerLimits(const Eigen::VectorXd& velocities);


  void setVelocityLowerLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& velocities);


  double getVelocityLowerLimit(std::size_t _index);


  Eigen::VectorXd getVelocityLowerLimits() const;


  Eigen::VectorXd getVelocityLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setVelocityUpperLimit(std::size_t _index, double _velocity);


  void setVelocityUpperLimits(const Eigen::VectorXd& velocities);


  void setVelocityUpperLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& velocities);


  double getVelocityUpperLimit(std::size_t _index);


  Eigen::VectorXd getVelocityUpperLimits() const;


  Eigen::VectorXd getVelocityUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setAcceleration(std::size_t _index, double _acceleration);


  double getAcceleration(std::size_t _index) const;


  void setAccelerations(const Eigen::VectorXd& _accelerations);


  void setAccelerations(

      const std::vector<std::size_t>& _indices,

      const Eigen::VectorXd& _accelerations);


  Eigen::VectorXd getAccelerations() const;


  Eigen::VectorXd getAccelerations(

      const std::vector<std::size_t>& _indices) const;


  void resetAccelerations();


  void setAccelerationLowerLimit(std::size_t _index, double _acceleration);


  void setAccelerationLowerLimits(const Eigen::VectorXd& accelerations);


  void setAccelerationLowerLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& accelerations);


  double getAccelerationLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getAccelerationLowerLimits() const;


  Eigen::VectorXd getAccelerationLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setAccelerationUpperLimit(std::size_t _index, double _acceleration);


  void setAccelerationUpperLimits(const Eigen::VectorXd& accelerations);


  void setAccelerationUpperLimits(

      const std::vector<std::size_t>& indices,

      const Eigen::VectorXd& accelerations);


  double getAccelerationUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getAccelerationUpperLimits() const;


  Eigen::VectorXd getAccelerationUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setForce(std::size_t _index, double _force);


  double getForce(std::size_t _index) const;


  void setForces(const Eigen::VectorXd& _forces);


  void setForces(

      const std::vector<std::size_t>& _index, const Eigen::VectorXd& _forces);


  Eigen::VectorXd getForces() const;


  Eigen::VectorXd getForces(const std::vector<std::size_t>& _indices) const;


  void resetGeneralizedForces();


  void setForceLowerLimit(std::size_t _index, double _force);


  void setForceLowerLimits(const Eigen::VectorXd& forces);


  void setForceLowerLimits(

      const std::vector<std::size_t>& indices, const Eigen::VectorXd& forces);


  double getForceLowerLimit(std::size_t _index) const;


  Eigen::VectorXd getForceLowerLimits() const;


  Eigen::VectorXd getForceLowerLimits(

      const std::vector<std::size_t>& indices) const;


  void setForceUpperLimit(std::size_t _index, double _force);


  void setForceUpperLimits(const Eigen::VectorXd& forces);


  void setForceUpperLimits(

      const std::vector<std::size_t>& indices, const Eigen::VectorXd& forces);


  double getForceUpperLimit(std::size_t _index) const;


  Eigen::VectorXd getForceUpperLimits() const;


  Eigen::VectorXd getForceUpperLimits(

      const std::vector<std::size_t>& indices) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  Eigen::VectorXd getVelocityChanges() const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  void setJointConstraintImpulses(const Eigen::VectorXd& _impulses);


  Eigen::VectorXd getJointConstraintImpulses() const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual math::Jacobian getJacobian(const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node, const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node, const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getWorldJacobian(const JacobianNode* _node) const = 0;


  virtual math::Jacobian getWorldJacobian(

      const JacobianNode* _node, const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  math::LinearJacobian getLinearJacobian(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual math::AngularJacobian getAngularJacobian(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  math::AngularJacobian getAngularJacobian(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf = Frame::World()) const;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node, const Frame* _inCoordinatesOf) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node, const Eigen::Vector3d& _localOffset) const = 0;


  virtual math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf) const = 0;


  math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  math::Jacobian getJacobianSpatialDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const JacobianNode* _relativeTo,

      const Frame* _inCoordinatesOf) const;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node) const = 0;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node, const Frame* _inCoordinatesOf) const = 0;


  virtual math::Jacobian getJacobianClassicDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobianDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getLinearJacobianDeriv(

      const JacobianNode* _node,

      const Eigen::Vector3d& _localOffset,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::AngularJacobian getAngularJacobianDeriv(

      const JacobianNode* _node,

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual double getMass() const = 0;


  virtual const Eigen::MatrixXd& getMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getAugMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getInvMassMatrix() const = 0;


  virtual const Eigen::MatrixXd& getInvAugMassMatrix() const = 0;


  virtual const Eigen::VectorXd& getCoriolisForces() const = 0;


  virtual const Eigen::VectorXd& getGravityForces() const = 0;


  virtual const Eigen::VectorXd& getCoriolisAndGravityForces() const = 0;


  virtual const Eigen::VectorXd& getExternalForces() const = 0;


  virtual const Eigen::VectorXd& getConstraintForces() const = 0;


  virtual void clearExternalForces() = 0;


  virtual void clearInternalForces() = 0;


  double computeLagrangian() const;


  DART_DEPRECATED(6.1)

  double getKineticEnergy() const;


  virtual double computeKineticEnergy() const = 0;


  DART_DEPRECATED(6.1)

  double getPotentialEnergy() const;


  virtual double computePotentialEnergy() const = 0;


  DART_DEPRECATED(6.0)

  virtual void clearCollidingBodies() = 0;


  //----------------------------------------------------------------------------

  //----------------------------------------------------------------------------


  virtual Eigen::Vector3d getCOM(

      const Frame* _withRespectTo = Frame::World()) const = 0;


  virtual Eigen::Vector6d getCOMSpatialVelocity(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector3d getCOMLinearVelocity(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector6d getCOMSpatialAcceleration(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual Eigen::Vector3d getCOMLinearAcceleration(

      const Frame* _relativeTo = Frame::World(),

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::Jacobian getCOMJacobian(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getCOMLinearJacobian(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::Jacobian getCOMJacobianSpatialDeriv(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  virtual math::LinearJacobian getCOMLinearJacobianDeriv(

      const Frame* _inCoordinatesOf = Frame::World()) const = 0;


  void setColor(const Eigen::Vector3d& color);


  void setColor(const Eigen::Vector4d& color);


  void setAlpha(double alpha);


  template <typename Func>

  void eachBodyNode(Func func) const;


  template <typename Func>

  void eachBodyNode(Func func);


  template <typename Func>

  void eachJoint(Func func) const;


  template <typename Func>

  void eachJoint(Func func);


  template <typename Func>

  void eachDof(Func func) const;


  template <typename Func>

  void eachDof(Func func);


protected:

  MetaSkeleton();


  //--------------------------------------------------------------------------

  // Signals

  //--------------------------------------------------------------------------

  NameChangedSignal mNameChangedSignal;


public:

  //--------------------------------------------------------------------------

  // Slot registers

  //--------------------------------------------------------------------------

  common::SlotRegister<NameChangedSignal> onNameChanged;

};


} // namespace dynamics

} // namespace dart


#include "dart/dynamics/detail/MetaSkeleton-impl.hpp"


#endif // DART_DYNAMICS_METASKELETON_HPP_

DART_DEPRECATED
#define DART_DEPRECATED(version)
Definition Deprecated.hpp:51

Frame.hpp

Geometry.hpp

InvalidIndex.hpp

LockableReference.hpp

Signal.hpp

name
std::string * name
Definition SkelParser.cpp:1698

index
std::size_t index
Definition SkelParser.cpp:1673

Subject.hpp

dart::common::Signal< void(std::shared_ptr< const MetaSkeleton > _skeleton, const std::string &_oldName, const std::string &_newName)>

dart::common::Subject
The Subject class is a base class for any object that wants to report when it gets destroyed.
Definition Subject.hpp:58

dart::dynamics::BodyNode
BodyNode class represents a single node of the skeleton.
Definition BodyNode.hpp:80

dart::dynamics::DegreeOfFreedom
DegreeOfFreedom class is a proxy class for accessing single degrees of freedom (aka generalized coord...
Definition DegreeOfFreedom.hpp:56

dart::dynamics::Frame
The Frame class serves as the backbone of DART's kinematic tree structure.
Definition Frame.hpp:58

dart::dynamics::JacobianNode
The JacobianNode class serves as a common interface for BodyNodes and EndEffectors to both be used as...
Definition JacobianNode.hpp:55

dart::dynamics::Joint
class Joint
Definition Joint.hpp:61

dart::dynamics::MetaSkeleton
MetaSkeleton is a pure abstract base class that provides a common interface for obtaining data (such ...
Definition MetaSkeleton.hpp:61

dart::dynamics::MetaSkeleton::getForces
Eigen::VectorXd getForces() const
Get the forces for all generalized coordinates.
Definition MetaSkeleton.cpp:845

dart::dynamics::MetaSkeleton::setAccelerationLowerLimits
void setAccelerationLowerLimits(const Eigen::VectorXd &accelerations)
Set the lower limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:722

dart::dynamics::MetaSkeleton::getLinearJacobianDeriv
virtual math::LinearJacobian getLinearJacobianDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
of a BodyNode.

dart::dynamics::MetaSkeleton::resetCommands
void resetCommands()
Set all commands to zero.
Definition MetaSkeleton.cpp:380

dart::dynamics::MetaSkeleton::getPotentialEnergy
double getPotentialEnergy() const
Get the potential energy of this MetaSkeleton.
Definition MetaSkeleton.cpp:1112

dart::dynamics::MetaSkeleton::getAccelerationUpperLimits
Eigen::VectorXd getAccelerationUpperLimits() const
Get the upper limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:801

dart::dynamics::MetaSkeleton::setVelocityLowerLimits
void setVelocityLowerLimits(const Eigen::VectorXd &velocities)
Set the lower limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:582

dart::dynamics::MetaSkeleton::getPositionUpperLimit
double getPositionUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:502

dart::dynamics::MetaSkeleton::setVelocityUpperLimits
void setVelocityUpperLimits(const Eigen::VectorXd &velocities)
Set the upper limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:626

dart::dynamics::MetaSkeleton::getAccelerationUpperLimit
double getAccelerationUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:794

dart::dynamics::MetaSkeleton::getCOM
virtual Eigen::Vector3d getCOM(const Frame *_withRespectTo=Frame::World()) const =0
Get the MetaSkeleton's COM with respect to any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::setForceUpperLimits
void setForceUpperLimits(const Eigen::VectorXd &forces)
Set the upperlimits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:918

dart::dynamics::MetaSkeleton::getBodyNode
virtual BodyNode * getBodyNode(std::size_t _idx)=0
Get BodyNode whose index is _idx.

dart::dynamics::MetaSkeleton::getKineticEnergy
double getKineticEnergy() const
Get the kinetic energy of this MetaSkeleton.
Definition MetaSkeleton.cpp:1106

dart::dynamics::MetaSkeleton::~MetaSkeleton
virtual ~MetaSkeleton()=default
Default destructor.

dart::dynamics::MetaSkeleton::setAcceleration
void setAcceleration(std::size_t _index, double _acceleration)
Set the acceleration of a single generalized coordinate.
Definition MetaSkeleton.cpp:663

dart::dynamics::MetaSkeleton::setAccelerationUpperLimit
void setAccelerationUpperLimit(std::size_t _index, double _acceleration)
Set the upper limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:765

dart::dynamics::MetaSkeleton::getCOMLinearVelocity
virtual Eigen::Vector3d getCOMLinearVelocity(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM linear velocity in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::clearCollidingBodies
virtual void clearCollidingBodies()=0
Clear collision flags of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::getCommands
Eigen::VectorXd getCommands() const
Get commands for all generalized coordinates.
Definition MetaSkeleton.cpp:365

dart::dynamics::MetaSkeleton::eachJoint
void eachJoint(Func func) const
Iterates all the Joints in this MetaSkeleton and invokes the callback function.
Definition MetaSkeleton-impl.hpp:88

dart::dynamics::MetaSkeleton::getForce
double getForce(std::size_t _index) const
Get the force of a single generalized coordinate.
Definition MetaSkeleton.cpp:823

dart::dynamics::MetaSkeleton::setForce
void setForce(std::size_t _index, double _force)
Set the force of a single generalized coordinate.
Definition MetaSkeleton.cpp:816

dart::dynamics::MetaSkeleton::resetAccelerations
void resetAccelerations()
Set all accelerations to zero.
Definition MetaSkeleton.cpp:708

dart::dynamics::MetaSkeleton::mNameChangedSignal
NameChangedSignal mNameChangedSignal
Definition MetaSkeleton.hpp:1018

dart::dynamics::MetaSkeleton::getLinearJacobian
virtual math::LinearJacobian getLinearJacobian(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the linear Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::resetPositions
void resetPositions()
Set all positions to zero.
Definition MetaSkeleton.cpp:430

dart::dynamics::MetaSkeleton::hasBodyNode
virtual bool hasBodyNode(const BodyNode *bodyNode) const =0
Returns whether this Skeleton contains bodyNode.

dart::dynamics::MetaSkeleton::getBodyNodes
virtual const std::vector< BodyNode * > & getBodyNodes()=0
Get all the BodyNodes that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getMassMatrix
virtual const Eigen::MatrixXd & getMassMatrix() const =0
Get the Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::getDofs
virtual const std::vector< DegreeOfFreedom * > & getDofs()=0
Get the vector of DegreesOfFreedom for this MetaSkeleton.

dart::dynamics::MetaSkeleton::getGravityForces
virtual const Eigen::VectorXd & getGravityForces() const =0
Get gravity force vector of the MetaSkeleton.

dart::dynamics::MetaSkeleton::clearExternalForces
virtual void clearExternalForces()=0
Clear the external forces of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::getBodyNode
virtual BodyNode * getBodyNode(const std::string &name)=0
Returns the BodyNode of given name.

dart::dynamics::MetaSkeleton::getBodyNode
virtual const BodyNode * getBodyNode(const std::string &name) const =0
Returns the BodyNode of given name.

dart::dynamics::MetaSkeleton::getNumJoints
virtual std::size_t getNumJoints() const =0
Get number of Joints.

dart::dynamics::MetaSkeleton::getPositionUpperLimits
Eigen::VectorXd getPositionUpperLimits() const
Get the upper limits for all generalized coordinates.
Definition MetaSkeleton.cpp:509

dart::dynamics::MetaSkeleton::getAngularJacobianDeriv
virtual math::AngularJacobian getAngularJacobianDeriv(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the angular Jacobian time derivative of a BodyNode.

dart::dynamics::MetaSkeleton::setPosition
void setPosition(std::size_t index, double _position)
Set the position of a single generalized coordinate.
Definition MetaSkeleton.cpp:386

dart::dynamics::MetaSkeleton::getMass
virtual double getMass() const =0
Get the total mass of all BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::setForceLowerLimits
void setForceLowerLimits(const Eigen::VectorXd &forces)
Set the lower limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:874

dart::dynamics::MetaSkeleton::getLockableReference
virtual std::unique_ptr< common::LockableReference > getLockableReference() const =0
Returns mutex.

dart::dynamics::MetaSkeleton::getCOMLinearAcceleration
virtual Eigen::Vector3d getCOMLinearAcceleration(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM linear acceleration in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::getAccelerationLowerLimit
double getAccelerationLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:743

dart::dynamics::MetaSkeleton::getForceUpperLimit
double getForceUpperLimit(std::size_t _index) const
Get the upper limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:933

dart::dynamics::MetaSkeleton::getJoint
virtual Joint * getJoint(std::size_t _idx)=0
Get Joint whose index is _idx.

dart::dynamics::MetaSkeleton::getPositionLowerLimits
Eigen::VectorXd getPositionLowerLimits() const
Get the lower limits for all generalized coordinates.
Definition MetaSkeleton.cpp:465

dart::dynamics::MetaSkeleton::setAccelerationUpperLimits
void setAccelerationUpperLimits(const Eigen::VectorXd &accelerations)
Set the upper limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:773

dart::dynamics::MetaSkeleton::getVelocity
double getVelocity(std::size_t _index) const
Get the velocity of a single generalized coordinate.
Definition MetaSkeleton.cpp:531

dart::dynamics::MetaSkeleton::eachBodyNode
void eachBodyNode(Func func) const
Iterates all the BodyNodes in this MetaSkeleton and invokes the callback function.
Definition MetaSkeleton-impl.hpp:42

dart::dynamics::MetaSkeleton::eachDof
void eachDof(Func func) const
Iterates all the DegreeOfFreedoms in this MetaSkeleton and invokes the callback function.
Definition MetaSkeleton-impl.hpp:134

dart::dynamics::MetaSkeleton::getInvMassMatrix
virtual const Eigen::MatrixXd & getInvMassMatrix() const =0
Get inverse of Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::setPositionUpperLimits
void setPositionUpperLimits(const Eigen::VectorXd &positions)
Set the upper limits for all generalized coordinates.
Definition MetaSkeleton.cpp:487

dart::dynamics::MetaSkeleton::getCOMJacobian
virtual math::Jacobian getCOMJacobian(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM Jacobian in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::resetGeneralizedForces
void resetGeneralizedForces()
Set all forces of the generalized coordinates to zero.
Definition MetaSkeleton.cpp:859

dart::dynamics::MetaSkeleton::setCommand
void setCommand(std::size_t _index, double _command)
Set a single command.
Definition MetaSkeleton.cpp:336

dart::dynamics::MetaSkeleton::setVelocityUpperLimit
void setVelocityUpperLimit(std::size_t _index, double _velocity)
Set the upper limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:619

dart::dynamics::MetaSkeleton::getNumBodyNodes
virtual std::size_t getNumBodyNodes() const =0
Get number of body nodes.

dart::dynamics::MetaSkeleton::setAccelerationLowerLimit
void setAccelerationLowerLimit(std::size_t _index, double _acceleration)
Set the lower limit of a generalized coordinate's acceleration.
Definition MetaSkeleton.cpp:714

dart::dynamics::MetaSkeleton::getForceLowerLimit
double getForceLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:889

dart::dynamics::MetaSkeleton::resetVelocities
void resetVelocities()
Set all velocities to zero.
Definition MetaSkeleton.cpp:569

dart::dynamics::MetaSkeleton::getJacobianClassicDeriv
virtual math::Jacobian getJacobianClassicDeriv(const JacobianNode *_node) const =0
Get the spatial Jacobian (classical) time derivative targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getVelocityUpperLimits
Eigen::VectorXd getVelocityUpperLimits() const
Get the upper limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:648

dart::dynamics::MetaSkeleton::getConstraintForces
virtual const Eigen::VectorXd & getConstraintForces() const =0
Get constraint force vector.

dart::dynamics::MetaSkeleton::getDof
virtual DegreeOfFreedom * getDof(std::size_t _idx)=0
Get degree of freedom (aka generalized coordinate) whose index is _idx.

dart::dynamics::MetaSkeleton::getVelocityLowerLimits
Eigen::VectorXd getVelocityLowerLimits() const
Get the lower limits for all generalized coordinates's velocity.
Definition MetaSkeleton.cpp:604

dart::dynamics::MetaSkeleton::setForces
void setForces(const Eigen::VectorXd &_forces)
Set the forces of all generalized coordinates.
Definition MetaSkeleton.cpp:830

dart::dynamics::MetaSkeleton::setColor
void setColor(const Eigen::Vector3d &color)
Sets the RGB color of the BodyNodes that are currently in this MetaSkeleton.
Definition MetaSkeleton.cpp:1118

dart::dynamics::MetaSkeleton::setVelocities
void setVelocities(const Eigen::VectorXd &_velocities)
Set the velocities of all generalized coordinates.
Definition MetaSkeleton.cpp:538

dart::dynamics::MetaSkeleton::getVelocities
Eigen::VectorXd getVelocities() const
Get the velocities for all generalized coordinates.
Definition MetaSkeleton.cpp:554

dart::dynamics::MetaSkeleton::setName
virtual const std::string & setName(const std::string &_name)=0
Set the name of this MetaSkeleton.

dart::dynamics::MetaSkeleton::getPositionLowerLimit
double getPositionLowerLimit(std::size_t _index) const
Get the lower limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:458

dart::dynamics::MetaSkeleton::setPositionLowerLimit
void setPositionLowerLimit(std::size_t _index, double _position)
Set the lower limit of a generalized coordinate's position.
Definition MetaSkeleton.cpp:436

dart::dynamics::MetaSkeleton::setPositions
void setPositions(const Eigen::VectorXd &_positions)
Set the positions for all generalized coordinates.
Definition MetaSkeleton.cpp:400

dart::dynamics::MetaSkeleton::getPosition
double getPosition(std::size_t _index) const
Get the position of a single generalized coordinate.
Definition MetaSkeleton.cpp:393

dart::dynamics::MetaSkeleton::setCommands
void setCommands(const Eigen::VectorXd &_commands)
Set commands for all generalized coordinates.
Definition MetaSkeleton.cpp:350

dart::dynamics::MetaSkeleton::clearInternalForces
virtual void clearInternalForces()=0
Clear the internal forces of the BodyNodes in this MetaSkeleton.

dart::dynamics::MetaSkeleton::hasJoint
virtual bool hasJoint(const Joint *joint) const =0
Returns whether this Skeleton contains join.

dart::dynamics::MetaSkeleton::getCOMSpatialVelocity
virtual Eigen::Vector6d getCOMSpatialVelocity(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM spatial velocity in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::getCoriolisAndGravityForces
virtual const Eigen::VectorXd & getCoriolisAndGravityForces() const =0
Get combined vector of Coriolis force and gravity force of the MetaSkeleton.

dart::dynamics::MetaSkeleton::getAugMassMatrix
virtual const Eigen::MatrixXd & getAugMassMatrix() const =0
Get augmented mass matrix of the skeleton.

dart::dynamics::MetaSkeleton::getJacobian
virtual math::Jacobian getJacobian(const JacobianNode *_node) const =0
Get the spatial Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getForceLowerLimits
Eigen::VectorXd getForceLowerLimits() const
Get the lower limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:896

dart::dynamics::MetaSkeleton::getCOMJacobianSpatialDeriv
virtual math::Jacobian getCOMJacobianSpatialDeriv(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM Jacobian spatial time derivative in terms of any Frame (default is World Frame...

dart::dynamics::MetaSkeleton::getForceUpperLimits
Eigen::VectorXd getForceUpperLimits() const
Get the upper limits for all generalized coordinates's force.
Definition MetaSkeleton.cpp:940

dart::dynamics::MetaSkeleton::getCoriolisForces
virtual const Eigen::VectorXd & getCoriolisForces() const =0
Get Coriolis force vector of the MetaSkeleton's BodyNodes.

dart::dynamics::MetaSkeleton::getExternalForces
virtual const Eigen::VectorXd & getExternalForces() const =0
Get external force vector of the MetaSkeleton.

dart::dynamics::MetaSkeleton::setAlpha
void setAlpha(double alpha)
Sets the alpha component of the BodyNodes that are currently in this MetaSkeleton.
Definition MetaSkeleton.cpp:1130

dart::dynamics::MetaSkeleton::getAccelerationLowerLimits
Eigen::VectorXd getAccelerationLowerLimits() const
Get the lower limits for all generalized coordinates's acceleration.
Definition MetaSkeleton.cpp:750

dart::dynamics::MetaSkeleton::getPositions
Eigen::VectorXd getPositions() const
Get the positions for all generalized coordinates.
Definition MetaSkeleton.cpp:415

dart::dynamics::MetaSkeleton::cloneMetaSkeleton
MetaSkeletonPtr cloneMetaSkeleton() const
Creates an identical clone of this MetaSkeleton.
Definition MetaSkeleton.cpp:330

dart::dynamics::MetaSkeleton::getAcceleration
double getAcceleration(std::size_t _index) const
Get the acceleration of a single generalized coordinate.
Definition MetaSkeleton.cpp:670

dart::dynamics::MetaSkeleton::setPositionLowerLimits
void setPositionLowerLimits(const Eigen::VectorXd &positions)
Set the lower limits for all generalized coordinates.
Definition MetaSkeleton.cpp:443

dart::dynamics::MetaSkeleton::getIndexOf
virtual std::size_t getIndexOf(const BodyNode *_bn, bool _warning=true) const =0
Get the index of a specific BodyNode within this ReferentialSkeleton.

dart::dynamics::MetaSkeleton::getVelocityUpperLimit
double getVelocityUpperLimit(std::size_t _index)
Get the upper limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:641

dart::dynamics::MetaSkeleton::setForceUpperLimit
void setForceUpperLimit(std::size_t _index, double _force)
Set the upper limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:911

dart::dynamics::MetaSkeleton::setForceLowerLimit
void setForceLowerLimit(std::size_t _index, double _force)
Set the lower limit of a generalized coordinate's force.
Definition MetaSkeleton.cpp:867

dart::dynamics::MetaSkeleton::setAccelerations
void setAccelerations(const Eigen::VectorXd &_accelerations)
Set the accelerations of all generalized coordinates.
Definition MetaSkeleton.cpp:677

dart::dynamics::MetaSkeleton::getVelocityChanges
Eigen::VectorXd getVelocityChanges() const
Get the velocity changes for all the generalized coordinates.
Definition MetaSkeleton.cpp:955

dart::dynamics::MetaSkeleton::setPositionUpperLimit
void setPositionUpperLimit(std::size_t _index, double _position)
Set the upper limit of a generalized coordainte's position.
Definition MetaSkeleton.cpp:480

dart::dynamics::MetaSkeleton::getAngularJacobian
virtual math::AngularJacobian getAngularJacobian(const JacobianNode *_node, const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the angular Jacobian of a BodyNode.

dart::dynamics::MetaSkeleton::MetaSkeleton
MetaSkeleton(const MetaSkeleton &)=delete

dart::dynamics::MetaSkeleton::getCOMLinearJacobianDeriv
virtual math::LinearJacobian getCOMLinearJacobianDeriv(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM Linear Jacobian time derivative in terms of any Frame (default is World Frame)...

dart::dynamics::MetaSkeleton::getWorldJacobian
virtual math::Jacobian getWorldJacobian(const JacobianNode *_node) const =0
Get the spatial Jacobian targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::onNameChanged
common::SlotRegister< NameChangedSignal > onNameChanged
Definition MetaSkeleton.hpp:1024

dart::dynamics::MetaSkeleton::computeKineticEnergy
virtual double computeKineticEnergy() const =0
Get the kinetic energy of this MetaSkeleton.

dart::dynamics::MetaSkeleton::setVelocityLowerLimit
void setVelocityLowerLimit(std::size_t _index, double _velocity)
Set the lower limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:575

dart::dynamics::MetaSkeleton::getJacobianSpatialDeriv
virtual math::Jacobian getJacobianSpatialDeriv(const JacobianNode *_node) const =0
Get the spatial Jacobian time derivative targeting the origin of a BodyNode.

dart::dynamics::MetaSkeleton::getVelocityLowerLimit
double getVelocityLowerLimit(std::size_t _index)
Get the lower limit of a generalized coordinate's velocity.
Definition MetaSkeleton.cpp:597

dart::dynamics::MetaSkeleton::computePotentialEnergy
virtual double computePotentialEnergy() const =0
Get the potential energy of this MetaSkeleton.

dart::dynamics::MetaSkeleton::getCommand
double getCommand(std::size_t _index) const
Get a single command.
Definition MetaSkeleton.cpp:343

dart::dynamics::MetaSkeleton::getAccelerations
Eigen::VectorXd getAccelerations() const
Get the accelerations for all generalized coordinates.
Definition MetaSkeleton.cpp:693

dart::dynamics::MetaSkeleton::getCOMSpatialAcceleration
virtual Eigen::Vector6d getCOMSpatialAcceleration(const Frame *_relativeTo=Frame::World(), const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the Skeleton's COM spatial acceleration in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::computeLagrangian
double computeLagrangian() const
Compute and return Lagrangian of this MetaSkeleton.
Definition MetaSkeleton.cpp:1100

dart::dynamics::MetaSkeleton::getCOMLinearJacobian
virtual math::LinearJacobian getCOMLinearJacobian(const Frame *_inCoordinatesOf=Frame::World()) const =0
Get the MetaSkeleton's COM Linear Jacobian in terms of any Frame (default is World Frame)

dart::dynamics::MetaSkeleton::cloneMetaSkeleton
virtual MetaSkeletonPtr cloneMetaSkeleton(const std::string &cloneName) const =0
Creates an identical clone of this MetaSkeleton.

dart::dynamics::MetaSkeleton::getJoints
virtual std::vector< Joint * > getJoints()=0
Returns all the joints that are held by this MetaSkeleton.

dart::dynamics::MetaSkeleton::getName
virtual const std::string & getName() const =0
Get the name of this MetaSkeleton.

dart::dynamics::MetaSkeleton::setJointConstraintImpulses
void setJointConstraintImpulses(const Eigen::VectorXd &_impulses)
Set the constraint impulses for the generalized coordinates.
Definition MetaSkeleton.cpp:962

dart::dynamics::MetaSkeleton::getJointConstraintImpulses
Eigen::VectorXd getJointConstraintImpulses() const
Get the constraint impulses for the generalized coordinates.
Definition MetaSkeleton.cpp:969

dart::dynamics::MetaSkeleton::getNumDofs
virtual std::size_t getNumDofs() const =0
Return the number of degrees of freedom in this skeleton.

dart::dynamics::MetaSkeleton::getInvAugMassMatrix
virtual const Eigen::MatrixXd & getInvAugMassMatrix() const =0
Get inverse of augmented Mass Matrix of the MetaSkeleton.

dart::dynamics::MetaSkeleton::setVelocity
void setVelocity(std::size_t _index, double _velocity)
Set the velocity of a single generalized coordinate.
Definition MetaSkeleton.cpp:524

dart::dynamics::MetaSkeleton::getBodyNode
virtual const BodyNode * getBodyNode(std::size_t _idx) const =0
Get const BodyNode whose index is _idx.

Eigen
Definition Random-impl.hpp:92

dart::dynamics::MetaSkeletonPtr
std::shared_ptr< MetaSkeleton > MetaSkeletonPtr
Definition SmartPointer.hpp:68

dart
Definition BulletCollisionDetector.cpp:60