All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator
Working with States and Manifolds

Allocating memory for states

See Operating with states for how to fill the contents of the allocated states.

Operating with states

In order for states to be useful in setting start (or goal) positions, accessing their content is needed. It is assumed the reader is familiar with Allocating memory for states. Furthermore, operators on states and manifolds are also used.

Operators for States and Manifolds

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;