37 #ifndef OMPL_BASE_PROBLEM_DEFINITION_
38 #define OMPL_BASE_PROBLEM_DEFINITION_
40 #include "ompl/base/State.h"
41 #include "ompl/base/Goal.h"
42 #include "ompl/base/Path.h"
43 #include "ompl/base/SpaceInformation.h"
44 #include "ompl/base/SolutionNonExistenceProof.h"
46 #include "ompl/util/ClassForward.h"
47 #include "ompl/base/ScopedState.h"
54 #include <boost/noncopyable.hpp>
63 OMPL_CLASS_FORWARD(ProblemDefinition);
164 for (
unsigned int i = 0 ; i <
startStates_.size() ; ++i)
221 void setGoalState(
const State *goal,
const double threshold = std::numeric_limits<double>::epsilon());
258 bool isTrivial(
unsigned int *startIndex = NULL,
double *distance = NULL)
const;
331 void print(std::ostream &out = std::cout)
const;
356 OMPL_CLASS_FORWARD(PlannerSolutionSet);
360 PlannerSolutionSetPtr solutions_;
GoalPtr goal_
The goal representation.
void setGoal(const GoalPtr &goal)
Set the goal.
PathPtr getSolutionPath(void) const
Return the top solution path, if one is found. The top path is the shortest one that was found...
bool optimized_
True of the solution was optimized to meet the specified optimization criterion.
void setOptimizationObjective(const OptimizationObjectivePtr &optimizationObjective)
Set the optimization objective to be considered during planning.
bool hasStartState(const State *state, unsigned int *startIndex=NULL)
Check whether a specified starting state is already included in the problem definition and optionally...
Representation of a solution to a planning problem.
Definition of a scoped state.
State * getStartState(unsigned int index)
Returns a specific start state.
const SolutionNonExistenceProofPtr & getSolutionNonExistenceProof(void) const
Retrieve a pointer to the SolutionNonExistenceProof instance for this problem definition.
const GoalPtr & getGoal(void) const
Return the current goal.
A boost shared pointer wrapper for ompl::base::SolutionNonExistenceProof.
void print(std::ostream &out=std::cout) const
Print information about the start and goal states and the optimization objective. ...
PathPtr path_
Solution path.
unsigned int getStartStateCount(void) const
Returns the number of start states.
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.
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 ...
std::vector< PlannerSolution > getSolutions(void) const
Get all the solution paths available for this goal.
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.
bool hasOptimizedSolution(void) const
Return true if the top found solution is optimized (satisfies the specified optimization objective) ...
void clearStartStates(void)
Clear all start states (memory is freed)
void addStartState(const ScopedState<> &state)
Add a start state. The state is copied.
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 plann...
bool hasSolution(void) const
Returns true if a solution path has been found (could be approximate)
void clearGoal(void)
Clear the goal. Memory is freed.
PlannerSolution(const PathPtr &path, bool approximate=false, double difference=-1.0)
Construct a solution that consists of a path and its attributes (whether it is approximate and the di...
SolutionNonExistenceProofPtr nonExistenceProof_
A Representation of a proof of non-existence of a solution for this problem definition.
const State * getStartState(unsigned int index) const
Returns a specific start state.
void clearSolutionPaths(void) const
Forget the solution paths (thread safe). Memory is freed.
bool approximate_
True if goal was not achieved, but an approximate solution was found.
double getSolutionDifference(void) const
Get the distance to the desired goal for the top solution. Return -1.0 if there are no solutions avai...
const SpaceInformationPtr & getSpaceInformation(void) const
Get the space information this problem definition is for.
bool operator<(const PlannerSolution &b) const
Define a ranking for solutions.
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.
std::size_t getSolutionCount(void) const
Get the number of solutions already found.
bool hasApproximateSolution(void) const
Return true if the top found solution is approximate (does not actually reach the desired goal...
void setSolutionNonExistenceProof(const SolutionNonExistenceProofPtr &nonExistenceProof)
Set the instance of SolutionNonExistenceProof for this problem definition.
PathPtr isStraightLinePathValid(void) const
Check if a straight line path is valid. If it is, return an instance of a path that represents the st...
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 ...
OptimizationObjectivePtr optimizationObjective_
The objective to be optimized while solving the planning problem.
StateType * get(void)
Returns a pointer to the contained state.
int index_
When multiple solutions are found, each is given a number starting at 0, so that the order in which t...
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 automa...
std::vector< State * > startStates_
The set of start states.
Definition of an abstract state.
bool operator==(const PlannerSolution &p) const
Return true if two solutions are the same.
Abstract definition of optimization objectives.
bool fixInvalidInputState(State *state, double dist, bool start, unsigned int attempts)
Helper function for fixInvalidInputStates(). Attempts to fix an individual state. ...
Definition of a problem to be solved. This includes the start state(s) for the system and a goal spec...
A boost shared pointer wrapper for ompl::base::OptimizationObjective.
const OptimizationObjectivePtr & getOptimizationObjective(void) const
Get the optimization objective to be considered during planning.
SpaceInformationPtr si_
The space information this problem definition is for.
ProblemDefinition(const SpaceInformationPtr &si)
Create a problem definition given the SpaceInformation it is part of.
void addStartState(const State *state)
Add a start state. The state is copied.
A boost shared pointer wrapper for ompl::base::Goal.
void clearSolutionNonExistenceProof(void)
Removes any existing instance of SolutionNonExistenceProof.
double difference_
The achieved difference between the found solution and the desired 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 ca...
bool hasOptimizationObjective(void) const
Check if an optimization objective was defined for planning.
double length_
For efficiency reasons, keep the length of the path as well.
bool hasSolutionNonExistenceProof(void) const
Returns true if the problem definition has a proof of non existence for a solution.
A boost shared pointer wrapper for ompl::base::Path.