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
enum ompl::base::GoalType |
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:
Definition at line 46 of file StateSpaceTypes.h.
Function Documentation
ompl::base::OMPL_CLASS_FORWARD | ( | SolutionNonExistenceProof | ) |
Forward declaration of ompl::base::SolutionNonExistenceProof.
IGNORE