ompl::base Namespace Reference

This namespace contains sampling based planning routines shared by both planning under geometric constraints (geometric) and planning under differential constraints (dynamic) More...

Classes

class  MorseEnvironment
 This class contains the MORSE constructs OMPL needs to know about when planning. More...
class  MorseGoal
 This is a goal class that is more amenable to Python. More...
class  MorseProjection
 This class implements a generic projection for the MorseStateSpace, namely, the subspace representing the x and y positions of every rigid body. More...
class  MorseStateSpace
 State space representing MORSE states. More...
class  MorseStateValidityChecker
 The simplest state validity checker: all states are valid if they are within bounds. More...
class  MorseTerminationCondition
 This class represents a termination condition for the planner that only terminates if the user shuts down the MORSE simulation. More...
class  CForestStateSampler
 Extended state sampler to use with the CForest planning algorithm. It wraps the user-specified state sampler. More...
class  CForestStateSpaceWrapper
 State space wrapper to use together with CForest. It adds some functionalities to the regular state spaces necessary to CForest. More...
class  GoalPtr
 A boost shared pointer wrapper for ompl::base::Goal. More...
class  MotionValidatorPtr
 A boost shared pointer wrapper for ompl::base::MotionValidator. More...
class  OptimizationObjectivePtr
 A boost shared pointer wrapper for ompl::base::OptimizationObjective. More...
class  PathPtr
 A boost shared pointer wrapper for ompl::base::Path. More...
class  PlannerPtr
 A boost shared pointer wrapper for ompl::base::Planner. More...
class  PlannerDataPtr
 A boost shared pointer wrapper for ompl::base::PlannerData. More...
class  ProblemDefinitionPtr
 A boost shared pointer wrapper for ompl::base::ProblemDefinition. More...
class  ProjectionEvaluatorPtr
 A boost shared pointer wrapper for ompl::base::ProjectionEvaluator. More...
class  SolutionNonExistenceProofPtr
 A boost shared pointer wrapper for ompl::base::SolutionNonExistenceProof. More...
class  SpaceInformationPtr
 A boost shared pointer wrapper for ompl::base::SpaceInformation. More...
class  StateSamplerPtr
 A boost shared pointer wrapper for ompl::base::StateSampler. More...
class  StateSpacePtr
 A boost shared pointer wrapper for ompl::base::StateSpace. More...
class  StateValidityCheckerPtr
 A boost shared pointer wrapper for ompl::base::StateValidityChecker. More...
class  ValidStateSamplerPtr
 A boost shared pointer wrapper for ompl::base::ValidStateSampler. More...
class  StatePropagatorPtr
 A boost shared pointer wrapper for ompl::control::StatePropagator. More...
class  MorseEnvironmentPtr
 A boost shared pointer wrapper for ompl::base::MorseEnvironment. More...

Typedefs

typedef boost::function< bool(const
GoalLazySamples *, State *) 
GoalSamplingFn )
 Goal sampling function. Returns false when no further calls should be made to it. Fills its second argument (the state) with the sampled goal state. This function need not be thread safe.
typedef boost::function< Cost(const
State *, const Goal *) 
CostToGoHeuristic )
 The definition of a function which returns an admissible estimate of the optimal path cost from a given state to a goal.
typedef boost::function
< PlannerPtr(const
SpaceInformationPtr &)> 
PlannerAllocator
 Definition of a function that can allocate a planner.
typedef boost::function< bool()> PlannerTerminationConditionFn
 Signature for functions that decide whether termination conditions have been met for a planner, even if no solution is found. This is usually reaching a time or memory limit. If the function returns true, the planner is signaled to terminate its computation. Otherwise, computation continues while this function returns false, until a solution is found.
typedef boost::function< void(const
Planner *, const std::vector
< const base::State * >
&, const Cost) 
ReportIntermediateSolutionFn )
 When a planner has an intermediate solution (e.g., optimizing planners), a function with this signature can be called to report the states of that solution.
typedef std::vector< int > ProjectionCoordinates
 Grid cells corresponding to a projection value are described in terms of their coordinates.
typedef
boost::numeric::ublas::vector
< double > 
EuclideanProjection
 The datatype for state projections. This class contains a real vector.
typedef boost::shared_ptr
< ScopedState<> > 
ScopedStatePtr
 Shared pointer to a ScopedState<>
typedef boost::function< bool(const
State *) 
StateValidityCheckerFn )
 If no state validity checking class is specified (StateValidityChecker), a boost function can be specified instead.
typedef boost::function
< StateSamplerPtr(const
StateSpace *) 
StateSamplerAllocator )
 Definition of a function that can allocate a state sampler.
typedef
StateStorageWithMetadata
< std::vector< std::size_t > > 
GraphStateStorage
 Storage of states where the metadata is a vector of indices. This is is typically used to store a graph.
