diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 313085b1be..e9b2cedff7 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,329 +1,329 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkTemporalJoinImagesFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkCrosshairManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSliceNavigationHelper.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
 
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
+  DataManagement/mitkCrosshairData.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNodePredicateSubGeometry.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
   Interactions/mitkDisplayActionEventHandlerStd.cpp
   Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkUtf8Util.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
   IO/mitkIOMetaInformationPropertyConstants.cpp
   IO/mitkIPreferences.cpp
   IO/mitkPreferences.cpp
   IO/mitkIPreferencesService.cpp
   IO/mitkPreferencesService.cpp
   IO/mitkIPreferencesStorage.cpp
   IO/mitkXMLPreferencesStorage.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkBaseRendererHelper.cpp
-  #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
+  Rendering/mitkCrosshairVtkMapper2D.cpp
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
-  #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfigMITKBase.xml
 Interactions/DisplayConfigPACSBase.xml
 Interactions/DisplayConfigCrosshair.xml
 Interactions/DisplayConfigRotation.xml
 Interactions/DisplayConfigActivateCoupling.xml
 Interactions/DisplayConfigSwivel.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigBlockLMB.xml
 Interactions/PointSet.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkCrosshairData.h b/Modules/Core/include/mitkCrosshairData.h
new file mode 100644
index 0000000000..c346164791
--- /dev/null
+++ b/Modules/Core/include/mitkCrosshairData.h
@@ -0,0 +1,46 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef mitkCrosshairData_h
+#define mitkCrosshairData_h
+
+#include <mitkBaseData.h>
+#include <mitkPoint.h>
+
+namespace mitk
+{
+  class MITKCORE_EXPORT CrosshairData : public BaseData
+  {
+  public:
+
+    mitkClassMacro(CrosshairData, BaseData);
+    itkFactorylessNewMacro(Self);
+
+    itkGetConstMacro(Position, Point3D);
+    itkSetMacro(Position, Point3D);
+
+    void SetRequestedRegionToLargestPossibleRegion() override;
+    bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
+    bool VerifyRequestedRegion() override;
+    void SetRequestedRegion(const itk::DataObject* data) override;
+
+  protected:
+
+    CrosshairData();
+    ~CrosshairData() override;
+
+    Point3D m_Position;
+
+  };
+}
+
+#endif
diff --git a/Modules/Core/include/mitkCrosshairVtkMapper2D.h b/Modules/Core/include/mitkCrosshairVtkMapper2D.h
new file mode 100644
index 0000000000..301c4114f9
--- /dev/null
+++ b/Modules/Core/include/mitkCrosshairVtkMapper2D.h
@@ -0,0 +1,93 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#ifndef mitkCrosshairVtkMapper2D_h
+#define mitkCrosshairVtkMapper2D_h
+
+#include <MitkCoreExports.h>
+
+#include <mitkBaseRenderer.h>
+#include <mitkCrosshairData.h>
+#include <mitkVtkMapper.h>
+
+#include <vtkSmartPointer.h>
+
+class vtkActor2D;
+class vtkCellArray;
+class vtkPropAssembly;
+class vtkPolyDataMapper2D;
+
+namespace mitk
+{
+  /**
+    * @brief Vtk-based 2D mapper for rendering a crosshair using vtk mapper.
+    *
+    *        CrosshairData is used to retrieve the selected position, which is stored
+    *        in the processed data node.
+    *        The crosshair is created by drawing lines through the selected position,
+    *        adding an additional gap in the center of the crosshair and creating vtk poly
+    *        data from the created points and lines.
+    */
+  class MITKCORE_EXPORT CrosshairVtkMapper2D : public VtkMapper
+  {
+  public:
+
+    mitkClassMacro(CrosshairVtkMapper2D, VtkMapper);
+    itkFactorylessNewMacro(Self);
+
+    const CrosshairData* GetInput() const;
+
+    /** \brief Checks whether this mapper needs to update itself and generate data. */
+    void Update(mitk::BaseRenderer* renderer) override;
+
+    vtkProp* GetVtkProp(BaseRenderer* renderer) override;
+
+    static void SetDefaultProperties(DataNode* node, BaseRenderer* renderer = nullptr, bool overwrite = false);
+
+  protected:
+
+    CrosshairVtkMapper2D();
+    ~CrosshairVtkMapper2D() override;
+
+    /** \brief Internal class holding the mapper, actor, etc. for each of the 2D render windows */
+    class LocalStorage : public Mapper::BaseLocalStorage
+    {
+    public:
+
+      LocalStorage();
+      ~LocalStorage() override;
+
+      // actor
+      vtkSmartPointer<vtkActor2D> m_CrosshairActor;
+      vtkSmartPointer<vtkPolyDataMapper2D> m_Mapper;
+      vtkSmartPointer<vtkPropAssembly> m_CrosshairAssembly;
+    };
+
+    /** \brief The LocalStorageHandler holds all LocalStorages for the 2D render windows. */
+    LocalStorageHandler<LocalStorage> m_LSH;
+
+    /* \brief Applies the color and opacity properties and calls CreateVTKRenderObjects */
+    void GenerateDataForRenderer(BaseRenderer *renderer) override;
+
+    void CreateVtkCrosshair(BaseRenderer *renderer);
+
+    void DrawLine(Point3D p0, Point3D p1, vtkCellArray* lines, vtkPoints* points);
+
+    void ApplyAllProperties(BaseRenderer* renderer);
+    void ApplyColorAndOpacityProperties2D(BaseRenderer* renderer, vtkActor2D* actor);
+
+    const int defaultGapSize;
+  };
+
+}
+
+#endif
diff --git a/Modules/Core/src/DataManagement/mitkCrosshairData.cpp b/Modules/Core/src/DataManagement/mitkCrosshairData.cpp
new file mode 100644
index 0000000000..59bee7d17f
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkCrosshairData.cpp
@@ -0,0 +1,39 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include <mitkCrosshairData.h>
+
+mitk::CrosshairData::CrosshairData()
+{
+}
+
+mitk::CrosshairData::~CrosshairData()
+{
+}
+
+void mitk::CrosshairData::SetRequestedRegionToLargestPossibleRegion()
+{
+}
+
+bool mitk::CrosshairData::RequestedRegionIsOutsideOfTheBufferedRegion()
+{
+  return false;
+}
+
+bool mitk::CrosshairData::VerifyRequestedRegion()
+{
+  return true;
+}
+
+void mitk::CrosshairData::SetRequestedRegion(const itk::DataObject*)
+{
+}
diff --git a/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp b/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp
new file mode 100644
index 0000000000..313dcc34ce
--- /dev/null
+++ b/Modules/Core/src/Rendering/mitkCrosshairVtkMapper2D.cpp
@@ -0,0 +1,244 @@
+/*============================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center (DKFZ)
+All rights reserved.
+
+Use of this source code is governed by a 3-clause BSD license that can be
+found in the LICENSE file.
+
+============================================================================*/
+
+#include "mitkCrosshairVtkMapper2D.h"
+
+// mitk includes
+#include <mitkAbstractTransformGeometry.h>
+#include <mitkDataNode.h>
+#include <mitkProperties.h>
+
+// vtk includes
+#include <mitkIPropertyAliases.h>
+#include <vtkActor2D.h>
+#include <vtkCellArray.h>
+#include <vtkCellData.h>
+#include <vtkLine.h>
+#include <vtkPoints.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper2D.h>
+#include <vtkProperty2D.h>
+
+const mitk::CrosshairData* mitk::CrosshairVtkMapper2D::GetInput() const
+{
+  return static_cast<CrosshairData*>(this->GetDataNode()->GetData());
+}
+
+mitk::CrosshairVtkMapper2D::CrosshairVtkMapper2D()
+  : defaultGapSize(32)
+{
+}
+
+mitk::CrosshairVtkMapper2D::~CrosshairVtkMapper2D()
+{
+}
+
+void mitk::CrosshairVtkMapper2D::Update(mitk::BaseRenderer* renderer)
+{
+  const auto* node = this->GetDataNode();
+  if (nullptr == node)
+  {
+    return;
+  }
+
+  bool visible = true;
+  node->GetVisibility(visible, renderer, "visible");
+  if (!visible)
+  {
+    // Do not render crosshair for base renderer, if the
+    // crosshair data node is not visible in that base renderer.
+    return;
+  }
+
+  const auto* data = static_cast<mitk::CrosshairData*>(node->GetData());
+  if (nullptr == data)
+  {
+    // Do not render crosshair for base renderer, if the
+    // base data node is no crosshair data.
+    return;
+  }
+
+  this->GenerateDataForRenderer(renderer);
+}
+
+vtkProp* mitk::CrosshairVtkMapper2D::GetVtkProp(BaseRenderer* renderer)
+{
+  LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
+  return ls->m_CrosshairAssembly;
+}
+
+void mitk::CrosshairVtkMapper2D::SetDefaultProperties(DataNode* node,
+                                                      BaseRenderer* renderer,
+                                                      bool overwrite)
+{
+  CoreServicePointer<IPropertyAliases> aliases(CoreServices::GetPropertyAliases());
+  node->AddProperty("Line width", FloatProperty::New(1), renderer, overwrite);
+  aliases->AddAlias("line width", "Crosshair.Line Width", "");
+  node->AddProperty("Crosshair.Gap Size", IntProperty::New(32), renderer, overwrite);
+
+  Superclass::SetDefaultProperties(node, renderer, overwrite);
+}
+
+void mitk::CrosshairVtkMapper2D::GenerateDataForRenderer(BaseRenderer* renderer)
+{
+  LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
+  ls->UpdateGenerateDataTime();
+
+  this->CreateVtkCrosshair(renderer);
+
+  this->ApplyAllProperties(renderer);
+}
+
+void mitk::CrosshairVtkMapper2D::CreateVtkCrosshair(BaseRenderer* renderer)
+{
+  LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
+  ls->m_CrosshairActor->SetVisibility(0);
+
+  CrosshairData::ConstPointer input = this->GetInput();
+  Point3D crosshairPosition = input->GetPosition();
+
+  // check if node is inside the renderer geometry
+  bool isInside = renderer->GetWorldTimeGeometry()->IsWorldPointInside(crosshairPosition);
+  if (!isInside)
+  {
+    // no need to draw crosshair lines
+    return;
+  }
+
+  int gapSize = defaultGapSize;
+  this->GetDataNode()->GetPropertyValue("Crosshair.Gap Size", gapSize, nullptr);
+
+  vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
+  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+  vtkSmartPointer<vtkPolyData> linesPolyData = vtkSmartPointer<vtkPolyData>::New();
+
+  // convert 3D crosshair crosshairPosition to 2D point
+  Point2D displayPoint;
+  renderer->WorldToDisplay(crosshairPosition, displayPoint);
+  Point2D displayPointOne = displayPoint;
+  Point2D displayPointTwo = displayPoint;
+  Point3D worldPointOne;
+  Point3D worldPointTwo;
+
+  // convert geometry bounds from 3D to 2D
+  const auto worldBounds = renderer->GetWorldTimeGeometry()->GetBoundsInWorld();
+  Point3D worldBoundsMinimum;
+  worldBoundsMinimum[0] = worldBounds[0];
+  worldBoundsMinimum[1] = worldBounds[2];
+  worldBoundsMinimum[2] = worldBounds[4];
+
+  Point3D worldBoundsMaximum;
+  worldBoundsMaximum[0] = worldBounds[1];
+  worldBoundsMaximum[1] = worldBounds[3];
+  worldBoundsMaximum[2] = worldBounds[5];
+
+  Point2D displayBoundsMinimum;
+  Point2D displayBoundsMaximum;
+  renderer->WorldToDisplay(worldBoundsMinimum, displayBoundsMinimum);
+  renderer->WorldToDisplay(worldBoundsMaximum, displayBoundsMaximum);
+
+  // define points for the first / left half of the crosshair x-line
+  displayPointOne[0] = displayBoundsMinimum[0];
+  displayPointTwo[0] = displayPoint[0] - gapSize;
+  renderer->DisplayToWorld(displayPointOne, worldPointOne);
+  renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
+  this->DrawLine(worldPointOne, worldPointTwo, lines, points);
+
+  // define points for the second / right half of the crosshair x-line
+  displayPointOne[0] = displayPoint[0] + gapSize;
+  displayPointTwo[0] = displayBoundsMaximum[0];
+  renderer->DisplayToWorld(displayPointOne, worldPointOne);
+  renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
+  this->DrawLine(worldPointOne, worldPointTwo, lines, points);
+
+  // reset 2D points
+  displayPointOne = displayPoint;
+  displayPointTwo = displayPoint;
+
+  // define points for the first / bottom half of the crosshair y-line
+  displayPointOne[1] = displayBoundsMinimum[1];
+  displayPointTwo[1] = displayPoint[1] - gapSize;
+  renderer->DisplayToWorld(displayPointOne, worldPointOne);
+  renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
+  this->DrawLine(worldPointOne, worldPointTwo, lines, points);
+
+  // define points for the second / top half of the crosshair y-line
+  displayPointOne[1] = displayPoint[1] + gapSize;
+  displayPointTwo[1] = displayBoundsMaximum[1];
+  renderer->DisplayToWorld(displayPointOne, worldPointOne);
+  renderer->DisplayToWorld(displayPointTwo, worldPointTwo);
+  this->DrawLine(worldPointOne, worldPointTwo, lines, points);
+
+  // set vtk data with the created points and lines
+  linesPolyData->SetPoints(points);
+  linesPolyData->SetLines(lines);
+  ls->m_Mapper->SetInputData(linesPolyData);
+  ls->m_CrosshairActor->SetMapper(ls->m_Mapper);
+  ls->m_CrosshairActor->SetVisibility(1);
+}
+
+void mitk::CrosshairVtkMapper2D::DrawLine(Point3D p0, Point3D p1, vtkCellArray* lines, vtkPoints* points)
+{
+  vtkIdType pidStart = points->InsertNextPoint(p0[0], p0[1], p0[2]);
+  vtkIdType pidEnd = points->InsertNextPoint(p1[0], p1[1], p1[2]);
+
+  vtkSmartPointer<vtkLine> lineVtk = vtkSmartPointer<vtkLine>::New();
+  lineVtk->GetPointIds()->SetId(0, pidStart);
+  lineVtk->GetPointIds()->SetId(1, pidEnd);
+
+  lines->InsertNextCell(lineVtk);
+}
+
+void mitk::CrosshairVtkMapper2D::ApplyAllProperties(BaseRenderer* renderer)
+{
+  LocalStorage* ls = m_LSH.GetLocalStorage(renderer);
+  ApplyColorAndOpacityProperties2D(renderer, ls->m_CrosshairActor);
+
+  float thickness;
+  this->GetDataNode()->GetFloatProperty("Line width", thickness, renderer);
+  ls->m_CrosshairActor->GetProperty()->SetLineWidth(thickness);
+}
+
+void mitk::CrosshairVtkMapper2D::ApplyColorAndOpacityProperties2D(BaseRenderer* renderer, vtkActor2D* actor)
+{
+  float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+  DataNode* node = GetDataNode();
+
+  // check for color prop and use it for rendering if it exists
+  node->GetColor(rgba, renderer, "color");
+  // check for opacity prop and use it for rendering if it exists
+  node->GetOpacity(rgba[3], renderer, "opacity");
+
+  double drgba[4] = { rgba[0], rgba[1], rgba[2], rgba[3] };
+  actor->GetProperty()->SetColor(drgba);
+  actor->GetProperty()->SetOpacity(drgba[3]);
+}
+
+mitk::CrosshairVtkMapper2D::LocalStorage::LocalStorage()
+{
+  m_CrosshairAssembly = vtkSmartPointer<vtkPropAssembly>::New();
+  m_CrosshairActor = vtkSmartPointer<vtkActor2D>::New();
+  m_Mapper = vtkSmartPointer<vtkPolyDataMapper2D>::New();
+
+  m_CrosshairActor->SetMapper(m_Mapper);
+  m_CrosshairActor->SetVisibility(0);
+  m_CrosshairAssembly->AddPart(m_CrosshairActor);
+
+  vtkCoordinate *tcoord = vtkCoordinate::New();
+  tcoord->SetCoordinateSystemToWorld();
+  m_Mapper->SetTransformCoordinate(tcoord);
+  tcoord->Delete();
+}
+
+mitk::CrosshairVtkMapper2D::LocalStorage::~LocalStorage()
+{
+}
diff --git a/Modules/Core/src/mitkCoreObjectFactory.cpp b/Modules/Core/src/mitkCoreObjectFactory.cpp
index 084c19c0b3..c3d4c5d7dd 100644
--- a/Modules/Core/src/mitkCoreObjectFactory.cpp
+++ b/Modules/Core/src/mitkCoreObjectFactory.cpp
@@ -1,454 +1,464 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCoreObjectFactory.h"
 #include "mitkConfig.h"
 
 #include "mitkColorProperty.h"
 #include "mitkDataNode.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometryData.h"
 #include "mitkImage.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPlaneGeometryData.h"
 #include "mitkPlaneGeometryDataMapper2D.h"
 #include "mitkPlaneGeometryDataVtkMapper3D.h"
 #include "mitkPointSet.h"
 #include "mitkPointSetVtkMapper2D.h"
 #include "mitkPointSetVtkMapper3D.h"
 #include "mitkProperties.h"
 #include "mitkPropertyList.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 #include "mitkSurface.h"
 #include "mitkSurfaceVtkMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 #include "mitkTimeGeometry.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include <mitkImageVtkMapper2D.h>
 
 // Legacy Support:
 #include <mitkCoreServices.h>
 #include <mitkLegacyFileReaderService.h>
 #include <mitkLegacyFileWriterService.h>
 
