Continuous validation of a path. More...
#include <hpp/core/continuous-validation/dichotomy.hh>
Public Member Functions | |
| virtual | ~Dichotomy () |
 Public Member Functions inherited from hpp::core::ContinuousValidation | |
| virtual bool | validate (const PathPtr_t &path, bool reverse, PathPtr_t &validPart, PathValidationReportPtr_t &report) |
| Compute the largest valid interval starting from the path beginning. More... | |
| virtual void | addObstacle (const CollisionObjectConstPtr_t &object) |
| Add an obstacle. More... | |
| virtual void | removeObstacleFromJoint (const JointPtr_t &joint, const CollisionObjectConstPtr_t &obstacle) |
| Remove a collision pair between a joint and an obstacle. More... | |
| void | filterCollisionPairs (const RelativeMotion::matrix_type &relMotion) |
| void | changeInitializer (continuousValidation::InitializerPtr_t initializer) |
| Change the initializer The continuous validation is then reset and the new initializer is called to do the new initialization. More... | |
| value_type | tolerance () const |
| Get tolerance value. More... | |
| virtual | ~ContinuousValidation () |
| Public Member Functions inherited from hpp::core::PathValidation | |
| virtual | ~PathValidation () |
Static Public Member Functions | |
| static DichotomyPtr_t | create (const DevicePtr_t &robot, const value_type &tolerance) |
| Create instance and return shared pointer. More... | |
Protected Member Functions | |
| Dichotomy (const DevicePtr_t &robot, const value_type &tolerance) | |
| Constructor. More... | |
| void | init (const DichotomyWkPtr_t weak) |
| Store weak pointer to itself. More... | |
| Protected Member Functions inherited from hpp::core::ContinuousValidation | |
| ContinuousValidation (const DevicePtr_t &robot, const value_type &tolerance) | |
| Constructor. More... | |
| virtual bool | validateConfiguration (BodyPairCollisions_t &bodyPairCollisions, const Configuration_t &config, const value_type &t, interval_t &interval, PathValidationReportPtr_t &report) |
| Validate interval centered on a path parameter. More... | |
| void | init (ContinuousValidationWkPtr_t weak) |
| Store weak pointer to itself. More... | |
| Protected Member Functions inherited from hpp::core::PathValidation | |
| PathValidation () | |
Additional Inherited Members | |
| Protected Types inherited from hpp::core::ContinuousValidation | |
| typedef continuousValidation::BodyPairCollisions_t | BodyPairCollisions_t |
| Static Protected Member Functions inherited from hpp::core::ContinuousValidation | |
| static void | setPath (BodyPairCollisions_t &bodyPairCollisions, const PathPtr_t &path, bool reverse) |
| Protected Attributes inherited from hpp::core::ContinuousValidation | |
| DevicePtr_t | robot_ |
| value_type | tolerance_ |
| BodyPairCollisions_t | bodyPairCollisions_ |
| BodyPairCollisions_t | disabledBodyPairCollisions_ |
| pinocchio::Pool< BodyPairCollisions_t > | bodyPairCollisionPool_ |
| value_type | stepSize_ |
| continuousValidation::InitializerPtr_t | initializer_ |
Detailed Description
Continuous validation of a path.
This class tests for collision
- straight paths, or
- concatenation of straight paths (PathVector).
A path is valid if and only if each interval validation element is valid along the whole interval of definition.
For each interval validation element, a union of sub-intervals where the element is valid is computed.
First, each validation element is tested at the beginning of the interval (at the end if reverse is set to true). Then the element that has the smaller upper bound of the first valid sub-interval is tested at the middle of the segment delimited by the upper bound of the first valid sub-interval and by the lower bound of the second valid sub-interval (or the end of the interval of definition if the union of sub-intervals contains only one sub-interval).
Collision pairs between bodies of the robot are initialized at construction of the instance.
Method addObstacle adds an obstacle in the environment. For each joint, a new pair is created with the new obstacle.
Validation of pairs along straight interpolations is based on the computation of an upper-bound of the relative velocity of objects of one joint (or of the environment) in the reference frame of the other joint.
See this document for details.
