hpp-manipulation  5.0.0
Classes for manipulation planning.
hpp::manipulation::pathPlanner::EndEffectorTrajectory Class Reference

#include <hpp/manipulation/path-planner/end-effector-trajectory.hh>

Inheritance diagram for hpp::manipulation::pathPlanner::EndEffectorTrajectory:
Collaboration diagram for hpp::manipulation::pathPlanner::EndEffectorTrajectory:

Public Member Functions

virtual void startSolve ()
 
virtual void oneStep ()
 One step of the algorithm. More...
 
int nRandomConfig () const
 
void nRandomConfig (int n)
 
int nDiscreteSteps () const
 Number of steps to generate goal config (successive projections). More...
 
void nDiscreteSteps (int n)
 
void checkFeasibilityOnly (bool enable)
 
bool checkFeasibilityOnly () const
 
void ikSolverInitialization (IkSolverInitializationPtr_t solver)
 
void tryConnectInitAndGoals ()
 

Static Public Member Functions

static EndEffectorTrajectoryPtr_t create (const core::ProblemConstPtr_t &problem)
 
static EndEffectorTrajectoryPtr_t createWithRoadmap (const core::ProblemConstPtr_t &problem, const core::RoadmapPtr_t &roadmap)
 

Protected Member Functions

 EndEffectorTrajectory (const core::ProblemConstPtr_t &problem)
 
 EndEffectorTrajectory (const core::ProblemConstPtr_t &problem, const core::RoadmapPtr_t &roadmap)
 
void init (const EndEffectorTrajectoryWkPtr_t &weak)
 Store weak pointer to itself. More...
 

Detailed Description

Plan a path for a robot with constrained trajectory of an end effector

This path planner only works with a steering method of type steeringMethod::EndEffectorTrajectory. The steering method defines the desired end-effector trajectory using a time-varying constraint.

To plan a path between two configurations q_init and q_goal, the configurations must satisfy the constraint at the beginning and at the end of the definition interval respectively.

The interval of definition \([0,T]\) of the output path is defined by the time-varying constraint of the steering method. This interval is uniformly discretized in a number of samples that can be accessed using method nDiscreteSteps .

The path is planned by successively calling method oneStep that performs the following actions.

  • A vector of configurations is produced by appending random configurations to q_init. The number of random configurations can be accessed by methods nRandomConfig .
  • for each configuration in the vector,
    • the initial configuration of the path is computed by projecting the configuration on the constraint,
    • the configuration at following samples is computed by projecting the configuration at the previous sample using the time-varying constraint.
    • In case of failure
      • in projecting a configuration or
      • in validating the path for collision, the loop restart with the next random configuration.

Note that continuity is not tested but enforced by projecting the configuration of the previous sample to compute the configuration at a given sample.

Constructor & Destructor Documentation

◆ EndEffectorTrajectory() [1/2]

hpp::manipulation::pathPlanner::EndEffectorTrajectory::EndEffectorTrajectory ( const core::ProblemConstPtr_t &  problem)
protected

Protected constructor

Parameters
problemthe path planning problem

◆ EndEffectorTrajectory() [2/2]

hpp::manipulation::pathPlanner::EndEffectorTrajectory::EndEffectorTrajectory ( const core::ProblemConstPtr_t &  problem,
const core::RoadmapPtr_t &  roadmap 
)
protected

Protected constructor

Parameters
problemthe path planning problem
roadmappreviously built roadmap

Member Function Documentation

◆ checkFeasibilityOnly() [1/2]

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::checkFeasibilityOnly ( bool  enable)

If enabled, only add one solution to the roadmap. Otherwise add all solution.

◆ checkFeasibilityOnly() [2/2]

bool hpp::manipulation::pathPlanner::EndEffectorTrajectory::checkFeasibilityOnly ( ) const
inline

◆ create()

static EndEffectorTrajectoryPtr_t hpp::manipulation::pathPlanner::EndEffectorTrajectory::create ( const core::ProblemConstPtr_t &  problem)
static

Return shared pointer to new instance

Parameters
problemthe path planning problem

◆ createWithRoadmap()

static EndEffectorTrajectoryPtr_t hpp::manipulation::pathPlanner::EndEffectorTrajectory::createWithRoadmap ( const core::ProblemConstPtr_t &  problem,
const core::RoadmapPtr_t &  roadmap 
)
static

Return shared pointer to new instance

Parameters
problemthe path planning problem
roadmappreviously built roadmap

◆ ikSolverInitialization()

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::ikSolverInitialization ( IkSolverInitializationPtr_t  solver)
inline

◆ init()

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::init ( const EndEffectorTrajectoryWkPtr_t &  weak)
protected

Store weak pointer to itself.

◆ nDiscreteSteps() [1/2]

int hpp::manipulation::pathPlanner::EndEffectorTrajectory::nDiscreteSteps ( ) const
inline

Number of steps to generate goal config (successive projections).

◆ nDiscreteSteps() [2/2]

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::nDiscreteSteps ( int  n)
inline

◆ nRandomConfig() [1/2]

int hpp::manipulation::pathPlanner::EndEffectorTrajectory::nRandomConfig ( ) const
inline

Get the number of random configurations shoot (after using init config) in order to generate the initial config of the final path.

◆ nRandomConfig() [2/2]

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::nRandomConfig ( int  n)
inline

◆ oneStep()

virtual void hpp::manipulation::pathPlanner::EndEffectorTrajectory::oneStep ( )
virtual

One step of the algorithm.

◆ startSolve()

virtual void hpp::manipulation::pathPlanner::EndEffectorTrajectory::startSolve ( )
virtual

Initialize the problem resolution

  • call parent implementation
  • get number nodes in problem parameter map

◆ tryConnectInitAndGoals()

void hpp::manipulation::pathPlanner::EndEffectorTrajectory::tryConnectInitAndGoals ( )

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