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

## Classes | |

class | AllValidStateValidityChecker |

The simplest state validity checker: all states are valid. 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 | CompoundState |

Definition of a compound state. More... | |

class | CompoundStateSampler |

Definition of a compound state sampler. This is useful to construct samplers for compound states. More... | |

class | CompoundStateSpace |

A space to allow the composition of state spaces. More... | |

class | Cost |

Definition of a cost value. Can represent the cost of a motion or the cost of a state. More... | |

class | DiscreteMotionValidator |

A motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution. More... | |

class | DiscreteStateSampler |

State space sampler for discrete states. More... | |

class | DiscreteStateSpace |

A space representing discrete states; i.e. there are a small number of discrete states the system can be in. States are represented as integers [lowerBound, upperBound], where lowerBound and upperBound are inclusive. States do not wrap around; i.e. the distance between state lowerBound and state upperBound is upperBound-lowerBound. The dimension of the space is 1. More... | |

class | DubinsMotionValidator |

A Dubins motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution. More... | |

class | DubinsStateSpace |

An SE(2) state space where distance is measured by the length of Dubins curves. More... | |

class | GaussianValidStateSampler |

Generate valid samples using the Gaussian sampling strategy. More... | |

class | GenericParam |

Motion planning algorithms often employ parameters to guide their exploration process. (e.g., goal biasing). Motion planners (and some of their components) use this class to declare what the parameters are, in a generic way, so that they can be set externally. More... | |

class | Goal |

Abstract definition of goals. More... | |

class | GoalLazySamples |

Definition of a goal region that can be sampled, but the sampling process can be slow. This class allows sampling the happen in a separate thread, and the number of goals may increase, as the planner is running, in a thread-safe manner. More... | |

class | GoalPtr |

A shared pointer wrapper for ompl::base::Goal. More... | |

class | GoalRegion |

Definition of a goal region. More... | |

class | GoalSampleableRegion |

Abstract definition of a goal region that can be sampled. More... | |

class | GoalState |

Definition of a goal state. More... | |

class | GoalStates |

Definition of a set of goal states. More... | |

class | InformedSampler |

An abstract class for the concept of using information about the state space and the current solution cost to limit future search to a planning subproblem that contains all possibly better solutions. More... | |

class | InformedStateSampler |

A wrapper class that allows an InformedSampler to be used as a StateSampler. More... | |

class | IterationTerminationCondition |

A class to run a planner for a specific number of iterations. Casts to a PTC for use with Planner::solve. More... | |

class | LightningRetrieveRepairPtr |

A shared pointer wrapper for ompl::base::LightningRetrieveRepair. More... | |

class | MaximizeClearanceValidStateSampler |

Generate valid samples randomly, but with a bias towards higher clearance. More... | |

class | MaximizeMinClearanceObjective |

Objective for attempting to maximize the minimum clearance along a path. More... | |

class | MechanicalWorkOptimizationObjective |

An optimization objective which defines path cost using the idea of mechanical work. To be used in conjunction with TRRT. More... | |

class | MinimaxObjective |

The cost of a path is defined as the worst state cost over the entire path. This objective attempts to find the path with the "best worst cost" over all paths. More... | |

class | MinimumClearanceValidStateSampler |

Generate valid samples randomly with extra requirement of min for clearance to nearest obstacle. More... | |

class | MorseEnvironment |

This class contains the MORSE constructs OMPL needs to know about when planning. More... | |

class | MorseEnvironmentPtr |

A shared pointer wrapper for ompl::base::MorseEnvironment. 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 | MotionValidator |

Abstract definition for a class checking the validity of motions – path segments between states. This is often called a local planner. The implementation of this class must be thread safe. More... | |

class | MotionValidatorPtr |

A shared pointer wrapper for ompl::base::MotionValidator. More... | |

class | MultiOptimizationObjective |

This class allows for the definition of multiobjective optimal planning problems. Objectives are added to this compound object, and motion costs are computed by taking a weighted sum of the individual objective costs. More... | |

class | ObstacleBasedValidStateSampler |

Generate valid samples using obstacle based sampling. First sample an invalid state, then sample a valid state. Then, interpolate from the invalid state to the valid state, returning the first valid state encountered. More... | |

class | OptimizationObjective |

Abstract definition of optimization objectives. More... | |

class | OptimizationObjectivePtr |

A shared pointer wrapper for ompl::base::OptimizationObjective. More... | |

class | OrderedInfSampler |

An informed sampler wrapper that generates m samples and then returns them in order of the heuristic. More... | |

class | ParamSet |

Maintain a set of parameters. More... | |

class | Path |

Abstract definition of a path. More... | |

class | PathLengthDirectInfSampler |

