hpp-constraints: hpp::constraints::Explicit Class Reference

hpp-constraints 9.0.2 Definition of basic geometric constraints for motion planning

Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
hpp::constraints::Explicit Class Reference
Constraints

`#include <hpp/constraints/explicit.hh>`

Inheritance diagram for hpp::constraints::Explicit:
[legend]
Collaboration diagram for hpp::constraints::Explicit:
[legend]

## Public Member Functions
virtual ImplicitPtr_t | copy () const
| Copy object and return shared pointer to copy.
DifferentiableFunctionPtr_t | explicitFunction () const
const segments_t & | outputConf () const
| Get output configuration variables.
const segments_t & | outputVelocity () const
| Get output degrees of freedom.
const segments_t & | inputConf () const
| Get input configuration variables.
const segments_t & | inputVelocity () const
| Get input degrees of freedom.
virtual void | outputValue (LiegroupElementRef result, vectorIn_t qin, LiegroupElementConstRef rhs) const
virtual void | jacobianOutputValue (vectorIn_t qin, LiegroupElementConstRef g_value, LiegroupElementConstRef rhs, matrixOut_t jacobian) const
Public Member Functions inherited from hpp::constraints::Implicit
bool | operator== (const Implicit &other) const
| Operator equality.
Implicit & | operator= (const Implicit &other)
| Operator assignation.
virtual | ~Implicit ()
const ComparisonTypes_t & | comparisonType () const
| Return the ComparisonType.
void | comparisonType (const ComparisonTypes_t &comp)
| Set the comparison type.
const segments_t & | activeRows () const
bool | checkAllRowsActive () const
| Check if all rows are active (no inactive rows)
const Eigen::RowBlockIndices & | equalityIndices () const
| Get indices of constraint coordinates that are equality.
void | setInactiveRowsToZero (vectorOut_t error) const
DifferentiableFunction & | function () const
| Return a reference to function .
const DifferentiableFunctionPtr_t & | functionPtr () const
| Return a reference to function .
virtual std::pair< JointConstPtr_t, JointConstPtr_t > | doesConstrainRelPoseBetween (DeviceConstPtr_t robot) const
void | rightHandSideFromConfig (ConfigurationIn_t config, LiegroupElementRef rhs)
bool | checkRightHandSide (LiegroupElementConstRef rhs) const
size_type | parameterSize () const
size_type | rightHandSideSize () const
void | rightHandSideFunction (const DifferentiableFunctionPtr_t &rhsF)
const DifferentiableFunctionPtr_t & | rightHandSideFunction () const
vectorIn_t | rightHandSideAt (const value_type &s)

## Static Public Member Functions
static ExplicitPtr_t | create (const LiegroupSpacePtr_t &configSpace, const DifferentiableFunctionPtr_t &function, const segments_t &inputConf, const segments_t &outputConf, const segments_t &inputVelocity, const segments_t &outputVelocity, const ComparisonTypes_t &comp=ComparisonTypes_t(), std::vector< bool > mask=std::vector< bool >())
static ExplicitPtr_t | createCopy (const ExplicitPtr_t &other)
| Create a copy and return shared pointer.
Static Public Member Functions inherited from hpp::constraints::Implicit
static ImplicitPtr_t | create (const DifferentiableFunctionPtr_t &func, ComparisonTypes_t comp, std::vector< bool > mask=std::vector< bool >())
static ImplicitPtr_t | createCopy (const ImplicitPtr_t &other)
| Create a copy and return shared pointer.

## Protected Member Functions
| Explicit (const LiegroupSpacePtr_t &configSpace, const DifferentiableFunctionPtr_t &function, const segments_t &inputConf, const segments_t &outputConf, const segments_t &inputVelocity, const segments_t &outputVelocity, const ComparisonTypes_t &comp, std::vector< bool > mask)
| Explicit (const DifferentiableFunctionPtr_t &implicitFunction, const DifferentiableFunctionPtr_t &function, const segments_t &inputConf, const segments_t &outputConf, const segments_t &inputVelocity, const segments_t &outputVelocity, const ComparisonTypes_t &comp, std::vector< bool > mask)
  | (const LiegroupSpacePtr_t&, constDifferentiableFunctionPtr_t&, const segments_t& inputConf, constsegments_t& outputConf, const segments_t& inputVelocity, constsegments_t&, const ComparisonTypes_t&); Parameters
  implicitFunction |
| Explicit (const Explicit &other)
| Copy constructor.
bool | isEqual (const Implicit &other, bool swapAndTest) const
void | init (const ExplicitWkPtr_t &weak)
| Explicit ()
Protected Member Functions inherited from hpp::constraints::Implicit
| Implicit (const DifferentiableFunctionPtr_t &function, ComparisonTypes_t comp, std::vector< bool > mask)
| Implicit (const Implicit &other)
| Copy constructor.
void | init (const ImplicitWkPtr_t &weak)
| Implicit ()

