Definition of a problem to be solved. This includes the start state(s) for the system and a goal specification. Will contain solutions, if found. More...
#include <ProblemDefinition.h>
Public Member Functions | |
ProblemDefinition (const SpaceInformationPtr &si) | |
Create a problem definition given the SpaceInformation it is part of. | |
const SpaceInformationPtr & | getSpaceInformation (void) const |
Get the space information this problem definition is for. | |
void | addStartState (const State *state) |
Add a start state. The state is copied. | |
void | addStartState (const ScopedState<> &state) |
Add a start state. The state is copied. | |
bool | hasStartState (const State *state, unsigned int *startIndex=NULL) |
Check whether a specified starting state is already included in the problem definition and optionally return the index of that starting state. | |
void | clearStartStates (void) |
Clear all start states (memory is freed) | |
unsigned int | getStartStateCount (void) const |
Returns the number of start states. | |
const State * | getStartState (unsigned int index) const |
Returns a specific start state. | |
State * | getStartState (unsigned int index) |
Returns a specific start state. | |
void | setGoal (const GoalPtr &goal) |
Set the goal. | |
void | clearGoal (void) |
Clear the goal. Memory is freed. | |
const GoalPtr & | getGoal (void) const |
Return the current goal. | |
void | getInputStates (std::vector< const State * > &states) const |
Get all the input states. This includes start states and states that are part of goal regions that can be casted as ompl::base::GoalState or ompl::base::GoalStates. | |
void | setStartAndGoalStates (const State *start, const State *goal, const double threshold=std::numeric_limits< double >::epsilon()) |
In the simplest case possible, we have a single starting state and a single goal state. | |
void | setGoalState (const State *goal, const double threshold=std::numeric_limits< double >::epsilon()) |
A simple form of setting the goal. This is called by setStartAndGoalStates(). A more general form is setGoal() | |
void | setStartAndGoalStates (const ScopedState<> &start, const ScopedState<> &goal, const double threshold=std::numeric_limits< double >::epsilon()) |
In the simplest case possible, we have a single starting state and a single goal state. | |
void | setGoalState (const ScopedState<> &goal, const double threshold=std::numeric_limits< double >::epsilon()) |
A simple form of setting the goal. This is called by setStartAndGoalStates(). A more general form is setGoal() | |
bool | isTrivial (unsigned int *startIndex=NULL, double *distance=NULL) const |
A problem is trivial if a given starting state already in the goal region, so we need no motion planning. startID will be set to the index of the starting state that satisfies the goal. The distance to the goal can optionally be returned as well. | |
PathPtr | isStraightLinePathValid (void) const |
Check if a straight line path is valid. If it is, return an instance of a path that represents the straight line. | |
bool | fixInvalidInputStates (double distStart, double distGoal, unsigned int attempts) |
Many times the start or goal state will barely touch an obstacle. In this case, we may want to automatically find a nearby state that is valid so motion planning can be performed. This function enables this behaviour. The allowed distance for both start and goal states is specified. The number of attempts is also specified. Returns true if all states are valid after completion. | |
bool | hasSolution (void) const |
Returns true if a solution path has been found (could be approximate) | |
bool | hasApproximateSolution (void) const |
Return true if the top found solution is approximate (does not actually reach the desired goal, but hopefully is closer to it) | |
double | getSolutionDifference (void) const |
Get the distance to the desired goal for the top solution. Return -1.0 if there are no solutions available. | |
PathPtr | getSolutionPath (void) const |
Return the top solution path, if one is found. The top path is the shortest one that was found, preference being given to solutions that are not approximate. | |
void | addSolutionPath (const PathPtr &path, bool approximate=false, double difference=-1.0) const |
Add a solution path in a thread-safe manner. Multiple solutions can be set for a goal. If a solution does not reach the desired goal it is considered approximate. Optionally, the distance between the desired goal and the one actually achieved is set by difference. | |
std::size_t | getSolutionCount (void) const |
Get the number of solutions already found. | |
std::vector< PlannerSolution > | getSolutions (void) const |
Get all the solution paths available for this goal. | |
void | clearSolutionPaths (void) const |
Forget the solution paths (thread safe). Memory is freed. | |
void | print (std::ostream &out=std::cout) const |
Print information about the start and goal states. | |
bool | hasSolutionNonExistenceProof (void) const |
Returns true if the problem definition has a proof of non existence for a solution. | |
void | clearSolutionNonExistenceProof (void) |
Removes any existing instance of SolutionNonExistenceProof. | |
const SolutionNonExistenceProofPtr & | getSolutionNonExistenceProof (void) const |
Retrieve a pointer to the SolutionNonExistenceProof instance for this problem definition. | |
void | setSolutionNonExistenceProof (const SolutionNonExistenceProofPtr &nonExistenceProof) |
Set the instance of SolutionNonExistenceProof for this problem definition. |
Protected Member Functions | |
bool | fixInvalidInputState (State *state, double dist, bool start, unsigned int attempts) |
Helper function for fixInvalidInputStates(). Attempts to fix an individual state. |
Protected Attributes | |
SpaceInformationPtr | si_ |
The space information this problem definition is for. | |
std::vector< State * > | startStates_ |
The set of start states. | |
GoalPtr | goal_ |
The goal representation. | |
SolutionNonExistenceProofPtr | nonExistenceProof_ |
A Representation of a proof of non-existence of a solution for this problem definition. |
Definition of a problem to be solved. This includes the start state(s) for the system and a goal specification. Will contain solutions, if found.
Definition at line 115 of file ProblemDefinition.h.
|
inline |
Add a start state. The state is copied.
Definition at line 140 of file ProblemDefinition.h.
ompl::base::PathPtr ompl::base::ProblemDefinition::getSolutionPath | ( | void | ) | const |
Return the top solution path, if one is found. The top path is the shortest one that was found, preference being given to solutions that are not approximate.
This will need to be casted into the specialization computed by the planner
Definition at line 374 of file ProblemDefinition.cpp.
|
inline |
Returns a specific start state.
Definition at line 171 of file ProblemDefinition.h.
ompl::base::PathPtr ompl::base::ProblemDefinition::isStraightLinePathValid | ( | void | ) | const |
Check if a straight line path is valid. If it is, return an instance of a path that represents the straight line.
Definition at line 239 of file ProblemDefinition.cpp.
|
inline |
A simple form of setting the goal. This is called by setStartAndGoalStates(). A more general form is setGoal()
Definition at line 219 of file ProblemDefinition.h.
void ompl::base::ProblemDefinition::setStartAndGoalStates | ( | const State * | start, |
const State * | goal, | ||
const double | threshold = std::numeric_limits<double>::epsilon() |
||
) |
In the simplest case possible, we have a single starting state and a single goal state.
This function simply configures the problem definition using these states (performs the needed calls to addStartState(), creates an instance of ompl::base::GoalState and calls setGoal() on it.
Definition at line 130 of file ProblemDefinition.cpp.
|
inline |
In the simplest case possible, we have a single starting state and a single goal state.
This function simply configures the problem definition using these states (performs the needed calls to addStartState(), creates an instance of ompl::base::GoalState and calls setGoal() on it.
Definition at line 213 of file ProblemDefinition.h.