An informed sampler for problems seeking to minimize path length. More... | |

class | PathLengthOptimizationObjective |

An optimization objective which corresponds to optimizing path length. More... | |

class | PathPtr |

A shared pointer wrapper for ompl::base::Path. More... | |

class | Planner |

Base class for a planner. More... | |

class | PlannerData |

Object containing planner generated vertex and edge data. It is assumed that all vertices are unique, and only a single directed edge connects two vertices. More... | |

class | PlannerDataEdge |

Base class for a PlannerData edge. More... | |

class | PlannerDataPtr |

A shared pointer wrapper for ompl::base::PlannerData. More... | |

class | PlannerDataStorage |

Object that handles loading/storing a PlannerData object to/from a binary stream. Serialization of vertices and edges is performed using the Boost archive method serialize. Derived vertex/edge classes are handled, presuming those classes implement the serialize method. More... | |

class | PlannerDataVertex |

Base class for a vertex in the PlannerData structure. All derived classes must implement the clone and equivalence operators. It is assumed that each vertex in the PlannerData structure is unique (i.e. no duplicates allowed). More... | |

class | PlannerInputStates |

Helper class to extract valid start & goal states. Usually used internally by planners. More... | |

class | PlannerPtr |

A shared pointer wrapper for ompl::base::Planner. More... | |

struct | PlannerSolution |

Representation of a solution to a planning problem. More... | |

struct | PlannerSpecs |

Properties that planners may have. More... | |

struct | PlannerStatus |

A class to store the exit status of Planner::solve() More... | |

class | PlannerTerminationCondition |

Encapsulate a termination condition for a motion planner. Planners will call operator() to decide whether they should terminate before a solution is found or not. operator() will return true if either the implemented condition is met (the call to eval() returns true) or if the user called terminate(true). More... | |

class | PrecomputedStateSampler |

State space sampler for discrete states. More... | |

class | ProblemDefinition |

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... | |

class | ProblemDefinitionPtr |

A shared pointer wrapper for ompl::base::ProblemDefinition. More... | |

class | ProjectionEvaluator |

Abstract definition for a class computing projections to R^{n}. Implicit integer grids are imposed on this projection space by setting cell sizes. Before use, the user must supply cell sizes for the integer grid (setCellSizes()). The implementation of this class is thread safe. More... | |

class | ProjectionEvaluatorPtr |

A shared pointer wrapper for ompl::base::ProjectionEvaluator. More... | |

class | ProjectionMatrix |

A projection matrix – it allows multiplication of real vectors by a specified matrix. The matrix can also be randomly generated. More... | |

class | RealVectorBounds |

The lower and upper bounds for an R^{n} space. More... | |

class | RealVectorIdentityProjectionEvaluator |

Define the identity projection. More... | |

class | RealVectorLinearProjectionEvaluator |