## Protected Attributes
DifferentiableFunctionPtr_t | inputToOutput_
segments_t | inputConf_
segments_t | outputConf_
segments_t | inputVelocity_
segments_t | outputVelocity_

## Detailed Description

Explicit numerical constraint

#### Definition

An explicit numerical constraint is a constraint such that some configuration variables called output are function of the others called input.

Let

- be the list of indices corresponding to ordered input configuration variables,
- be the list of indices corresponding to ordered output configuration variables,
- be the list of indices corresponding to ordered input degrees of freedom,
- be the list of indices corresponding to ordered output degrees of freedom.

Recall that degrees of freedom refer to velocity vectors.

Let us notice that is less than the robot configuration size, and is less than the velocity size. Some degrees of freedom may indeed be neither input nor output.

Then the differential function is of the form

It is straightforward that an equality constraint with this function can be solved explicitely:

If function takes values in a Lie group (SO(2), SO(3)), the above "+" between a Lie group element and a tangent vector has to be undestood as the integration of the constant velocity from the Lie group element:

where is a Lie group element and is a tangent vector.

Considered as an Implicit instance, the expression of the Jacobian of the DifferentiableFunction above depends on the output space of function . The rows corresponding to values in a vector space are expressed as follows.

for any index between 0 and the size of velocity vectors, either

- is an input degree of freedom: integer, such that ,
- is an output degree of freedom: integer, such that , or
- neither input nor output. In this case, the corresponding column is equal to 0.

  The rows corresponding to values in SO(3) have the following expression.

  where
- is the rotation matrix corresponding to unit quaternion ,
- is the rotation matrix corresponding to the part of the output value of corresponding to SO(3),
- is the Jacobian matrix of function that associates to a rotation matrix the vector such that

#### "Domain of

definition"

    Some explicit constraints might be defined over only a subspace of the input

space. If the input value is not in the definition subspace, the explicit constraint will throw an exception of type FunctionNotDefinedForThisValue.

## Constructor & Destructor Documentation

## ◆ Explicit() [1/4]

hpp::constraints::Explicit::Explicit | ( | const LiegroupSpacePtr_t & | configSpace,
|  | const DifferentiableFunctionPtr_t & | function,
|  | const segments_t & | inputConf,
|  | const segments_t & | outputConf,
|  | const segments_t & | inputVelocity,
|  | const segments_t & | outputVelocity,
|  | const ComparisonTypes_t & | comp,
|  | std::vector< bool > | mask )
| protected

Constructor

Parameters

  configSpace | Configuration space on which the constraint is defined,
  function | relation between input configuration variables and output configuration variables,
  inputConf | set of integer intervals defining indices ,
  outputConf | set of integer intervals defining indices ,
  inputVelocity | set of integer defining indices .
  outputVelocity | set of integer defining indices .
  mask | mask defining which components of the error are taken into account to determine whether the constraint is satisfied (See parent class for details).

## ◆ Explicit() [2/4]

hpp::constraints::Explicit::Explicit | ( | const DifferentiableFunctionPtr_t & | implicitFunction,
|  | const DifferentiableFunctionPtr_t & | function,
|  | const segments_t & | inputConf,
|  | const segments_t & | outputConf,
|  | const segments_t & | inputVelocity,
|  | const segments_t & | outputVelocity,
|  | const ComparisonTypes_t & | comp,
|  | std::vector< bool > | mask )
| protected

(const LiegroupSpacePtr_t&, constDifferentiableFunctionPtr_t&, const segments_t& inputConf, constsegments_t& outputConf, const segments_t& inputVelocity, constsegments_t&, const ComparisonTypes_t&);

Parameters

  implicitFunction |

Constructor

Parameters

  configSpace | Configuration space on which the constraint is defined,
  function | relation between input configuration variables and output configuration variables,
  inputConf | set of integer intervals defining indices ,
  outputConf | set of integer intervals defining indices ,
  inputVelocity | set of integer defining indices .
  outputVelocity | set of integer defining indices .
  mask | mask defining which components of the error are taken into account to determine whether the constraint is satisfied (See parent class for details). (const LiegroupSpacePtr_t&, constDifferentiableFunctionPtr_t&, const segments_t& inputConf, constsegments_t& outputConf, const segments_t& inputVelocity, constsegments_t&, const ComparisonTypes_t&);
  implicitFunction | differentiable function of the implicit formulation if different from default expression

## ◆ Explicit() [3/4]

hpp::constraints::Explicit::Explicit | ( | const Explicit & | other | ) |
| protected

Copy constructor.

