DART  6.10.1
dart::constraint Namespace Reference

Classes

class  BalanceConstraint
 BalanceConstraint is a kinematic constraint function designed to be passed into a HierarchicalIK module. More...
 
class  BallJointConstraint
 BallJointConstraint represents ball joint constraint between a body and the world or between two bodies. More...
 
class  BoxedLcpConstraintSolver
 
class  BoxedLcpSolver
 
class  ConstrainedGroup
 ConstrainedGroup is a group of skeletons that interact each other with constraints. More...
 
struct  ConstraintInfo
 ConstraintInfo. More...
 
class  ConstraintBase
 Constraint is a base class of concrete constraints classes. More...
 
class  ConstraintSolver
 ConstraintSolver manages constraints and computes constraint impulses. More...
 
class  ContactConstraint
 ContactConstraint represents a contact constraint between two bodies. More...
 
class  DantzigBoxedLcpSolver
 
class  DantzigLCPSolver
 
class  JointConstraint
 class JointConstraint More...
 
class  JointCoulombFrictionConstraint
 Joint Coulomb friction constraint. More...
 
class  JointLimitConstraint
 JointLimitConstraint handles joint position and velocity limits. More...
 
class  LCPSolver
 
class  MimicMotorConstraint
 Servo motor constraint. More...
 
class  PgsBoxedLcpSolver
 Implementation of projected Gauss-Seidel (PGS) LCP solver. More...
 
class  PGSLCPSolver
 
struct  PGSOption
 
class  ServoMotorConstraint
 Servo motor constraint. More...
 
class  SoftContactConstraint
 SoftContactConstraint represents a contact constraint between two bodies. More...
 
class  WeldJointConstraint
 WeldJointConstraint represents weld joint constraint between a body and the world or between two bodies. More...
 

Typedefs

using ConstraintSolverPtr = std::shared_ptr< ConstraintSolver >
 
using ConstConstraintSolverPtr = std::shared_ptr< const ConstraintSolver >
 
using WeakConstraintSolverPtr = std::weak_ptr< ConstraintSolver >
 
using WeakConstConstraintSolverPtr = std::weak_ptr< const ConstraintSolver >
 
using UniqueConstraintSolverPtr = std::unique_ptr< ConstraintSolver >
 
using UniqueConstConstraintSolverPtr = std::unique_ptr< const ConstraintSolver >
 
using ConstrainedGroupPtr = std::shared_ptr< ConstrainedGroup >
 
using ConstConstrainedGroupPtr = std::shared_ptr< const ConstrainedGroup >
 
using WeakConstrainedGroupPtr = std::weak_ptr< ConstrainedGroup >
 
using WeakConstConstrainedGroupPtr = std::weak_ptr< const ConstrainedGroup >
 
using ConstraintBasePtr = std::shared_ptr< ConstraintBase >
 
using ConstConstraintBasePtr = std::shared_ptr< const ConstraintBase >
 
using WeakConstraintBasePtr = std::weak_ptr< ConstraintBase >
 
using WeakConstConstraintBasePtr = std::weak_ptr< const ConstraintBase >
 
using ClosedLoopConstraintPtr = std::shared_ptr< ClosedLoopConstraint >
 
using ConstClosedLoopConstraintPtr = std::shared_ptr< const ClosedLoopConstraint >
 
using WeakClosedLoopConstraintPtr = std::weak_ptr< ClosedLoopConstraint >
 
using WeakConstClosedLoopConstraintPtr = std::weak_ptr< const ClosedLoopConstraint >
 
using ContactConstraintPtr = std::shared_ptr< ContactConstraint >
 
using ConstContactConstraintPtr = std::shared_ptr< const ContactConstraint >
 
using WeakContactConstraintPtr = std::weak_ptr< ContactConstraint >
 
using WeakConstContactConstraintPtr = std::weak_ptr< const ContactConstraint >
 
using SoftContactConstraintPtr = std::shared_ptr< SoftContactConstraint >
 
using ConstSoftContactConstraintPtr = std::shared_ptr< const SoftContactConstraint >
 
using WeakSoftContactConstraintPtr = std::weak_ptr< SoftContactConstraint >
 
