Manager for a set of TSR constraints. Attempts to reduce redundancy and combines errors and Jacobians together. More...

#include <tsr.h>

Public Member Functions
void	print (std::ostream &out) const
	Print out the TSRs in this set. More...

Constructor and Initialization
	TSRSet (const WorldPtr &world, const TSRPtr &tsr)
	Constructor. More...

	TSRSet (const WorldPtr &world, const std::vector< TSRPtr > &tsrs, bool intersect=true)
	Constructor. More...

void	setWorld (const WorldPtr &world)
	Set the world used by this TSR set. More...

void	addTSR (const TSRPtr &tsr, bool intersect=true, double weight=1.0)
	Add a TSR to the set. More...

void	initialize ()
	Initialize this set of TSRs. More...

void	updateSolver ()
	Update the solver information (iterations, tolerance, etc.) More...

DoF Indexing
void	useGroup (const std::string &name)
	Use the joints in a robot's group. Robot used is the target frame's structure. More...

void	useIndices (const std::vector< std::size_t > &indices)
	Use DoF indices for all TSRs computation. More...

void	useWorldIndices (const std::vector< std::pair< std::size_t, std::size_t >> &indices)
	Use World DoF indices for all TSRs computation. World indices are pairs of skeleton index and DoF index. More...

void	setWorldIndices (const std::vector< std::pair< std::size_t, std::size_t >> &indices)
	Output world indices. TSR information for *WorldState methods uses this set of world indices. World indices are pairs of skeleton index and DoF index. More...

const std::vector< std::pair< std::size_t, std::size_t > > &	getWorldIndices () const
	Get the world indices used. More...

void	setWorldUpperLimits (const Eigen::Ref< const Eigen::VectorXd > &upper)
	Set the upper limit on joints given their index in the world configuration. More...

void	setWorldLowerLimits (const Eigen::Ref< const Eigen::VectorXd > &lower)
	Set the lower limit on joints given their index in the world configuration. More...

void	computeLimits ()
	Compute the upper and lower limits from the skeleton. More...

Getters
void	getPositionsWorldState (Eigen::Ref< Eigen::VectorXd > world) const
	Get the current world state. More...

std::size_t	getDimension () const
	Get the error dimension of this set of TSRs. More...

std::size_t	numTSRs () const
	Get the number of TSRs in the set. More...

const std::vector< TSRPtr > &	getTSRs () const
	Get the TSRs that form the set. More...

double	getTolerance () const
	Get the numerical tolerance for solving. More...

void	setTolerance (double tolerance)
	Set the maximum tolerance used for solving. More...

std::size_t	getMaxIterations () const
	Get the maximum iterations allowed. More...

void	setMaxIterations (std::size_t iterations)
	Set the maximum iterations used for solving. More...

void	addSuffix (const std::string &suffix)
	Add a suffix to the end of all structures in the TSRs in the set. More...

void	setStep (double step)
	Set the step parameter in the solver. More...

double	getStep () const
	Get the solver step parameter. More...

void	setLimit (double limit)
	Set the limit parameter in the solver. More...

double	getLimit () const
	Get the solver limit parameter. More...

void	setDamping (double damping)
	Set the damping parameter in the solver. More...

double	getDamping () const
	Get the solver damping parameter. More...

void	useDamping (bool damping)
	Set if damping is used in SVD solving. More...

void	useSVD ()
	Use SVD for solving. More...

void	useQR ()
	Use QR for solving. More...

Error / Function Computation
void	getErrorWorld (Eigen::Ref< Eigen::VectorXd > error) const
	Get the current error given the world state. More...

void	getErrorWorldState (const Eigen::Ref< const Eigen::VectorXd > &world, Eigen::Ref< Eigen::VectorXd > error) const
	Get the error given a provided world configuration. More...

Jacobian Computation
void	getJacobianWorldState (const Eigen::Ref< const Eigen::VectorXd > &world, Eigen::Ref< Eigen::MatrixXd > jacobian) const
	Get the Jacobian given a provided world configuration. More...

Distance Computation
double	distanceWorld () const
	Get the current distance to satisfaction given the world state. More...