## ◆ Explicit() [4/4]

hpp::constraints::Explicit::Explicit | ( |  | ) |
| inline protected

## Member Function Documentation

## ◆ copy()

virtual ImplicitPtr_t hpp::constraints::Explicit::copy | ( |  | ) | const
| virtual

Copy object and return shared pointer to copy.

Reimplemented from hpp::constraints::Implicit.

Reimplemented in hpp::constraints::explicit_::ConvexShapeContact, hpp::constraints::explicit_::RelativePose, and hpp::constraints::LockedJoint.

## ◆ create()

static ExplicitPtr_t hpp::constraints::Explicit::create | ( | const LiegroupSpacePtr_t & | configSpace,
|  | const DifferentiableFunctionPtr_t & | function,
|  | const segments_t & | inputConf,
|  | const segments_t & | outputConf,
|  | const segments_t & | inputVelocity,
|  | const segments_t & | outputVelocity,
|  | const ComparisonTypes_t & | comp = ComparisonTypes_t(),
|  | std::vector< bool > | mask = std::vector< bool >() )
| static

Create instance and return shared pointer

Parameters

  configSpace | Configuration space on which the constraint is defined,
  function | relation between input configuration variables and output configuration variables,
  inputConf | set of integer intervals defining indices ,
  outputConf | set of integer intervals defining indices ,
  inputVelocity | set of integer defining indices .
  outputVelocity | set of integer defining indices .
  mask | mask defining which components of the error are taken into account to determine whether the constraint is satisfied (See parent class for details).

## ◆ createCopy()

static ExplicitPtr_t hpp::constraints::Explicit::createCopy | ( | const ExplicitPtr_t & | other | ) |
| static

Create a copy and return shared pointer.

## ◆ explicitFunction()

DifferentiableFunctionPtr_t hpp::constraints::Explicit::explicitFunction | ( |  | ) | const
| inline

Function that maps input to output

Returns
  function .

## ◆ init()

void hpp::constraints::Explicit::init | ( | const ExplicitWkPtr_t & | weak | ) |
| protected

## ◆ inputConf()

const segments_t & hpp::constraints::Explicit::inputConf | ( |  | ) | const
| inline

Get input configuration variables.

## ◆ inputVelocity()

const segments_t & hpp::constraints::Explicit::inputVelocity | ( |  | ) | const
| inline

Get input degrees of freedom.

## ◆ isEqual()

bool hpp::constraints::Explicit::isEqual | ( | const Implicit & | other,
|  | bool | swapAndTest ) const
| protected virtual

Test equality with other instance

Parameters

  other | object to copy
  swapAndTest | whether we should also check other == this

Reimplemented from hpp::constraints::Implicit.

Reimplemented in hpp::constraints::LockedJoint.

## ◆ jacobianOutputValue()

virtual void hpp::constraints::Explicit::jacobianOutputValue | ( | vectorIn_t | qin,
|  | LiegroupElementConstRef | g_value,
|  | LiegroupElementConstRef | rhs,
|  | matrixOut_t | jacobian ) const
| virtual

Compute Jacobian of output value

Parameters

  qin | vector of input variables,
  g_value | provided to avoid recomputation,
  rhs | right hand side (of implicit formulation).

Reimplemented in hpp::constraints::explicit_::ConvexShapeContact, and hpp::constraints::explicit_::RelativePose.

## ◆ outputConf()

const segments_t & hpp::constraints::Explicit::outputConf | ( |  | ) | const
| inline

Get output configuration variables.

## ◆ outputValue()

virtual void hpp::constraints::Explicit::outputValue | ( | LiegroupElementRef | result,
|  | vectorIn_t | qin,
|  | LiegroupElementConstRef | rhs ) const
| virtual

Compute the value of the output configuration variables

Parameters

  qin | input configuration variables,
  rhs | right hand side of constraint

The default implementation computes

Reimplemented in hpp::constraints::explicit_::ConvexShapeContact, and hpp::constraints::explicit_::RelativePose.

## ◆ outputVelocity()

const segments_t & hpp::constraints::Explicit::outputVelocity | ( |  | ) | const
| inline

Get output degrees of freedom.

## Member Data Documentation

## ◆ inputConf_

segments_t hpp::constraints::Explicit::inputConf_
| protected

## ◆ inputToOutput_

DifferentiableFunctionPtr_t hpp::constraints::Explicit::inputToOutput_
| protected

## ◆ inputVelocity_

segments_t hpp::constraints::Explicit::inputVelocity_
| protected

## ◆ outputConf_

segments_t hpp::constraints::Explicit::outputConf_
| protected

## ◆ outputVelocity_

segments_t hpp::constraints::Explicit::outputVelocity_
| protected

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

- include/hpp/constraints/explicit.hh