using WeakConstSoftContactConstraintPtr = std::weak_ptr< const SoftContactConstraint >
 
using JointLimitConstraintPtr = std::shared_ptr< JointLimitConstraint >
 
using ConstJointLimitConstraintPtr = std::shared_ptr< const JointLimitConstraint >
 
using WeakJointLimitConstraintPtr = std::weak_ptr< JointLimitConstraint >
 
using WeakConstJointLimitConstraintPtr = std::weak_ptr< const JointLimitConstraint >
 
using ServoMotorConstraintPtr = std::shared_ptr< ServoMotorConstraint >
 
using ConstServoMotorConstraintPtr = std::shared_ptr< const ServoMotorConstraint >
 
using WeakServoMotorConstraintPtr = std::weak_ptr< ServoMotorConstraint >
 
using WeakConstServoMotorConstraintPtr = std::weak_ptr< const ServoMotorConstraint >
 
using MimicMotorConstraintPtr = std::shared_ptr< MimicMotorConstraint >
 
using ConstMimicMotorConstraintPtr = std::shared_ptr< const MimicMotorConstraint >
 
using WeakMimicMotorConstraintPtr = std::weak_ptr< MimicMotorConstraint >
 
using WeakConstMimicMotorConstraintPtr = std::weak_ptr< const MimicMotorConstraint >
 
using JointCoulombFrictionConstraintPtr = std::shared_ptr< JointCoulombFrictionConstraint >
 
using ConstJointCoulombFrictionConstraintPtr = std::shared_ptr< const JointCoulombFrictionConstraint >
 
using WeakJointCoulombFrictionConstraintPtr = std::weak_ptr< JointCoulombFrictionConstraint >
 
using WeakConstJointCoulombFrictionConstraintPtr = std::weak_ptr< const JointCoulombFrictionConstraint >
 
using LCPSolverPtr = std::shared_ptr< LCPSolver >
 
using ConstLCPSolverPtr = std::shared_ptr< const LCPSolver >
 
using WeakLCPSolverPtr = std::weak_ptr< LCPSolver >
 
using WeakConstLCPSolverPtr = std::weak_ptr< const LCPSolver >
 
using BoxedLcpSolverPtr = std::shared_ptr< BoxedLcpSolver >
 
using ConstBoxedLcpSolverPtr = std::shared_ptr< const BoxedLcpSolver >
 
using WeakBoxedLcpSolverPtr = std::weak_ptr< BoxedLcpSolver >
 
using WeakConstBoxedLcpSolverPtr = std::weak_ptr< const BoxedLcpSolver >
 
using PgsBoxedLcpSolverPtr = std::shared_ptr< PgsBoxedLcpSolver >
 
using ConstPgsBoxedLcpSolverPtr = std::shared_ptr< const PgsBoxedLcpSolver >
 
using WeakPgsBoxedLcpSolverPtr = std::weak_ptr< PgsBoxedLcpSolver >
 
using WeakConstPgsBoxedLcpSolverPtr = std::weak_ptr< const PgsBoxedLcpSolver >
 
using PsorBoxedLcpSolverPtr = std::shared_ptr< PsorBoxedLcpSolver >
 
using ConstPsorBoxedLcpSolverPtr = std::shared_ptr< const PsorBoxedLcpSolver >
 
using WeakPsorBoxedLcpSolverPtr = std::weak_ptr< PsorBoxedLcpSolver >
 
using WeakConstPsorBoxedLcpSolverPtr = std::weak_ptr< const PsorBoxedLcpSolver >
 
using JacobiBoxedLcpSolverPtr = std::shared_ptr< JacobiBoxedLcpSolver >
 
using ConstJacobiBoxedLcpSolverPtr = std::shared_ptr< const JacobiBoxedLcpSolver >
 
using WeakJacobiBoxedLcpSolverPtr = std::weak_ptr< JacobiBoxedLcpSolver >
 
using WeakConstJacobiBoxedLcpSolverPtr = std::weak_ptr< const JacobiBoxedLcpSolver >
 
using JointConstraintPtr = std::shared_ptr< JointConstraint >
 
using ConstJointConstraintPtr = std::shared_ptr< const JointConstraint >
 
using WeakJointConstraintPtr = std::weak_ptr< JointConstraint >
 
using WeakConstJointConstraintPtr = std::weak_ptr< const JointConstraint >
 
using BallJointConstraintPtr = std::shared_ptr< BallJointConstraint >
 
using ConstBallJointConstraintPtr = std::shared_ptr< const BallJointConstraint >
 
using WeakBallJointConstraintPtr = std::weak_ptr< BallJointConstraint >
 
using WeakConstBallJointConstraintPtr = std::weak_ptr< const BallJointConstraint >
 
using WeldJointConstraintPtr = std::shared_ptr< WeldJointConstraint >
 
using ConstWeldJointConstraintPtr = std::shared_ptr< const WeldJointConstraint >
 
using WeakWeldJointConstraintPtr = std::weak_ptr< WeldJointConstraint >
 
using WeakConstWeldJointConstraintPtr = std::weak_ptr< const WeldJointConstraint >
 
using BalanceConstraintPtr = std::shared_ptr< BalanceConstraint >
 
using ConstBalanceConstraintPtr = std::shared_ptr< const BalanceConstraint >
 
using WeakBalanceConstraintPtr = std::weak_ptr< BalanceConstraint >
 
using WeakConstBalanceConstraintPtr = std::weak_ptr< const BalanceConstraint >
 

Functions

template<typename JacType >
static void addDampedPseudoInverseToGradient (Eigen::Map< Eigen::VectorXd > &grad, const JacType &J, const Eigen::MatrixXd &nullspace, const Eigen::Vector3d &error, double damping)
 
bool solvePGS (int n, int nskip, int, double *A, double *x, double *b, double *lo, double *hi, int *findex, PGSOption *option)
 
template<typename PointMassT , typename SoftBodyNodeT >
static PointMassT selectCollidingPointMassT (SoftBodyNodeT _softBodyNode, const Eigen::Vector3d &_point, int _faceId)
 

Variables

constexpr double DART_DEFAULT_FRICTION_COEFF = 1.0
 
constexpr double DART_DEFAULT_RESTITUTION_COEFF = 0.0
 
constexpr double DART_DEFAULT_SLIP_COMPLIANCE = 0.0
 
const Eigen::Vector3d DART_DEFAULT_FRICTION_DIR = Eigen::Vector3d::UnitZ()
 

Typedef Documentation

◆ BalanceConstraintPtr

using dart::constraint::BalanceConstraintPtr = typedef std::shared_ptr< BalanceConstraint >

◆ BallJointConstraintPtr

◆ BoxedLcpSolverPtr

using dart::constraint::BoxedLcpSolverPtr = typedef std::shared_ptr< BoxedLcpSolver >

◆ ClosedLoopConstraintPtr

using dart::constraint::ClosedLoopConstraintPtr = typedef std::shared_ptr< ClosedLoopConstraint >

◆ ConstBalanceConstraintPtr

using dart::constraint::ConstBalanceConstraintPtr = typedef std::shared_ptr<const BalanceConstraint >

◆ ConstBallJointConstraintPtr

using dart::constraint::ConstBallJointConstraintPtr = typedef std::shared_ptr<const BallJointConstraint >

◆ ConstBoxedLcpSolverPtr

using dart::constraint::ConstBoxedLcpSolverPtr = typedef std::shared_ptr<const BoxedLcpSolver >

◆ ConstClosedLoopConstraintPtr

using dart::constraint::ConstClosedLoopConstraintPtr = typedef std::shared_ptr<const ClosedLoopConstraint >

◆ ConstConstrainedGroupPtr

using dart::constraint::ConstConstrainedGroupPtr = typedef std::shared_ptr<const ConstrainedGroup >

◆ ConstConstraintBasePtr

using dart::constraint::ConstConstraintBasePtr = typedef std::shared_ptr<const ConstraintBase >

◆ ConstConstraintSolverPtr

using dart::constraint::ConstConstraintSolverPtr = typedef std::shared_ptr<const ConstraintSolver >

◆ ConstContactConstraintPtr

using dart::constraint::ConstContactConstraintPtr = typedef std::shared_ptr<const ContactConstraint >