double	distanceWorldState (const Eigen::Ref< const Eigen::VectorXd > &world) const
	Get the distance to satisfaction given a provided world configuration. More...

Solving for Satisfying Configurations
bool	solveWorld ()
	Solve for a satisfying configuration given the current state of the world. More...

bool	solveWorldState (Eigen::Ref< Eigen::VectorXd > world)
	Solve for a satisfying configuration given an initial world configuration. More...

bool	solveGradientWorldState (Eigen::Ref< Eigen::VectorXd > world)
	Solve using gradient descent for a satisfying configuration given an initial world configuration. More...

Private Member Functions
void	enforceBoundsWorld (Eigen::Ref< Eigen::VectorXd > world) const
	Enforce upper and lower bounds on a world configuration. More...

Private Attributes
WorldPtr	world_
	World to use. More...

std::set< std::size_t >	skel_indices_
	All skeleton indices used by members of the set. More...

bool	qr_ {false}
	If true, use QR in gradient solve. Else, SVD. More...

bool	damped_ {true}
	If true, use damped SVD. More...

double	step_ {1.0}
	Step scaling in gradient. More...

double	limit_ {1.}
	Step size limit. More...

double	damping_ {1e-8}
	Damping factor. More...

double	tolerance_ {magic::DEFAULT_IK_TOLERANCE}
	Tolerance for solving. More...

std::size_t	maxIter_ {50}
	Maximum iterations to use for solving. More...

std::vector< TSRPtr >	tsrs_
	Set of TSRs. More...

std::vector< double >	weights_
	Weights on TSRs. More...

std::size_t	dimension_ {0}
	Total error dimension of set. More...

Eigen::VectorXd	upper_
	Upper bounds on world configuration. More...

Eigen::VectorXd	lower_
	Lower bounds on world configuration. More...

Detailed Description

Manager for a set of TSR constraints. Attempts to reduce redundancy and combines errors and Jacobians together.

Will "stack" the error values and Jacobians together. For example, given two TSRs "a" and "b" in the set, the error vector will be [ea, eb] where ea and eb are a and b's error vector. The Jacobian will also correspond to this stacked error vector.

Definition at line 725 of file tsr.h.

Constructor & Destructor Documentation

◆ TSRSet() [1/2]

TSRSet::TSRSet	(	const WorldPtr &	world,
		const TSRPtr &	tsr
	)

Constructor.

Parameters

[in]	world	World to use.
[in]	tsr	TSR to add to set.

TSRSet

Definition at line 928 of file tsr.cpp.

                                                        : world_(world)
 {
     addTSR(tsr);
 }

◆ TSRSet() [2/2]

TSRSet::TSRSet	(	const WorldPtr &	world,
		const std::vector< TSRPtr > &	tsrs,
		bool	intersect = `true`
	)

Constructor.

Parameters

[in]	world	World to use.
[in]	tsrs	TSRs to add to set.
[in]	intersect	If true, tries to simplify TSR set.

Definition at line 933 of file tsr.cpp.

                                                                                    : world_(world)
 {
     for (const auto &tsr : tsrs)
         addTSR(tsr, intersect);
 }

Member Function Documentation

◆ addSuffix()

void TSRSet::addSuffix ( const std::string & suffix )

Add a suffix to the end of all structures in the TSRs in the set.

Parameters

[in] suffix Suffix to add.

Definition at line 992 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->getSpecification().addSuffix(suffix);
 }

◆ addTSR()

void TSRSet::addTSR	(	const TSRPtr &	tsr,
		bool	intersect = `true`,
		double	weight = `1.0`
	)

Add a TSR to the set.

Parameters

[in]	tsr	TSR to add.
[in]	intersect	If true, tries to simplify TSR set.
[in]	weight	Weight to use for this TSR.

