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