◆ ConstJacobiBoxedLcpSolverPtr

using dart::constraint::ConstJacobiBoxedLcpSolverPtr = typedef std::shared_ptr<const JacobiBoxedLcpSolver >

◆ ConstJointConstraintPtr

using dart::constraint::ConstJointConstraintPtr = typedef std::shared_ptr<const JointConstraint >

◆ ConstJointCoulombFrictionConstraintPtr

◆ ConstJointLimitConstraintPtr

◆ ConstLCPSolverPtr

using dart::constraint::ConstLCPSolverPtr = typedef std::shared_ptr<const LCPSolver >

◆ ConstMimicMotorConstraintPtr

◆ ConstPgsBoxedLcpSolverPtr

using dart::constraint::ConstPgsBoxedLcpSolverPtr = typedef std::shared_ptr<const PgsBoxedLcpSolver >

◆ ConstPsorBoxedLcpSolverPtr

using dart::constraint::ConstPsorBoxedLcpSolverPtr = typedef std::shared_ptr<const PsorBoxedLcpSolver >

◆ ConstrainedGroupPtr

using dart::constraint::ConstrainedGroupPtr = typedef std::shared_ptr< ConstrainedGroup >

◆ ConstraintBasePtr

using dart::constraint::ConstraintBasePtr = typedef std::shared_ptr< ConstraintBase >

◆ ConstraintSolverPtr

using dart::constraint::ConstraintSolverPtr = typedef std::shared_ptr< ConstraintSolver >

◆ ConstServoMotorConstraintPtr

◆ ConstSoftContactConstraintPtr

◆ ConstWeldJointConstraintPtr

using dart::constraint::ConstWeldJointConstraintPtr = typedef std::shared_ptr<const WeldJointConstraint >

◆ ContactConstraintPtr

using dart::constraint::ContactConstraintPtr = typedef std::shared_ptr< ContactConstraint >

◆ JacobiBoxedLcpSolverPtr

using dart::constraint::JacobiBoxedLcpSolverPtr = typedef std::shared_ptr< JacobiBoxedLcpSolver >

◆ JointConstraintPtr

using dart::constraint::JointConstraintPtr = typedef std::shared_ptr< JointConstraint >

◆ JointCoulombFrictionConstraintPtr

◆ JointLimitConstraintPtr

◆ LCPSolverPtr

using dart::constraint::LCPSolverPtr = typedef std::shared_ptr< LCPSolver >

◆ MimicMotorConstraintPtr

◆ PgsBoxedLcpSolverPtr

using dart::constraint::PgsBoxedLcpSolverPtr = typedef std::shared_ptr< PgsBoxedLcpSolver >

◆ PsorBoxedLcpSolverPtr

using dart::constraint::PsorBoxedLcpSolverPtr = typedef std::shared_ptr< PsorBoxedLcpSolver >

◆ ServoMotorConstraintPtr

◆ SoftContactConstraintPtr

◆ UniqueConstConstraintSolverPtr

using dart::constraint::UniqueConstConstraintSolverPtr = typedef std::unique_ptr<const ConstraintSolver >

◆ UniqueConstraintSolverPtr

◆ WeakBalanceConstraintPtr

◆ WeakBallJointConstraintPtr

◆ WeakBoxedLcpSolverPtr

using dart::constraint::WeakBoxedLcpSolverPtr = typedef std::weak_ptr< BoxedLcpSolver >

◆ WeakClosedLoopConstraintPtr

using dart::constraint::WeakClosedLoopConstraintPtr = typedef std::weak_ptr< ClosedLoopConstraint >

◆ WeakConstBalanceConstraintPtr

◆ WeakConstBallJointConstraintPtr

◆ WeakConstBoxedLcpSolverPtr

using dart::constraint::WeakConstBoxedLcpSolverPtr = typedef std::weak_ptr<const BoxedLcpSolver >

◆ WeakConstClosedLoopConstraintPtr

using dart::constraint::WeakConstClosedLoopConstraintPtr = typedef std::weak_ptr<const ClosedLoopConstraint >

◆ WeakConstConstrainedGroupPtr

◆ WeakConstConstraintBasePtr