Definition at line 939 of file tsr.cpp.

 {
     TSRPtr ntsr = tsr;
     TSR::Specification spec = tsr->getSpecification();
     if (intersect)
     {
         for (auto &etsr : tsrs_)
             // Don't need this entire TSR if we can intersect
             if (etsr->getSpecification().intersect(spec))
             {
                 dimension_ = 0;
                 for (auto &tsr : tsrs_)
                     dimension_ += tsr->getDimension();
                 return;
             }
  
         // copy for intersections later
         ntsr = std::make_shared<TSR>(world_, spec);
         ntsr->useIndices(tsr->getIndices());
         ntsr->setWorldIndices(tsr->getWorldIndices());
  
         // weight relative frames less
         if ((weight - 1.) < constants::eps)
             if (spec.isRelative())
                 weight = 0.1;
     }
  
     tsrs_.emplace_back(ntsr);
     weights_.emplace_back(weight);
  
     dimension_ += ntsr->getDimension();
     tolerance_ = std::min(tolerance_, spec.tolerance);
 }

◆ computeLimits()

void TSRSet::computeLimits ( )

Compute the upper and lower limits from the skeleton.

Definition at line 1242 of file tsr.cpp.

 {
     const auto &wi = getWorldIndices();
     std::size_t n = wi.size();
  
     upper_ = Eigen::VectorXd::Zero(n);
     lower_ = Eigen::VectorXd::Zero(n);
     for (std::size_t i = 0; i < n; ++i)
     {
         const auto &wii = wi[i];
         const auto &dof = world_->getSim()->getSkeleton(wii.first)->getDof(wii.second);
         // if (dof->isCyclic())
         // {
         //     lower_[i] = -constants::pi;
         //     upper_[i] = constants::pi;
         // }
         // else
         // {
         auto limits = dof->getPositionLimits();
         lower_[i] = limits.first;
         upper_[i] = limits.second;
         // }
     }
 }

◆ distanceWorld()

double TSRSet::distanceWorld ( ) const

Get the current distance to satisfaction given the world state.

Returns: Distance to TSR set satisfaction.

Definition at line 1081 of file tsr.cpp.

 {
     Eigen::VectorXd x(getDimension());
     getErrorWorld(x);
     return x.norm();
 }

◆ distanceWorldState()

double TSRSet::distanceWorldState ( const Eigen::Ref< const Eigen::VectorXd > & world ) const

Get the distance to satisfaction given a provided world configuration.

Parameters

[in] world World configuration (from world indices).

Returns: Distance to TSR set satisfaction.

Definition at line 1088 of file tsr.cpp.

 {
     Eigen::VectorXd x(getDimension());
     getErrorWorldState(world, x);
     return x.norm();
 }

◆ enforceBoundsWorld()

void TSRSet::enforceBoundsWorld ( Eigen::Ref< Eigen::VectorXd > world ) const

private

Enforce upper and lower bounds on a world configuration.

Parameters

[in,out] world World configuration to enforce.

Definition at line 1287 of file tsr.cpp.

 {
     if (upper_.size())
         world = world.cwiseMin(upper_);
     if (lower_.size())
         world = world.cwiseMax(lower_);
 }

◆ getDamping()

double TSRSet::getDamping ( ) const

Get the solver damping parameter.

Returns: The solver damping parameter.

Definition at line 1338 of file tsr.cpp.

 {
     return damping_;
 }

◆ getDimension()

std::size_t TSRSet::getDimension ( ) const

Get the error dimension of this set of TSRs.

Returns: The error dimension of the set of TSRs.

Definition at line 1022 of file tsr.cpp.

 {
     return dimension_;
 }

◆ getErrorWorld()

void TSRSet::getErrorWorld ( Eigen::Ref< Eigen::VectorXd > error ) const

Get the current error given the world state.

Parameters

[out] error Error value for all TSRs.

Definition at line 1027 of file tsr.cpp.

 {
     world_->lock();
  
     std::size_t i = 0;
     for (std::size_t j = 0; j < tsrs_.size(); ++j)
     {
         const auto &tsr = tsrs_[j];
         tsr->getErrorWorld(error.segment(i, tsr->getDimension()));
         error.segment(i, tsr->getDimension()) *= weights_[j];
  
         i += tsr->getDimension();
     }
  
     world_->unlock();
 }

◆ getErrorWorldState()

void TSRSet::getErrorWorldState	(	const Eigen::Ref< const Eigen::VectorXd > &	world,
		Eigen::Ref< Eigen::VectorXd >	error
	)		const

