Inheritance diagram for ompl::control::LTLProblemDefinition:

Public Member Functions
	LTLProblemDefinition (const control::LTLSpaceInformationPtr &ltlsi)

void	addLowerStartState (const base::State *s)

base::PathPtr	getLowerSolutionPath () const

Public Member Functions inherited from ompl::base::ProblemDefinition
	ProblemDefinition (const ProblemDefinition &)=delete

ProblemDefinition &	operator= (const ProblemDefinition &)=delete

	ProblemDefinition (SpaceInformationPtr si)
	Create a problem definition given the SpaceInformation it is part of.

ProblemDefinitionPtr	clone () const
	Return a copy of the problem definition. More...

const SpaceInformationPtr &	getSpaceInformation () 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. More...

bool	hasStartState (const State state, unsigned int startIndex=nullptr) const
	Check whether a specified starting state is already included in the problem definition and optionally return the index of that starting state.

void	clearStartStates ()
	Clear all start states (memory is freed)

unsigned int	getStartStateCount () 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. More...

void	setGoal (const GoalPtr &goal)
	Set the goal.

void	clearGoal ()
	Clear the goal. Memory is freed.

const GoalPtr &	getGoal () 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, double threshold=std::numeric_limits< double >::epsilon())
	In the simplest case possible, we have a single starting state and a single goal state. More...

void	setGoalState (const State *goal, 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. More...

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() More...

bool	hasOptimizationObjective () const
	Check if an optimization objective was defined for planning

const OptimizationObjectivePtr &	getOptimizationObjective () const
	Get the optimization objective to be considered during planning.

void	setOptimizationObjective (const OptimizationObjectivePtr &optimizationObjective)
	Set the optimization objective to be considered during planning.

const ReportIntermediateSolutionFn &	getIntermediateSolutionCallback () const
	When this function returns a valid function pointer, that function should be called by planners that compute intermediate solutions every time a better solution is found.

void	setIntermediateSolutionCallback (const ReportIntermediateSolutionFn &callback)
	Set the callback to be called by planners that can compute intermediate solutions.

bool	isTrivial (unsigned int startIndex=nullptr, double distance=nullptr) 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 () const
	Check if a straight line path is valid. If it is, return an instance of a path that represents the straight line. More...

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 () const
	Returns true if a solution path has been found (could be approximate)

bool	hasExactSolution () const
	Returns true if an exact solution path has been found. Specifically returns hasSolution && !hasApproximateSolution()

bool	hasApproximateSolution () 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 () const
	Get the distance to the desired goal for the top solution. Return -1.0 if there are no solutions available.

bool	hasOptimizedSolution () const
	Return true if the top found solution is optimized (satisfies the specified optimization objective)

PathPtr	getSolutionPath () const
	Return the top solution path, if one is found. The top path is a shortest path that was found, preference being given to solutions that are not approximate. More...

bool	getSolution (PlannerSolution &solution) const
	Return true if a top solution is found, with the top solution passed by reference in the function header The top path is a shortest path 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.

void	addSolutionPath (const PathPtr &path, bool approximate=false, double difference=-1.0, const std::string &plannerName="Unknown") 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. Optionally, the name of the planner that generated the solution.

void	addSolutionPath (const PlannerSolution &sol) const
	Add a solution path in a thread-safe manner. Multiple solutions can be set for a goal.

std::size_t	getSolutionCount () const
	Get the number of solutions already found.

std::vector< PlannerSolution >	getSolutions () const
	Get all the solution paths available for this goal.

void	clearSolutionPaths () const
	Forget the solution paths (thread safe). Memory is freed.

bool	hasSolutionNonExistenceProof () const
	Returns true if the problem definition has a proof of non existence for a solution.

void	clearSolutionNonExistenceProof ()
	Removes any existing instance of SolutionNonExistenceProof.

const SolutionNonExistenceProofPtr &	getSolutionNonExistenceProof () 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.

void	print (std::ostream &out=std::cout) const
	Print information about the start and goal states and the optimization objective.

Protected Member Functions
void	createGoal ()

Protected Member Functions inherited from ompl::base::ProblemDefinition
bool	fixInvalidInputState (State *state, double dist, bool start, unsigned int attempts)
	Helper function for fixInvalidInputStates(). Attempts to fix an individual state.

Protected Attributes
LTLSpaceInformationPtr	ltlsi_

Protected Attributes inherited from ompl::base::ProblemDefinition
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.

OptimizationObjectivePtr	optimizationObjective_
	The objective to be optimized while solving the planning problem.

ReportIntermediateSolutionFn	intermediateSolutionCallback_
	Callback function which is called when a new intermediate solution has been found.

Detailed Description

Definition at line 119 of file LTLProblemDefinition.h.

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

ompl/control/planners/ltl/LTLProblemDefinition.h
ompl/control/planners/ltl/src/LTLProblemDefinition.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description