using dart::constraint::WeakConstConstraintBasePtr = typedef std::weak_ptr<const ConstraintBase >

◆ WeakConstConstraintSolverPtr

◆ WeakConstContactConstraintPtr

◆ WeakConstJacobiBoxedLcpSolverPtr

using dart::constraint::WeakConstJacobiBoxedLcpSolverPtr = typedef std::weak_ptr<const JacobiBoxedLcpSolver >

◆ WeakConstJointConstraintPtr

using dart::constraint::WeakConstJointConstraintPtr = typedef std::weak_ptr<const JointConstraint >

◆ WeakConstJointCoulombFrictionConstraintPtr

◆ WeakConstJointLimitConstraintPtr

◆ WeakConstLCPSolverPtr

using dart::constraint::WeakConstLCPSolverPtr = typedef std::weak_ptr<const LCPSolver >

◆ WeakConstMimicMotorConstraintPtr

◆ WeakConstPgsBoxedLcpSolverPtr

◆ WeakConstPsorBoxedLcpSolverPtr

using dart::constraint::WeakConstPsorBoxedLcpSolverPtr = typedef std::weak_ptr<const PsorBoxedLcpSolver >

◆ WeakConstrainedGroupPtr

◆ WeakConstraintBasePtr

using dart::constraint::WeakConstraintBasePtr = typedef std::weak_ptr< ConstraintBase >

◆ WeakConstraintSolverPtr

◆ WeakConstServoMotorConstraintPtr

◆ WeakConstSoftContactConstraintPtr

◆ WeakConstWeldJointConstraintPtr

◆ WeakContactConstraintPtr

◆ WeakJacobiBoxedLcpSolverPtr

using dart::constraint::WeakJacobiBoxedLcpSolverPtr = typedef std::weak_ptr< JacobiBoxedLcpSolver >

◆ WeakJointConstraintPtr

◆ WeakJointCoulombFrictionConstraintPtr

◆ WeakJointLimitConstraintPtr

◆ WeakLCPSolverPtr

using dart::constraint::WeakLCPSolverPtr = typedef std::weak_ptr< LCPSolver >

◆ WeakMimicMotorConstraintPtr

◆ WeakPgsBoxedLcpSolverPtr

◆ WeakPsorBoxedLcpSolverPtr

using dart::constraint::WeakPsorBoxedLcpSolverPtr = typedef std::weak_ptr< PsorBoxedLcpSolver >

◆ WeakServoMotorConstraintPtr

◆ WeakSoftContactConstraintPtr

◆ WeakWeldJointConstraintPtr

◆ WeldJointConstraintPtr

Function Documentation

◆ addDampedPseudoInverseToGradient()

template<typename JacType >
static void dart::constraint::addDampedPseudoInverseToGradient ( Eigen::Map< Eigen::VectorXd > &  grad,
const JacType &  J,
const Eigen::MatrixXd &  nullspace,
const Eigen::Vector3d &  error,
double  damping 
)
static

◆ selectCollidingPointMassT()

template<typename PointMassT , typename SoftBodyNodeT >
static PointMassT dart::constraint::selectCollidingPointMassT ( SoftBodyNodeT  _softBodyNode,
const Eigen::Vector3d &  _point,
int  _faceId 
)
static

◆ solvePGS()

bool dart::constraint::solvePGS ( int  n,
int  nskip,
int  ,
double *  A,
double *  x,
double *  b,
double *  lo,
double *  hi,
int *  findex,
PGSOption option 
)

Variable Documentation

◆ DART_DEFAULT_FRICTION_COEFF

constexpr double dart::constraint::DART_DEFAULT_FRICTION_COEFF = 1.0
constexpr

◆ DART_DEFAULT_FRICTION_DIR

const Eigen::Vector3d dart::constraint::DART_DEFAULT_FRICTION_DIR = Eigen::Vector3d::UnitZ()

◆ DART_DEFAULT_RESTITUTION_COEFF

constexpr double dart::constraint::DART_DEFAULT_RESTITUTION_COEFF = 0.0
constexpr

◆ DART_DEFAULT_SLIP_COMPLIANCE

constexpr double dart::constraint::DART_DEFAULT_SLIP_COMPLIANCE = 0.0
constexpr