Get the error given a provided world configuration.

Parameters

[in]	world	World configuration (from world indices).
[out]	error	Error value for all TSRs.

Definition at line 1044 of file tsr.cpp.

 {
     world_->lock();
  
     std::size_t i = 0;
     for (std::size_t j = 0; j < tsrs_.size(); ++j)
     {
         const auto &tsr = tsrs_[j];
         tsr->getErrorWorldState(world, error.segment(i, tsr->getDimension()));
         error.segment(i, tsr->getDimension()) *= weights_[j];
  
         i += tsr->getDimension();
     }
  
     world_->unlock();
 }

◆ getJacobianWorldState()

void TSRSet::getJacobianWorldState	(	const Eigen::Ref< const Eigen::VectorXd > &	world,
		Eigen::Ref< Eigen::MatrixXd >	jacobian
	)		const

Get the Jacobian given a provided world configuration.

Parameters

[in]	world	World configuration (from world indices).
[out]	jacobian	Jacobian value for all TSRs.

Definition at line 1062 of file tsr.cpp.

 {
     world_->lock();
  
     unsigned int i = 0;
     std::size_t n = world.size();
     for (std::size_t j = 0; j < tsrs_.size(); ++j)
     {
         const auto &tsr = tsrs_[j];
         tsr->getJacobianWorldState(world, jacobian.block(i, 0, tsr->getDimension(), n));
         jacobian.block(i, 0, tsr->getDimension(), n) *= weights_[j];
  
         i += tsr->getDimension();
     }
  
     world_->unlock();
 }

◆ getLimit()

double TSRSet::getLimit ( ) const

Get the solver limit parameter.

Returns: The solver limit parameter.

Definition at line 1328 of file tsr.cpp.

 {
     return limit_;
 }

◆ getMaxIterations()

std::size_t TSRSet::getMaxIterations ( ) const

Get the maximum iterations allowed.

Returns: The maximum solver iterations.

Definition at line 1204 of file tsr.cpp.

 {
     return maxIter_;
 }

◆ getPositionsWorldState()

void TSRSet::getPositionsWorldState ( Eigen::Ref< Eigen::VectorXd > world ) const

Get the current world state.

Parameters

[out] world State to fill.

Definition at line 1232 of file tsr.cpp.

 {
     const auto &wi = getWorldIndices();
     for (std::size_t i = 0; i < wi.size(); ++i)
     {
         const auto &wii = wi[i];
         world[i] = world_->getSim()->getSkeleton(wii.first)->getDof(wii.second)->getPosition();
     }
 }

◆ getStep()

double TSRSet::getStep ( ) const

Get the solver step parameter.

Returns: The solver step parameter.

Definition at line 1308 of file tsr.cpp.

 {
     return step_;
 }

◆ getTolerance()

double TSRSet::getTolerance ( ) const

Get the numerical tolerance for solving.

Returns: The tolerance.

Definition at line 1209 of file tsr.cpp.

 {
     return tolerance_;
 }

◆ getTSRs()

const std::vector< TSRPtr > & TSRSet::getTSRs ( ) const

Get the TSRs that form the set.

Returns: The set of TSRs.

Definition at line 978 of file tsr.cpp.

 {
     return tsrs_;
 }

◆ getWorldIndices()

const std::vector< std::pair< std::size_t, std::size_t > > & TSRSet::getWorldIndices ( ) const

Get the world indices used.

Returns: World indices.

Definition at line 1227 of file tsr.cpp.

 {
     return tsrs_[0]->getWorldIndices();
 }

◆ initialize()

void TSRSet::initialize ( )

Initialize this set of TSRs.

Definition at line 1214 of file tsr.cpp.

 {
     skel_indices_.clear();
     for (auto &tsr : tsrs_)
     {
         tsr->initialize();
         skel_indices_.emplace(tsr->getSkeletonIndex());
     }
  
     updateSolver();
     RBX_INFO("TSRSet: Initialized %d TSRs!", tsrs_.size());
 }

◆ numTSRs()

std::size_t TSRSet::numTSRs ( ) const

Get the number of TSRs in the set.

Returns: The number of TSRs.

Definition at line 973 of file tsr.cpp.

 {
     return tsrs_.size();
 }

◆ print()

void TSRSet::print ( std::ostream & out ) const

Print out the TSRs in this set.

Parameters

[in] out Output stream.

Definition at line 1295 of file tsr.cpp.

 {
     out << "TSRSet --------------------" << std::endl;
     for (const auto &tsr : tsrs_)
         tsr->getSpecification().print(out);
     out << "---------------------------" << std::endl;
 }

◆ setDamping()

void TSRSet::setDamping ( double damping )

Set the damping parameter in the solver.

Parameters

[in] damping Damping parameter.

Definition at line 1333 of file tsr.cpp.

 {
     damping_ = damping;
 }

◆ setLimit()

void TSRSet::setLimit ( double limit )

Set the limit parameter in the solver.

Parameters

[in] limit Limit parameter.

Definition at line 1323 of file tsr.cpp.

 {
     limit_ = limit;
 }

◆ setMaxIterations()

void TSRSet::setMaxIterations ( std::size_t iterations )

Set the maximum iterations used for solving.

Parameters

[in] iterations Max iterations to use.

Definition at line 1267 of file tsr.cpp.

 {
     maxIter_ = iterations;
 }

◆ setStep()

void TSRSet::setStep ( double step )

Set the step parameter in the solver.

Parameters

[in] step Step parameter.

Definition at line 1303 of file tsr.cpp.

 {
     step_ = step;
 }

◆ setTolerance()

void TSRSet::setTolerance ( double tolerance )

Set the maximum tolerance used for solving.

Parameters

[in] tolerance New tolerance.

Definition at line 1272 of file tsr.cpp.

 {
     tolerance_ = tolerance;
 }

◆ setWorld()

void TSRSet::setWorld ( const WorldPtr & world )

Set the world used by this TSR set.

Parameters

[in] world New world to use.

Definition at line 983 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->setWorld(world);
  
     world_ = world;
     initialize();
 }

◆ setWorldIndices()

void TSRSet::setWorldIndices ( const std::vector< std::pair< std::size_t, std::size_t >> & indices )

Output world indices. TSR information for *WorldState methods uses this set of world indices. World indices are pairs of skeleton index and DoF index.

Parameters

[in] indices Indices to use.

Definition at line 1016 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->setWorldIndices(indices);
 }

◆ setWorldLowerLimits()

void TSRSet::setWorldLowerLimits ( const Eigen::Ref< const Eigen::VectorXd > & lower )

Set the lower limit on joints given their index in the world configuration.

Parameters

[in] lower Lower bounds on joints.

Definition at line 1282 of file tsr.cpp.

 {
     lower_ = lower;
 }

◆ setWorldUpperLimits()

void TSRSet::setWorldUpperLimits ( const Eigen::Ref< const Eigen::VectorXd > & upper )

Set the upper limit on joints given their index in the world configuration.

Parameters

[in] upper Upper bounds on joints.

Definition at line 1277 of file tsr.cpp.

 {
     upper_ = upper;
 }

◆ solveGradientWorldState()

bool TSRSet::solveGradientWorldState ( Eigen::Ref< Eigen::VectorXd > world )

Solve using gradient descent for a satisfying configuration given an initial world configuration.

Parameters

[in] world World configuration (from world indices).

Returns: True on success, false on failure.

Definition at line 1135 of file tsr.cpp.

 {
     unsigned int iter = 0;
     double norm = 0;
     Eigen::VectorXd f(getDimension());
     Eigen::MatrixXd j(getDimension(), world.size());
  
     const double squared_tolerance = tolerance_ * tolerance_;
     const Eigen::VectorXd limit = Eigen::VectorXd::Constant(world.size(), limit_);
  
     world_->lock();
     getErrorWorldState(world, f);
  
     while ((norm = f.norm()) > squared_tolerance and iter++ < maxIter_)
     {
         getJacobianWorldState(world, j);
         if (qr_)
             world -= (step_ * j.colPivHouseholderQr().solve(f)).cwiseMin(limit).cwiseMax(-limit);
         else
         {
             if (damped_)
             {
                 auto svd = j.jacobiSvd(Eigen::ComputeFullU | Eigen::ComputeFullV);
                 auto lr = svd.rank();
                 const auto &u = svd.matrixU().leftCols(lr);
                 const auto &v = svd.matrixV().leftCols(lr);
                 const auto &s = svd.singularValues().head(lr);
                 const auto &d = Eigen::VectorXd::Constant(lr, damping_);
  
                 const auto &damped = s.cwiseQuotient(s.cwiseProduct(s) + d.cwiseProduct(d));
  
                 Eigen::MatrixXd tmp;
                 tmp.noalias() = u.adjoint() * f;
                 tmp = damped.asDiagonal().inverse() * tmp;
                 auto step = v * tmp;
  
                 world -= (step_ * step).cwiseMin(limit).cwiseMax(-limit);
             }
             else
                 world -= (step_ * j.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(f))
                              .cwiseMin(limit)
                              .cwiseMax(-limit);
         }
  
         enforceBoundsWorld(world);
  
         getErrorWorldState(world, f);
     }
  
     world_->forceUpdate();
     world_->unlock();
  
     return norm < squared_tolerance;
 }

◆ solveWorld()

bool TSRSet::solveWorld ( )

Solve for a satisfying configuration given the current state of the world.

Returns: True on success, false on failure.

Definition at line 1095 of file tsr.cpp.

 {
     world_->lock();
  
     if (tsrs_.size() == 1)
     {
         bool r = tsrs_[0]->solveWorld();
         world_->unlock();
         return r;
     }
  
     auto sim = world_->getSim();
  
     bool r = true;
     for (const auto &skidx : skel_indices_)
     {
         auto skel = sim->getSkeleton(skidx);
         auto ik = skel->getIK(true);
         r &= ik->solveAndApply(true);
     }
  
     world_->unlock();
     return r;
 }

◆ solveWorldState()

bool TSRSet::solveWorldState ( Eigen::Ref< Eigen::VectorXd > world )

Solve for a satisfying configuration given an initial world configuration.

Parameters

[in] world World configuration (from world indices).

Returns: True on success, false on failure.

Definition at line 1120 of file tsr.cpp.

 {
     world_->lock();
     for (auto &tsr : tsrs_)
         tsr->setPositionsWorldState(world);
  
     bool r = solveWorld();
  
     for (auto &tsr : tsrs_)
         tsr->getPositionsWorldState(world);
  
     world_->unlock();
     return r;
 }

◆ updateSolver()

void TSRSet::updateSolver ( )

Update the solver information (iterations, tolerance, etc.)

Definition at line 1190 of file tsr.cpp.

 {
     auto sim = world_->getSim();
     for (const auto &skidx : skel_indices_)
     {
         auto skel = sim->getSkeleton(skidx);
         auto ik = skel->getIK(true);
  
         auto sv = ik->getSolver();
         sv->setNumMaxIterations(maxIter_);
         sv->setTolerance(tolerance_);
     }
 }

◆ useDamping()

void TSRSet::useDamping ( bool damping )

Set if damping is used in SVD solving.

Parameters

[in] damping Damping value.

Definition at line 1343 of file tsr.cpp.

 {
     damped_ = damping;
 }

◆ useGroup()

void TSRSet::useGroup ( const std::string & name )

Use the joints in a robot's group. Robot used is the target frame's structure.

Parameters

[in] name Name of group to use.

Definition at line 998 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->useGroup(name);
 }

◆ useIndices()

void TSRSet::useIndices ( const std::vector< std::size_t > & indices )

Use DoF indices for all TSRs computation.

Parameters

[in] indices Indices to use.

Definition at line 1004 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->useIndices(indices);
 }

◆ useQR()

void TSRSet::useQR ( )

Use QR for solving.

Definition at line 1318 of file tsr.cpp.

 {
     qr_ = true;
 }

◆ useSVD()

void TSRSet::useSVD ( )

Use SVD for solving.

Definition at line 1313 of file tsr.cpp.

 {
     qr_ = false;
 }

◆ useWorldIndices()

void TSRSet::useWorldIndices ( const std::vector< std::pair< std::size_t, std::size_t >> & indices )

Use World DoF indices for all TSRs computation. World indices are pairs of skeleton index and DoF index.

Parameters

[in] indices Indices to use.

Definition at line 1010 of file tsr.cpp.

 {
     for (auto &tsr : tsrs_)
         tsr->useWorldIndices(indices);
 }

Member Data Documentation

◆ damped_

bool robowflex::darts::TSRSet::damped_ {true}

private

If true, use damped SVD.

Definition at line 987 of file tsr.h.

◆ damping_

double robowflex::darts::TSRSet::damping_ {1e-8}

private

Damping factor.

Definition at line 990 of file tsr.h.

◆ dimension_

std::size_t robowflex::darts::TSRSet::dimension_ {0}

private

Total error dimension of set.

Definition at line 996 of file tsr.h.

◆ limit_

double robowflex::darts::TSRSet::limit_ {1.}

private

Step size limit.

Definition at line 989 of file tsr.h.

◆ lower_

Eigen::VectorXd robowflex::darts::TSRSet::lower_

private

Lower bounds on world configuration.

Definition at line 999 of file tsr.h.

◆ maxIter_

std::size_t robowflex::darts::TSRSet::maxIter_ {50}

private

Maximum iterations to use for solving.

Definition at line 992 of file tsr.h.

◆ qr_

bool robowflex::darts::TSRSet::qr_ {false}

private

If true, use QR in gradient solve. Else, SVD.

Definition at line 986 of file tsr.h.

◆ skel_indices_

std::set<std::size_t> robowflex::darts::TSRSet::skel_indices_

private

All skeleton indices used by members of the set.

Definition at line 984 of file tsr.h.

◆ step_

double robowflex::darts::TSRSet::step_ {1.0}

private

Step scaling in gradient.

Definition at line 988 of file tsr.h.

◆ tolerance_

double robowflex::darts::TSRSet::tolerance_ {magic::DEFAULT_IK_TOLERANCE}

private

Tolerance for solving.

Definition at line 991 of file tsr.h.

◆ tsrs_

std::vector<TSRPtr> robowflex::darts::TSRSet::tsrs_

private

Set of TSRs.

Definition at line 994 of file tsr.h.

◆ upper_

Eigen::VectorXd robowflex::darts::TSRSet::upper_

private

Upper bounds on world configuration.

Definition at line 998 of file tsr.h.

◆ weights_

std::vector<double> robowflex::darts::TSRSet::weights_

private

Weights on TSRs.

Definition at line 995 of file tsr.h.

◆ world_

WorldPtr robowflex::darts::TSRSet::world_

private

World to use.

Definition at line 983 of file tsr.h.

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TSRSet() [1/2]

◆ TSRSet() [2/2]

Member Function Documentation

◆ addSuffix()

◆ addTSR()

◆ computeLimits()

◆ distanceWorld()

◆ distanceWorldState()

◆ enforceBoundsWorld()

◆ getDamping()

◆ getDimension()

◆ getErrorWorld()

◆ getErrorWorldState()

◆ getJacobianWorldState()

◆ getLimit()

◆ getMaxIterations()

◆ getPositionsWorldState()

◆ getStep()

◆ getTolerance()

◆ getTSRs()

◆ getWorldIndices()

◆ initialize()

◆ numTSRs()

◆ print()

◆ setDamping()

◆ setLimit()

◆ setMaxIterations()

◆ setStep()

◆ setTolerance()

◆ setWorld()

◆ setWorldIndices()

◆ setWorldLowerLimits()

◆ setWorldUpperLimits()

◆ solveGradientWorldState()

◆ solveWorld()

◆ solveWorldState()

◆ updateSolver()

◆ useDamping()

◆ useGroup()

◆ useIndices()

◆ useQR()

◆ useSVD()

◆ useWorldIndices()

Member Data Documentation

◆ damped_

◆ damping_

◆ dimension_

◆ limit_

◆ lower_

◆ maxIter_

◆ qr_

◆ skel_indices_

◆ step_

◆ tolerance_

◆ tsrs_

◆ upper_

◆ weights_

◆ world_