All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator
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  DiscreteMotionValidator
 A motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution. More...
class  Goal
 Abstract definition of goals. Will contain solutions, if found. 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  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  RealVectorBounds
 The lower and upper bounds for an Rn manifold. More...
class  RealVectorStateSampler
 State sampler for the Rn manifold. More...
class  RealVectorStateManifold
 A manifold representing Rn. The distance function is the L2 norm. More...
class  RealVectorLinearProjectionEvaluator
 Definition for a class computing linear projections (multiplication of a k-by-n matrix to the the Rn vector state to produce an Rk projection. The multiplication matrix needs to be supplied as input. More...
class  RealVectorRandomLinearProjectionEvaluator
 Definition for a class computing a random linear projections. More...
class  RealVectorOrthogonalProjectionEvaluator
 Definition for a class computing orthogonal projections. More...
class  RealVectorIdentityProjectionEvaluator
 Define the identity projection. More...
class  SE2StateManifold
 A manifold representing SE(2) More...
class  SE3StateManifold
 A manifold representing SE(3) More...
class  SO2StateSampler
 Manifold sampler for SO(2) More...
class  SO2StateManifold
 A manifold representing SO(2). The distance function and interpolation take into account angle wrapping. More...
class  SO3StateSampler
 Manifold sampler for SO(3), using quaternion representation. More...
class  SO3StateManifold
 A manifold 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  TimeStateSampler
 Manifold sampler for time. More...
class  TimeStateManifold
 A manifold 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 manifold behaves as expected. After construction, the manifold is unbounded. isBounded() can be used to check if the manifold is bounded or not. More...
class  ManifoldStateSampler
 Abstract definition of a manifold state sampler. More...
class  CompoundManifoldStateSampler
 Definition of a compound state sampler. This is useful to construct samplers for compound states. 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  Path
 Abstract definition of a path. More...
class  PlannerInputStates
 Helper class to extract valid start & goal states. Usually used internally by planners. More...
class  Planner
 Base class for a planner. More...
class  PlannerData
 Datatype holding data a planner can expose for debug purposes. More...
class  ProblemDefinition
 Definition of a problem to be solved. This includes the start state(s) for the system and a goal specification. More...
class  EuclideanProjection
 The datatype for state projections. This class contains a real vector. 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  ProjectionEvaluator
 Abstract definition for a class computing projections to Rn. 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  GaussianValidStateSampler
 Generate valid samples using the Gaussian sampling strategy. More...
class  MaximizeClearanceValidStateSampler
 Generate valid samples randomly, but with a bias towards higher clearance. More...
class  ObstacleBasedValidStateSampler
 Generate valid samples using the Bridge Test. More...
class  UniformValidStateSampler
 A state sampler that only samples valid states, uniformly. More...
class  ScopedState
 Definition of a scoped state. 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  State
 Definition of an abstract state. More...
class  CompoundState
 Definition of a compound state. More...
class  StateManifold
 Representation of a space in which planning can be performed. Topology specific sampling, interpolation and distance are defined. More...
class  CompoundStateManifold
 A manifold to allow the composition of state manifolds. More...
struct  SamplerSelector
 Depending on the type of sampler, we have different allocation routines. More...
class  StateSamplerArray
 Class to ease the creation of a set of samplers. This is especially useful for multi-threaded planners. More...
class  StateValidityChecker
 Abstract definition for a class checking the validity of states. The implementation of this class must be thread safe. More...
class  AllValidStateValidityChecker
 The simplest state validity checker: all states are valid. More...
class  ValidStateSampler
 Abstract definition of a state sampler. More...
class  GoalPtr
 A boost shared pointer wrapper for ompl::base::Goal. More...
class  ManifoldStateSamplerPtr
 A boost shared pointer wrapper for ompl::base::ManifoldStateSampler. More...
class  MotionValidatorPtr
 A boost shared pointer wrapper for ompl::base::MotionValidator. 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  ProblemDefinitionPtr
 A boost shared pointer wrapper for ompl::base::ProblemDefinition. More...
class  ProjectionEvaluatorPtr
 A boost shared pointer wrapper for ompl::base::ProjectionEvaluator. More...
class  SpaceInformationPtr
 A boost shared pointer wrapper for ompl::base::SpaceInformation. More...
class  StateManifoldPtr
 A boost shared pointer wrapper for ompl::base::StateManifold. 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...

Typedefs

typedef boost::function2< 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.
typedef boost::function0< bool > PlannerTerminationCondition
 Datatype for functions deciding whether termination conditions have been met for the 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::function1
< PlannerPtr, const
SpaceInformationPtr & > 
PlannerAllocator
 Definition of a function that can allocate a planner.
typedef std::vector< int > ProjectionCoordinates
 Grid cells corresponding to a projection value are described in terms of their coordinates.
typedef boost::shared_ptr
< ScopedState<> > 
ScopedStatePtr
 Shared pointer to a ScopedState<>
typedef boost::function1< bool,
const State * > 
StateValidityCheckerFn
 If no state validity checking class is specified (StateValidityChecker), a boost function can be specified instead.
typedef boost::function1
< ValidStateSamplerPtr, const
SpaceInformation * > 
ValidStateSamplerAllocator
 Definition of a function that can allocate a state sampler.

Enumerations

enum  PlannerType {
  PLAN_UNKNOWN = 0, PLAN_TO_GOAL_STATE = 1, PLAN_TO_GOAL_STATES = 2, PLAN_TO_GOAL_SAMPLEABLE_REGION = 4 | PLAN_TO_GOAL_STATES | PLAN_TO_GOAL_STATE,
  PLAN_TO_GOAL_REGION = 8 | PLAN_TO_GOAL_SAMPLEABLE_REGION, PLAN_TO_GOAL_ANY = 32768 | PLAN_TO_GOAL_REGION
}
 Different planners may be able to handle only specific types of goal regions. For instance, the most general goal representation is not suitable for bi-directional planners. Planners set their type to specify which type of goal regions they can handle. More...
enum  StateManifoldType {
  STATE_MANIFOLD_UNKNOWN = 0, STATE_MANIFOLD_REAL_VECTOR = 1, STATE_MANIFOLD_SO2 = 2, STATE_MANIFOLD_SO3 = 3,
  STATE_MANIFOLD_SE2 = 4, STATE_MANIFOLD_SE3 = 5, STATE_MANIFOLD_TIME = 6, STATE_MANIFOLD_TYPE_COUNT
}
 The type of a state manifold. More...

Functions

 ClassForward (Goal)
 Forward declaration of ompl::base::Goal.
 ClassForward (StateManifold)
 Forward declaration of ompl::base::StateManifold.
 ClassForward (ManifoldStateSampler)
 Forward declaration of ompl::base::ManifoldStateSampler.
 ClassForward (SpaceInformation)
 Forward declaration of ompl::base::SpaceInformation.
 ClassForward (MotionValidator)
 Forward declaration of ompl::base::MotionValidator.
 ClassForward (Path)
 Forward declaration of ompl::base::Path.
 ClassForward (Planner)
 Forward declaration of ompl::base::Planner.
 ClassForward (ProblemDefinition)
 Forward declaration of ompl::base::ProblemDefinition.
 ClassForward (ProjectionEvaluator)
 Forward declaration of ompl::base::ProjectionEvaluator.
template<class T >
std::ostream & operator<< (std::ostream &out, const ScopedState< T > &state)
 Overload stream output operator. Calls ompl::base::StateManifold::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 manifolds, the data is copied from from to to on a component by component basis. Manifolds are matched by name. If the manifold for to contains any sub-manifold whose name matches any sub-manifold of the manifold 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 manifolds, the data is copied from from to to on a component by component basis. Manifolds are matched by name. If the manifold for to contains any sub-manifold whose name matches any sub-manifold of the manifold for from, the corresponding state components are copied.
template<class T , class Y >
ScopedState operator^ (const ScopedState< T > &a, const ScopedState< Y > &b)
 Given state a from manifold A and state b from manifold B, construct a state from manifold A + B. The resulting state contains all the information from the input states (the states are concatenated).
int copyStateData (const StateManifoldPtr &destM, State *dest, const StateManifoldPtr &sourceM, const State *source)
 Copy data from source (state from manifold sourceM) to dest (state from manifold destM) on a component by component basis. Manifolds are matched by name. If the manifold destM contains any sub-manifold whose name matches any sub-manifold of the manifold sourceM, the corresponding state components are copied. The return value is either 0 (no data copied), 1 (some data copied), 2 (all data copied)
StateManifoldPtr operator+ (const StateManifoldPtr &a, const StateManifoldPtr &b)
 Construct a compound manifold from two existing manifolds. The components of this compound manifold are a (or the components of a, if a is compound) and b (or the components of b, if b is compound). Manifolds are identified by name. Duplicates are checked for and added only once. If the compound manifold would contain solely one component, that component is returned instead.
StateManifoldPtr operator- (const StateManifoldPtr &a, const StateManifoldPtr &b)
 Construct a compound manifold that contains submanifolds 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 manifold. If the compound manifold would contain solely one component, that component is returned instead.
StateManifoldPtr operator- (const StateManifoldPtr &a, const std::string &name)
 Construct a compound manifold that contains submanifolds only from a, except for maybe the one named name.
StateManifoldPtr operator* (const StateManifoldPtr &a, const StateManifoldPtr &b)
 Construct a compound manifold that contains submanifolds that are in both a and b.
 ClassForward (StateValidityChecker)
 Forward declaration of ompl::base::StateValidityChecker.
 ClassForward (ValidStateSampler)
 Forward declaration of ompl::base::ValidStateSampler.

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

Different planners may be able to handle only specific types of goal regions. For instance, the most general goal representation is not suitable for bi-directional planners. Planners set their type to specify which type of goal regions they can handle.

Enumerator:
PLAN_UNKNOWN 

This value should not be set.

PLAN_TO_GOAL_STATE 

This bit is set if planning to goal states (ompl::base::GoalState) is possible.

PLAN_TO_GOAL_STATES 

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

PLAN_TO_GOAL_SAMPLEABLE_REGION 

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

PLAN_TO_GOAL_REGION 

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

PLAN_TO_GOAL_ANY 

This bit is set if planning to generic goal regions (ompl::base::Goal) is possible.

Definition at line 60 of file Planner.h.

The type of a state manifold.

Enumerator:
STATE_MANIFOLD_UNKNOWN 

Unset type; this is the default type.

STATE_MANIFOLD_REAL_VECTOR 

ompl::base::RealVectorStateManifold

STATE_MANIFOLD_SO2 

ompl::base::SO2StateManifold

STATE_MANIFOLD_SO3 

ompl::base::SO3StateManifold

STATE_MANIFOLD_SE2 

ompl::base::SE2StateManifold

STATE_MANIFOLD_SE3 

ompl::base::SE3StateManifold

STATE_MANIFOLD_TIME 

ompl::base::TimeStateManifold

STATE_MANIFOLD_TYPE_COUNT 

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

Definition at line 46 of file StateManifoldTypes.h.