Definition for a class computing linear projections (multiplication of a k-by-n matrix to the the R^{n} vector state to produce an R^{k} projection. The multiplication matrix needs to be supplied as input. More... | |

class | RealVectorOrthogonalProjectionEvaluator |

Definition for a class computing orthogonal projections. More... | |

class | RealVectorRandomLinearProjectionEvaluator |

Definition for a class computing a random linear projections. More... | |

class | RealVectorStateSampler |

State sampler for the R^{n} state space. More... | |

class | RealVectorStateSpace |

A state space representing R^{n}. The distance function is the L2 norm. More... | |

class | ReedsSheppMotionValidator |

A Reeds-Shepp motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution. More... | |

class | ReedsSheppStateSpace |

An SE(2) state space where distance is measured by the length of Reeds-Shepp curves. More... | |

class | RejectionInfSampler |

A default rejection sampling scheme that samples uniformly from the entire planning domain. Samples are rejected until one is found that has a heuristic solution estimate that is less than the current solution. In general, direct sampling of the informed subset is much better, but this is a general default. More... | |

struct | SamplerSelector |

Depending on the type of state sampler, we have different allocation routines. More... | |

class | ScopedState |

Definition of a scoped state. More... | |

class | SE2StateSpace |

A state space representing SE(2) More... | |

class | SE3StateSpace |

A state space representing SE(3) More... | |

class | SO2StateSampler |

State space sampler for SO(2) More... | |

class | SO2StateSpace |

A state space representing SO(2). The distance function and interpolation take into account angle wrapping. More... | |

class | SO3StateSampler |

State space sampler for SO(3), using quaternion representation. More... | |

class | SO3StateSpace |

A state space representing SO(3). The internal representation is done with quaternions. The distance between states is the angle between quaternions and interpolation is done with slerp. More... | |

class | SolutionNonExistenceProof |

Abstract definition of a proof for the non-existence of a solution to a problem. More... | |

class | SolutionNonExistenceProofPtr |

A shared pointer wrapper for ompl::base::SolutionNonExistenceProof. More... | |

class | SpaceInformation |

The base class for space information. This contains all the information about the space planning is done in. setup() needs to be called as well, before use. More... | |

class | SpaceInformationPtr |

A shared pointer wrapper for ompl::base::SpaceInformation. More... | |

class | SpecificParam |

This is a helper class that instantiates parameters with different data types. More... | |

class | State |

Definition of an abstract state. More... | |

class | StateCostIntegralObjective |

Defines optimization objectives where path cost can be represented as a path integral over a cost function defined over the state space. This cost function is specified by implementing the stateCost() method. More... | |

class | StatePropagatorPtr |

A shared pointer wrapper for ompl::control::StatePropagator. More... | |

class | StateSampler |

Abstract definition of a state space sampler. More... | |

class | StateSamplerArray |

Class to ease the creation of a set of samplers. This is especially useful for multi-threaded planners. More... | |

class | StateSamplerPtr |

A shared pointer wrapper for ompl::base::StateSampler. More... | |

class | StateSpace |

Representation of a space in which planning can be performed. Topology specific sampling, interpolation and distance are defined. More... | |

class | StateSpacePtr |

A shared pointer wrapper for ompl::base::StateSpace. More... | |

class | StateStorage |

Manage loading and storing for a set of states of a specified state space. More... | |

class | StateStorageWithMetadata |

State storage that allows storing state metadata as well. More... | |

class | StateValidityChecker |

Abstract definition for a class checking the validity of states. The implementation of this class must be thread safe. More... | |

class | StateValidityCheckerPtr |

A shared pointer wrapper for ompl::base::StateValidityChecker. More... | |

struct | StateValidityCheckerSpecs |

Properties that a state validity checker may have. More... | |

class | SubspaceProjectionEvaluator |

If the projection for a CompoundStateSpace is supposed to be the same as the one for one of its included subspaces, this class facilitates selecting a projection of that subspace. More... | |

class | SubspaceStateSampler |

Construct a sampler that samples only within a subspace of the space. More... | |

class | ThunderRetrieveRepairPtr |

A shared pointer wrapper for ompl::base::ThunderRetrieveRepair. More... | |

class | TimeStateSampler |

State space sampler for time. More... | |

class | TimeStateSpace |

A state space representing time. The time can be unbounded, in which case enforceBounds() is a no-op, satisfiesBounds() always returns true, sampling uniform time states always produces time 0 and getMaximumExtent() returns 1. If time is bounded (setBounds() has been previously called), the state space behaves as expected. After construction, the state space is unbounded. isBounded() can be used to check if the state space is bounded or not. More... | |

class | TypedSpaceInformation |

class | TypedStateValidityChecker |

class | UniformValidStateSampler |

A state sampler that only samples valid states, uniformly. More... | |

class | ValidStateSampler |

Abstract definition of a state sampler. More... | |

class | ValidStateSamplerPtr |

A shared pointer wrapper for ompl::base::ValidStateSampler. More... | |

class | VFMechanicalWorkOptimizationObjective |

class | VFUpstreamCriterionOptimizationObjective |

## Typedefs | |

typedef std::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 std::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 std::function< PlannerPtr(const SpaceInformationPtr &)> | PlannerAllocator |

Definition of a function that can allocate a planner. | |

typedef std::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 std::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 std::shared_ptr< ScopedState<> > | ScopedStatePtr |

Shared pointer to a ScopedState<> | |

typedef std::function< bool(const State *)> | StateValidityCheckerFn |

If no state validity checking class is specified (StateValidityChecker), a std::function can be specified instead. | |

typedef std::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 std::shared_ptr< GraphStateStorage > | GraphStateStoragePtr |

typedef std::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 the cost-to-go of a state under the optimization objective is equivalent to the goal region's distanceGoal() . 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 weight, 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 weight) |

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 (time::duration duration) |

Return a termination condition that will become true duration 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. | |

PlannerTerminationCondition | exactSolnPlannerTerminationCondition (const ompl::base::ProblemDefinitionPtr &pdef) |

Return a termination condition that will become true as soon as the problem definition has an exact solution. | |

OMPL_CLASS_FORWARD (OptimizationObjective) | |

OMPL_CLASS_FORWARD (InformedSampler) | |

OMPL_CLASS_FORWARD (InformedStateSampler) | |

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

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. | |

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

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

## 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

## ◆ GoalType

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 45 of file GoalTypes.h.

## ◆ StateSpaceType

The type of a state space.

Definition at line 45 of file StateSpaceTypes.h.