anchor.diff:  
   First make sure that all dependencies are installed.
   Most of the dependencies can be installed using apt:
  -```
  +----
   apt install build-essential gcc g++ cmake git wget libgoogle-glog-dev libboost-test-dev libboost-filesystem-dev libboost-serialization-dev libboost-system-dev pkg-config libeigen3-dev libclass-loader-dev libtinyxml-dev librosconsole-bridge-dev libeigen3-dev libclass-loader-dev libtinyxml-dev
  -```
  +----
   
   Some dependencies need to be build from source. A script is provided to install those:
  -```
  +[source,bash]
  +----
   chmod +x install_dependencies.sh
   sudo ./install_dependencies.sh [path_to_prefix]
  -```
  +----
   If no prefix is provided, the dependencies will be installed system-wide.
   
   
  
positive.code: {
  	std::cout << "Item uuid: " << it->getIDString() << std::endl;
  }
  ```
  
  A convenience method exist to get an ``ItemIterator`` of the i'th item:
  ```
  OcTreeItemIt itemIt = g.getItem<OcTreeItem>(frame, 42);
  ```
  
  #### Accessing Items without Iterators
  If type information is not available at compile time, ``getItems()`` can also
  be used with ``std::type_index``:
  ```const std::type_index index2(octree->getTypeIndex());
  const Frame::ItemList& items = g.getItems(frame, index2);
  ```
  However without compile time type information automatic type casting is not
  available, thus in this case ``getItems`` returns a list of ``ItemBase::Ptr``.
  The list is returned as reference and points to graph internal memory.
  
  
  #### Removing Items
  
  Items can be removed by calling ``removeItemFromFrame()``. Removing items invalidates
  all iterators of the same type. To be able to iteratively remove items, the
  method returns a new pair of iterators.
  ```
  OcTreeItemIt i, endI;
  std::tie(i, endI) = g.getItems<OcTreeItem>(frame);
  for(; i != endI;)
  {
  		std::tie(i, endI) = g.removeItemFromFrame(frame, i);
  }
  ```
  
  All items can be removed at once using ``clearFrame()``.
  ```
  g.clearFrame(frame);
  ```
  
  #### Adding Transformations
  ```
  EnvireGraph g;
  const FrameId a = "frame_a";
  const FrameId b = "frame_b";
  Transform ab;
  /** initialize Transform */
  g.addTransform(a, b, ab);
  ```
  If a transformation is added, the inverse will be added automatically.
  If one or both of the frames are not part of the graph, they will be added.
  
  #### Removing Transformations
  ```
  g.removeTransform(a, b);
  ```
  The inverse will be removed as well.
  
  #### Modifying Transformations
  Transformations can be replaced using ``updateTransform``.
  The inverse will be updated automatically.
  ```
  Transform tf;
  tf.transform.translation << 84, 21, 42;
  g.updateTransform(a, b, tf);
  ```
  
  
  #### Calculating Transformations
  ``getTransform()`` can be used to calculate the transformation between two
  frames if a path connecting the two exists in the graph. Breadth first search is
  used to find the path connecting the two frames.
  ```
  const Transform tf2 = g.getTransform(a, b);
  ```
  
  Calculating the transformation between two frames might be expensive depending
  on the complexity of the graph structure. A ``TreeView`` can be used to speed
  up the calculation:
  ```
  TreeView view = g.getTree(g.getVertex(a));
  const Transform tf3 = g.getTransform(a, b, view);
  ```
  
  Since creating the ``TreeView`` walks the whole graph once, using this methods
  only makes sense when multiple transformations need to be calculated.
  
negative.code: 	should contain the existing doxygen file: doxygen.conf
  
  
  == Graph Usage Examples
  This section contains a few usage examples that showcase most of the graph's features.
  
  === Frames
  ==== Adding Frames
  Frames can be added either explicitly by calling ``addFrame()``
  [source,c++]
  ----
  EnvireGraph g;
  const FrameId frame = "frame_a";
  g.addFrame(frame);
  ----
  
  or implicitly by using a unknown frame id in ``addTransform()``.
  
  [source,c++]
  ----
  EnvireGraph g;
  const FrameId frameA = "frame_a";
  const FrameId frameB = "frame_b";
  Transform tf;
  g.addTransform(frameA, frameB, tf);
  
  ----
  Frames cannot be added twice. If a frame with the given name already exists,
  an exception will be thrown.
  
  