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: ``emplaceFrame()`` does only make sense, if the frame property has non-default
  constructors.
  
  #### Removing Frames
  Frames can be removed by calling ``removeFrame()``:
  ```
  EnvireGraph g;
  const FrameId frame = "frame_a";
  g.addFrame(frame);
  g.disconnectFrame(frame);
  g.removeFrame(frame);
  ```
  
  ``disconnectFrame()`` removes all transforms that are connected to the given frame.
  Frames can only be removed, if they are not connected to the graph. I.e. if no
  
negative.code: 	std::cerr << "Unabled to load envire::octomap::OcTree" << std::endl;
  	return -1;
  }
  ----
  
  It is also possible to instantiate items directly, however this is only
  recommended for testing because visualization and serialization only work if
  the ``ClassLoader`` was used to load the item.
  
  ==== Adding Item
  Once the item is loaded, there are two ways to add it to the graph.
  The common way is to add it using ``addItemToFrame()``:
  [source,c++]
  
  ----
  g.addItemToFrame(frame, octree);
  ----
  
  The item will remember the frame that it was added to. I.e. an item cannot be part of two frames at the same time.
  
  It is also possible to set the frame id beforehand and add the item using
  ``addItem()``.
  [source,c++]
  
  ----
  octree->setFrame(frame);
  g.addItem(octree);
  ----
  
  The item type can be a ``boost::shared_ptr`` to any subclass of ``ItemBase``.
  Item contains a typedef ``Ptr`` to make working with the pointer more convenient.
  [source,c++]
  
  ----
  envire::core::Item<...>::Ptr p;
  ----
  
  ==== Accessing Items
  When working with items, the user needs to know the item type. The type can
  either be provided at compile time using template parameters or at runtime using
  ``std::type_index``.
  
  ==== Checking Whether a Frame Contains Items of a Specific Type
  ``containsItems()`` is used to check for the existence of items of a given type
  in a given frame.
  [source,c++]
  
  ----
  const bool contains = g.containsItems<envire::core::Item<boost::shared_ptr<octomap::AbstractOcTree>>>(frame);
  ----
  
  If the type is not known at compile time, there is also an overload that
  accepts ``std::type_index``. You can get the type index by calling
  ``getTypeIndex()`` on any ``Item``.
  
  [source,c++]
  ----
  const std::type_index index(octree->getTypeIndex());
  const bool contains2 = g.containsItems(frame, index);
  ----
  
  
  ==== Accessing Items with Iterators
  
  The ``ItemIterator`` can be used to iterate over all items of a specific type
  in a frame. The iterator internally takes care of the necessary type casting
  and type checks.
  
  [source,c++]
  ----
  using OcTreeItem = envire::core::Item<boost::shared_ptr<octomap::AbstractOcTree>>;
  using OcTreeItemIt = EnvireGraph::ItemIterator<envire::core::Item<boost::shared_ptr<octomap::AbstractOcTree>>>;
  OcTreeItemIt it, end;
  