typedef boost::shared_ptr
< GraphStateStorage
GraphStateStoragePtr
typedef boost::function
< ValidStateSamplerPtr(const
SpaceInformation *) 
ValidStateSamplerAllocator )
 Definition of a function that can allocate a valid state sampler.

Enumerations

enum  GoalType {
  GOAL_ANY = 1, GOAL_REGION = GOAL_ANY + 2, GOAL_SAMPLEABLE_REGION = GOAL_REGION + 4, GOAL_STATE = GOAL_SAMPLEABLE_REGION + 8,
  GOAL_STATES = GOAL_SAMPLEABLE_REGION + 16, GOAL_LAZY_SAMPLES = GOAL_STATES + 32
}
 The type of goal. More...
enum  AdvancedStateCopyOperation { NO_DATA_COPIED = 0, SOME_DATA_COPIED = 1, ALL_DATA_COPIED = 2 }
 The possible outputs for an advanced copy operation. More...
enum  StateSpaceType {
  STATE_SPACE_UNKNOWN = 0, STATE_SPACE_REAL_VECTOR = 1, STATE_SPACE_SO2 = 2, STATE_SPACE_SO3 = 3,
  STATE_SPACE_SE2 = 4, STATE_SPACE_SE3 = 5, STATE_SPACE_TIME = 6, STATE_SPACE_DISCRETE = 7,
  STATE_SPACE_TYPE_COUNT
}
 The type of a state space. More...

Functions

std::ostream & operator<< (std::ostream &stream, Cost c)
 Output operator for Cost.
Cost goalRegionCostToGo (const State *state, const Goal *goal)
 For use when goal region's distanceGoal() is equivalent to the cost-to-go of a state under the optimization objective. This function assumes that all states within the goal region's threshold have a cost-to-go of exactly zero. Note: goal is assumed to be of type ompl::base::GoalRegion.
OptimizationObjectivePtr operator+ (const OptimizationObjectivePtr &a, const OptimizationObjectivePtr &b)
 Given two optimization objectives, returns a MultiOptimizationObjective that combines the two objectives with both weights equal to 1.0.
OptimizationObjectivePtr operator* (double w, const OptimizationObjectivePtr &a)
 Given a weighing factor and an optimization objective, returns a MultiOptimizationObjective containing only this objective weighted by the given weight.
OptimizationObjectivePtr operator* (const OptimizationObjectivePtr &a, double w)
 Given a weighing factor and an optimization objective, returns a MultiOptimizationObjective containing only this objective weighted by the given weight.
std::ostream & operator<< (std::ostream &out, const PlannerStatus &status)
 Print a PlannerStatus object.
PlannerTerminationCondition plannerNonTerminatingCondition ()
 Simple termination condition that always returns false. The termination condition will never be met.
PlannerTerminationCondition plannerAlwaysTerminatingCondition ()
 Simple termination condition that always returns true. The termination condition will always be met.
PlannerTerminationCondition plannerOrTerminationCondition (const PlannerTerminationCondition &c1, const PlannerTerminationCondition &c2)
 Combine two termination conditions into one. If either termination condition returns true, this one will return true as well.
PlannerTerminationCondition plannerAndTerminationCondition (const PlannerTerminationCondition &c1, const PlannerTerminationCondition &c2)
 Combine two termination conditions into one. Both termination conditions need to return true for this one to return true.
PlannerTerminationCondition timedPlannerTerminationCondition (double duration)
 Return a termination condition that will become true duration seconds in the future (wall-time)
PlannerTerminationCondition timedPlannerTerminationCondition (double duration, double interval)
 Return a termination condition that will become true duration seconds in the future (wall-time), but is checked in a separate thread, every interval seconds; interval must be less than duration.
 OMPL_CLASS_FORWARD (OptimizationObjective)
template<class T >
std::ostream & operator<< (std::ostream &out, const ScopedState< T > &state)
 Overload stream output operator. Calls ompl::base::StateSpace::printState()
template<class T , class Y >
ScopedState< T > & operator<< (ScopedState< T > &to, const ScopedState< Y > &from)
 This is a fancy version of the assignment operator. It is a partial assignment, in some sense. The difference is that if the states are part of compound state spaces, the data is copied from from to to on a component by component basis. State spaces are matched by name. If the state space for to contains any subspace whose name matches any subspace of the state space for from, the corresponding state components are copied.
template<class T , class Y >
const ScopedState< T > & operator>> (const ScopedState< T > &from, ScopedState< Y > &to)
 This is a fancy version of the assignment operator. It is a partial assignment, in some sense. The difference is that if the states are part of compound state spaces, the data is copied from from to to on a component by component basis. State spaces are matched by name. If the state space for to contains any subspace whose name matches any subspace of the state space for from, the corresponding state components are copied.