+#include <mitkCrosshairData.h>
+#include <mitkCrosshairVtkMapper2D.h>
+
 void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
   m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
   // Register Legacy Reader and Writer
   this->RegisterLegacyReaders(factory);
   this->RegisterLegacyWriters(factory);
 }
 
 void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
   this->UnRegisterLegacyWriters(factory);
   this->UnRegisterLegacyReaders(factory);
   try
   {
     m_ExtraFactories.erase(factory);
   }
   catch ( const std::exception &e )
   {
     MITK_ERROR << "Caught exception while unregistering: " << e.what();
   }
 }
 
 mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance()
 {
   static mitk::CoreObjectFactory::Pointer instance;
   if (instance.IsNull())
   {
     instance = mitk::CoreObjectFactory::New();
   }
   return instance;
 }
 
 mitk::CoreObjectFactory::~CoreObjectFactory()
 {
   for (auto iter =
          m_LegacyReaders.begin();
        iter != m_LegacyReaders.end();
        ++iter)
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
   }
 
   for (auto iter =
          m_LegacyWriters.begin();
        iter != m_LegacyWriters.end();
        ++iter)
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
   }
 }
 
 void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
   if (image.IsNotNull() && image->IsInitialized())
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
   }
 
   mitk::PlaneGeometryData::Pointer planeGeometry = dynamic_cast<mitk::PlaneGeometryData *>(node->GetData());
   if (planeGeometry.IsNotNull())
   {
     mitk::PlaneGeometryDataMapper2D::SetDefaultProperties(node);
   }
 
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface *>(node->GetData());
   if (surface.IsNotNull())
   {
     mitk::SurfaceVtkMapper2D::SetDefaultProperties(node);
     mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet *>(node->GetData());
   if (pointSet.IsNotNull())
   {
     mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
     mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
   }
+
+  mitk::CrosshairData::Pointer crosshairData = dynamic_cast<mitk::CrosshairData*>(node->GetData());
+  if (crosshairData.IsNotNull())
+  {
+    mitk::CrosshairVtkMapper2D::SetDefaultProperties(node);
+  }
+
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     (*it)->SetDefaultProperties(node);
   }
 }
 
 mitk::CoreObjectFactory::CoreObjectFactory()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     CreateFileExtensionsMap();
 
     // RegisterLegacyReaders(this);
     // RegisterLegacyWriters(this);
 
     alreadyDone = true;
   }
 }
 
 mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::Mapper::Pointer tmpMapper = nullptr;
 
   // check whether extra factories provide mapper
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     tmpMapper = (*it)->CreateMapper(node, id);
     if (tmpMapper.IsNotNull())
       newMapper = tmpMapper;
   }
 
   if (newMapper.IsNull())
   {
     mitk::BaseData *data = node->GetData();
 
     if (id == mitk::BaseRenderer::Standard2D)
     {
       if ((dynamic_cast<Image *>(data) != nullptr))
       {
         newMapper = mitk::ImageVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PlaneGeometryData *>(data) != nullptr))
       {
         newMapper = mitk::PlaneGeometryDataMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<Surface *>(data) != nullptr))
       {
         newMapper = mitk::SurfaceVtkMapper2D::New();
         // cast because SetDataNode is not virtual
         auto *castedMapper = dynamic_cast<mitk::SurfaceVtkMapper2D *>(newMapper.GetPointer());
         castedMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PointSet *>(data) != nullptr))
       {
         newMapper = mitk::PointSetVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
     }
     else if (id == mitk::BaseRenderer::Standard3D)
     {
       if ((dynamic_cast<PlaneGeometryData *>(data) != nullptr))
       {
         newMapper = mitk::PlaneGeometryDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<Surface *>(data) != nullptr))
       {
         newMapper = mitk::SurfaceVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if ((dynamic_cast<PointSet *>(data) != nullptr))
       {
         newMapper = mitk::PointSetVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
     }
   }
 
   return newMapper;
 }
 
 std::string mitk::CoreObjectFactory::GetFileExtensions()
 {
   MultimapType aMap;
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     aMap = (*it)->GetFileExtensionsMap();
     this->MergeFileExtensions(m_FileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
   return m_FileExtensions.c_str();
 }
 
 void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType &fileExtensionsMap, MultimapType inputMap)
 {
   std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
   for (auto it = inputMap.begin(); it != inputMap.end(); ++it)
   {
     bool duplicateFound = false;
     pairOfIter = fileExtensionsMap.equal_range((*it).first);
     for (auto it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
     {
       // cout << "  [" << (*it).first << ", " << (*it).second << "]" << endl;
       std::string aString = (*it2).second;
       if (aString.compare((*it).second) == 0)
       {
         // cout << "  DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
         duplicateFound = true;
         break;
       }
     }
     if (!duplicateFound)
     {
       fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
     }
   }
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 void mitk::CoreObjectFactory::CreateFileExtensionsMap()
 {
   /*
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
   */
 }
 
 std::string mitk::CoreObjectFactory::GetSaveFileExtensions()
 {
   MultimapType aMap;
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     aMap = (*it)->GetSaveFileExtensionsMap();
     this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
   return m_SaveFileExtensions.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters()
 {
   FileWriterList allWriters = m_FileWriters;
   // sort to merge lists later on
   typedef std::set<mitk::FileWriterWithInformation::Pointer> FileWriterSet;
   FileWriterSet fileWritersSet;
 
   fileWritersSet.insert(allWriters.begin(), allWriters.end());
 
   // collect all extra factories
   for (auto it = m_ExtraFactories.begin(); it != m_ExtraFactories.end(); ++it)
   {
     FileWriterList list2 = (*it)->GetFileWriters();
 
     // add them to the sorted set
     fileWritersSet.insert(list2.begin(), list2.end());
   }
 
   // write back to allWriters to return a list
   allWriters.clear();
   allWriters.insert(allWriters.end(), fileWritersSet.begin(), fileWritersSet.end());
 
   return allWriters;
 }
 
 void mitk::CoreObjectFactory::MapEvent(const mitk::Event *, const int)
 {
 }
 
 std::string mitk::CoreObjectFactory::GetDescriptionForExtension(const std::string &extension)
 {
   std::multimap<std::string, std::string> fileExtensionMap = GetSaveFileExtensionsMap();
   for (auto it = fileExtensionMap.begin(); it != fileExtensionMap.end();
        ++it)
     if (it->first == extension)
       return it->second;
   return ""; // If no matching extension was found, return empty string
 }
 
 void mitk::CoreObjectFactory::RegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory)
 {
   // We are not really interested in the string, just call the method since
   // many readers initialize the map the first time when this method is called
   factory->GetFileExtensions();
 
   std::map<std::string, std::vector<std::string>> extensionsByCategories;
   std::multimap<std::string, std::string> fileExtensionMap = factory->GetFileExtensionsMap();
   for (auto it = fileExtensionMap.begin(); it != fileExtensionMap.end();
        ++it)
   {
     std::string extension = it->first;
     // remove "*."
     extension = extension.erase(0, 2);
 
     extensionsByCategories[it->second].push_back(extension);
   }
 
   for (auto &extensionsByCategorie : extensionsByCategories)
   {
     m_LegacyReaders[factory].push_back(
       new mitk::LegacyFileReaderService(extensionsByCategorie.second, extensionsByCategorie.first));
   }
 }
 
 void mitk::CoreObjectFactory::UnRegisterLegacyReaders(mitk::CoreObjectFactoryBase *factory)
 {
   auto iter =
     m_LegacyReaders.find(factory);
   if (iter != m_LegacyReaders.end())
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
 
     m_LegacyReaders.erase(iter);
   }
 }
 
 void mitk::CoreObjectFactory::RegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory)
 {
   // Get all external Writers
   mitk::CoreObjectFactory::FileWriterList writers = factory->GetFileWriters();
 
   // We are not really interested in the string, just call the method since
   // many writers initialize the map the first time when this method is called
   factory->GetSaveFileExtensions();
 
   MultimapType fileExtensionMap = factory->GetSaveFileExtensionsMap();
 
   for (auto it = writers.begin(); it != writers.end(); ++it)
   {
     std::vector<std::string> extensions = (*it)->GetPossibleFileExtensions();
     if (extensions.empty())
       continue;
 
     std::string description;
     for (auto ext = extensions.begin(); ext != extensions.end(); ++ext)
     {
       if (ext->empty())
         continue;
 
       std::string extension = *ext;
       std::string extensionWithStar = extension;
       if (extension.find_first_of('*') == 0)
       {
         // remove "*."
         extension = extension.substr(0, extension.size() - 2);
       }
       else
       {
         extensionWithStar.insert(extensionWithStar.begin(), '*');
       }
 
       for (auto fileExtensionIter = fileExtensionMap.begin();
            fileExtensionIter != fileExtensionMap.end();
            ++fileExtensionIter)
       {
         if (fileExtensionIter->first == extensionWithStar)
         {
           description = fileExtensionIter->second;
           break;
         }
       }
       if (!description.empty())
         break;
     }
     if (description.empty())
     {
       description = std::string("Legacy ") + (*it)->GetNameOfClass() + " Reader";
     }
 
     mitk::FileWriter::Pointer fileWriter(it->GetPointer());
     mitk::LegacyFileWriterService *lfws = new mitk::LegacyFileWriterService(fileWriter, description);
     m_LegacyWriters[factory].push_back(lfws);
   }
 }
 
 void mitk::CoreObjectFactory::UnRegisterLegacyWriters(mitk::CoreObjectFactoryBase *factory)
 {
   auto iter =
     m_LegacyWriters.find(factory);
   if (iter != m_LegacyWriters.end())
   {
     for (auto &elem : iter->second)
     {
       delete elem;
     }
 
     m_LegacyWriters.erase(iter);
   }
 }