All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator
Operators for States and Manifolds

Functions

template<class T >
std::ostream & ompl::base::operator<< (std::ostream &out, const ScopedState< T > &state)
 Overload stream output operator. Calls ompl::base::StateManifold::printState()
template<class T , class Y >
ScopedState< T > & ompl::base::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 > & ompl::base::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 ompl::base::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).
StateManifoldPtr ompl::base::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 ompl::base::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 ompl::base::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 ompl::base::operator* (const StateManifoldPtr &a, const StateManifoldPtr &b)
 Construct a compound manifold that contains submanifolds that are in both a and b.

Detailed Description

These operators are intended to simplify code that manipulates states and manifolds. They rely on the fact that manifolds have unique names. Here are some examples for using these operators:

           // Assume X, Y, Z, W are state manifold instances, none of
           // which inherits from ompl::base::CompoundStateManifold.
           // Denote a compound manifold as C[...], where "..." is the
           // list of submanifolds.

           ompl::base::StateManifoldPtr X;
           ompl::base::StateManifoldPtr Y;
           ompl::base::StateManifoldPtr Z;
           ompl::base::StateManifoldPtr W;

           // the following line will construct a manifold C1 = C[X, Y]
           ompl::base::StateManifoldPtr C1 = X + Y;

           // the following line will construct a manifold C2 = C[X, Y, Z]
           ompl::base::StateManifoldPtr C2 = C1 + Z;

           // the following line will leave C2 as C[X, Y, Z]
           ompl::base::StateManifoldPtr C2 = C1 + C2;

           // the following line will construct a manifold C2 = C[X, Y, Z, W]
           ompl::base::StateManifoldPtr C2 = C2 + W;

           // the following line will construct a manifold C3 = C[X, Z, Y]
           ompl::base::StateManifoldPtr C3 = X + Z + Y;

           // the following line will construct a manifold C4 = C[Z, W]
           ompl::base::StateManifoldPtr C4 = C2 - C1;

           // the following line will construct a manifold C5 = W
           ompl::base::StateManifoldPtr C5 = C2 - C3;

           // the following line will construct an empty manifold C6 = C[]
           ompl::base::StateManifoldPtr C6 = X - X;

           // the following line will construct an empty manifold C7 = Y
           ompl::base::StateManifoldPtr C7 = Y + C6;

These manifolds can be used when operating with states:

           ompl::base::ScopedState<> sX(X);
           ompl::base::ScopedState<> sXY(X + Y);
           ompl::base::ScopedState<> sY(Y);
           ompl::base::ScopedState<> sZX(Z + X);
           ompl::base::ScopedState<> sXZW(X + Z + W);

           // the following line will copy the content of the state sX to
           // the corresponding locations in sXZW. The components of the state
           // corresponding to the Z and W manifolds are not touched
           sX >> sXZW;

           // the following line will initialize the X component of sXY with
           // the X component of sXZW;
           sXY << sXZW;

           // the following line will initialize both components of sZX, using
           // the X and Z components of sXZW;
           sZX << sXZW;

           // the following line compares the concatenation of states sX and sY with sXY
           // the concatenation will automatically construct the manifold X + Y and a state
           // from that manifold containing the information from sX and sY. Since sXY is
           // constructed from the manifold X + Y, the two are comparable.
           bool eq = (sX ^ sY) == sXY;