template<class T , class Y >
const ScopedState operator^ (const ScopedState< T > &a, const ScopedState< Y > &b)
 Given state a from state space A and state b from state space B, construct a state from state space A + B. The resulting state contains all the information from the input states (the states are concatenated).
 OMPL_CLASS_FORWARD (SolutionNonExistenceProof)
 Forward declaration of ompl::base::SolutionNonExistenceProof.
AdvancedStateCopyOperation copyStateData (const StateSpacePtr &destS, State *dest, const StateSpacePtr &sourceS, const State *source)
 Copy data from source (state from space sourceS) to dest (state from space destS) on a component by component basis. State spaces are matched by name. If the state space destS contains any subspace whose name matches any subspace of the state space sourceS, the corresponding state components are copied.
AdvancedStateCopyOperation copyStateData (const StateSpace *destS, State *dest, const StateSpace *sourceS, const State *source)
 Copy data from source (state from space sourceS) to dest (state from space destS) on a component by component basis. State spaces are matched by name. If the state space destS contains any subspace whose name matches any subspace of the state space sourceS, the corresponding state components are copied.
AdvancedStateCopyOperation copyStateData (const StateSpacePtr &destS, State *dest, const StateSpacePtr &sourceS, const State *source, const std::vector< std::string > &subspaces)
 Copy data from source (state from space sourceS) to dest (state from space destS) but only for the subspaces indicated by name in subspaces. This uses StateSpace::getSubstateLocationsByName().
AdvancedStateCopyOperation copyStateData (const StateSpace *destS, State *dest, const StateSpace *sourceS, const State *source, const std::vector< std::string > &subspaces)
 Copy data from source (state from space sourceS) to dest (state from space destS) but only for the subspaces indicated by name in subspaces. This uses StateSpace::getSubstateLocationsByName().
StateSpacePtr operator+ (const StateSpacePtr &a, const StateSpacePtr &b)
 Construct a compound state space from two existing state spaces. The components of this compound space are a (or the components of a, if a is compound) and b (or the components of b, if b is compound). State spaces are identified by name. Duplicates are checked for and added only once. If the compound state space would end up containing solely one component, that component is returned instead.
StateSpacePtr operator- (const StateSpacePtr &a, const StateSpacePtr &b)
 Construct a compound state space that contains subspaces only from a. If a is compound, b (or the components from b, if b is compound) are removed and the remaining components are returned as a compound state space. If the compound space would end up containing solely one component, that component is returned instead.
StateSpacePtr operator- (const StateSpacePtr &a, const std::string &name)
 Construct a compound state space that contains subspaces only from a, except for maybe the one named name.
StateSpacePtr operator* (const StateSpacePtr &a, const StateSpacePtr &b)
 Construct a compound state space that contains subspaces that are in both a and b.

Detailed Description

This namespace contains sampling based planning routines shared by both planning under geometric constraints (geometric) and planning under differential constraints (dynamic)


Enumeration Type Documentation

The type of goal.

Enumerator:
GOAL_ANY 

This bit is set if casting to generic goal regions (ompl::base::Goal) is possible. This bit shold always be set.

GOAL_REGION 

This bit is set if casting to goal regions (ompl::base::GoalRegion) is possible.

GOAL_SAMPLEABLE_REGION 

This bit is set if casting to sampleable goal regions (ompl::base::GoalSampleableRegion) is possible.

GOAL_STATE 

This bit is set if casting to goal state (ompl::base::GoalState) is possible.

GOAL_STATES 

This bit is set if casting to goal states (ompl::base::GoalStates) is possible.

GOAL_LAZY_SAMPLES 

This bit is set if casting to goal states (ompl::base::GoalLazySamples) is possible.

Definition at line 46 of file GoalTypes.h.

The type of a state space.

Enumerator:
STATE_SPACE_UNKNOWN 

Unset type; this is the default type.

STATE_SPACE_REAL_VECTOR 

ompl::base::RealVectorStateSpace

STATE_SPACE_SO2 

ompl::base::SO2StateSpace

STATE_SPACE_SO3 

ompl::base::SO3StateSpace

STATE_SPACE_SE2 

ompl::base::SE2StateSpace

STATE_SPACE_SE3 

ompl::base::SE3StateSpace

STATE_SPACE_TIME 

ompl::base::TimeStateSpace

STATE_SPACE_DISCRETE 

ompl::base::DiscreteStateSpace

STATE_SPACE_TYPE_COUNT 

Number of state space types; To add new types, use values that are larger than the count.

Definition at line 46 of file StateSpaceTypes.h.


Function Documentation

ompl::base::OMPL_CLASS_FORWARD ( SolutionNonExistenceProof  )

Forward declaration of ompl::base::SolutionNonExistenceProof.

IGNORE

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines