diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 1a3e5ca9d2..c0a3302f8a 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,314 +1,315 @@
 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/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
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.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/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.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/mitkIPropertyPersistence.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/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.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/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.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/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.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/mitkDicomSeriesReader.cpp
   IO/mitkDicomSeriesReaderService.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_SliceGroupingResult.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/mitkVtkLoggingAdapter.cpp
 
   Rendering/mitkAbstractOverlayLayouter.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkIShaderRepository.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkOverlay.cpp
   Rendering/mitkOverlayManager.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/mitkVtkOverlay2D.cpp
   Rendering/mitkVtkOverlay3D.cpp
   Rendering/mitkVtkOverlay.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/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/DisplayConfigMITKNoCrosshair.xml
 Interactions/DisplayConfigMITKRotation.xml
 Interactions/DisplayConfigMITKRotationUnCoupled.xml
 Interactions/DisplayConfigMITKSwivel.xml
 Interactions/DisplayConfigMITKLimited.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkCompositePixelValueToString.h b/Modules/Core/include/mitkCompositePixelValueToString.h
new file mode 100644
index 0000000000..6bcb0f3aab
--- /dev/null
+++ b/Modules/Core/include/mitkCompositePixelValueToString.h
@@ -0,0 +1,33 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkCompositePixelValueToString_h
+#define mitkCompositePixelValueToString_h
+
+#include <mitkImage.h>
+#include <string>
+
+namespace mitk
+{
+  /** \brief Converts composite pixel values to a displayable string
+  *
+  * \throws mitk::Exception If the image is NULL.
+  * \throws mitk::AccessByItkException for pixel types which are not part of MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ
+  */
+  std::string MITKCORE_EXPORT ConvertCompositePixelValueToString(Image::Pointer image, itk::Index<3> index);
+}
+
+#endif
diff --git a/Modules/Core/include/mitkStatusBar.h b/Modules/Core/include/mitkStatusBar.h
index 853de45e69..b9dc3935b0 100755
--- a/Modules/Core/include/mitkStatusBar.h
+++ b/Modules/Core/include/mitkStatusBar.h
@@ -1,92 +1,95 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKSTATUSBAR_H
 #define MITKSTATUSBAR_H
 #include "mitkStatusBarImplementation.h"
 #include <MitkCoreExports.h>
 #include <itkObject.h>
 #include <mitkPoint.h>
 #include <itkIndex.h>
 
 namespace mitk
 {
   //##Documentation
   //## @brief Sending a message to the applications StatusBar
   //##
   //## Holds a GUI dependent StatusBarImplementation and sends the text further.
   //## nearly equal to itk::OutputWindow,
   //## no Window, but one line of text and a delay for clear.
   //## all mitk-classes use this class to display text on GUI-StatusBar.
   //## The mainapplication has to set the internal held StatusBarImplementation with SetInstance(..).
   //## @ingroup Interaction
   class MITKCORE_EXPORT StatusBar : public itk::Object
   {
   public:
     itkTypeMacro(StatusBar, itk::Object);
 
     //##Documentation
     //## @brief static method to get the GUI dependent StatusBar-instance
     //## so the methods DisplayText, etc. can be called
     //## No reference counting, cause of decentral static use!
     static StatusBar *GetInstance();
 
     //##Documentation
     //## @brief Supply a GUI- dependent StatusBar. Has to be set by the application
     //## to connect the application dependent subclass of mitkStatusBar
     //## if you create an instance, then call ->Delete() on the supplied
     //## instance after setting it.
     static void SetImplementation(StatusBarImplementation *instance);
 
     //##Documentation
     //## @brief Send a string to the applications StatusBar
     void DisplayText(const char *t);
     //##Documentation
     //## @brief Send a string with a time delay to the applications StatusBar
     void DisplayText(const char *t, int ms);
     void DisplayErrorText(const char *t);
     void DisplayWarningText(const char *t);
     void DisplayWarningText(const char *t, int ms);
     void DisplayGenericOutputText(const char *t);
     void DisplayDebugText(const char *t);
     void DisplayGreyValueText(const char *t);
 
     //##Documentation
     //## @brief Display position, index, time and pixel value
-    void DisplayImageInfo(const mitk::Point3D point, const itk::Index<3> index, const mitk::ScalarType time, const mitk::ScalarType pixelValue);
+    void DisplayImageInfo(mitk::Point3D point, itk::Index<3> index, mitk::ScalarType time, mitk::ScalarType pixelValue);
+    //## @brief Display rotation, index, time and custom pixel value
+    void DisplayImageInfo(mitk::Point3D point, itk::Index<3> index, mitk::ScalarType time, const char *pixelValue);
     //##Documentation
     //## @brief Display placeholder text for invalid information
     void DisplayImageInfoInvalid();
 
     //##Documentation
     //## @brief removes any temporary message being shown.
     void Clear();
 
     //##Documentation
     //## @brief Set the SizeGrip of the window
     //## (the triangle in the lower right Windowcorner for changing the size)
     //## to enabled or disabled
     void SetSizeGripEnabled(bool enable);
 
   protected:
     StatusBar();
     virtual ~StatusBar();
+
     static StatusBarImplementation *m_Implementation;
     static StatusBar *m_Instance;
   };
 
 } // end namespace mitk
 #endif /* define MITKSTATUSBAR_H */
diff --git a/Modules/Core/src/Algorithms/mitkCompositePixelValueToString.cpp b/Modules/Core/src/Algorithms/mitkCompositePixelValueToString.cpp
new file mode 100644
index 0000000000..c60f1744bb
--- /dev/null
+++ b/Modules/Core/src/Algorithms/mitkCompositePixelValueToString.cpp
@@ -0,0 +1,78 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkCompositePixelValueToString.h>
+#include <mitkImageAccessByItk.h>
+#include <sstream>
+
+namespace mitk
+{
+  // The output operator for RGBA in ITK does not properly cast to printable type,
+  // like the RGB pixel output operator. This here is an indirection to fix this until
+  // ITK-3501 is fixed.
+  template <typename TComponent>
+  std::ostream &operator<<(std::ostream &os, const itk::RGBPixel<TComponent> &c)
+  {
+    return itk::operator<<(os, c);
+  }
+
+  template <typename TComponent>
+  std::ostream &operator<<(std::ostream &os, const itk::RGBAPixel<TComponent> &c)
+  {
+    os << static_cast<typename itk::NumericTraits<TComponent>::PrintType>(c[0]) << "  ";
+    os << static_cast<typename itk::NumericTraits<TComponent>::PrintType>(c[1]) << "  ";
+    os << static_cast<typename itk::NumericTraits<TComponent>::PrintType>(c[2]) << "  ";
+    os << static_cast<typename itk::NumericTraits<TComponent>::PrintType>(c[3]);
+    return os;
+  }
+
+  template <typename TPixel, unsigned int VImageDimension>
+  static void ConvertCompositePixelValueToString(itk::Image<TPixel, VImageDimension> *image,
+                                                 itk::Index<3> index3,
+                                                 std::string &string)
+  {
+    itk::Index<VImageDimension> index;
+    for (unsigned int i = 0; i < VImageDimension; ++i)
+      index[i] = index3[i];
+
+    if (image->GetLargestPossibleRegion().IsInside(index))
+    {
+      std::ostringstream stream;
+      mitk::operator<<(stream, image->GetPixel(index));
+
+      string = stream.str();
+    }
+    else
+    {
+      string = "Out of bounds";
+    }
+  }
+}
+
+std::string mitk::ConvertCompositePixelValueToString(Image::Pointer image, itk::Index<3> index)
+{
+  std::string string;
+
+  if (image.IsNull())
+  {
+    mitkThrow() << "Image is null.";
+  }
+
+  AccessFixedPixelTypeByItk_n(
+    image, ConvertCompositePixelValueToString, MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ, (index, string));
+
+  return string;
+}
diff --git a/Modules/Core/src/Controllers/mitkStatusBar.cpp b/Modules/Core/src/Controllers/mitkStatusBar.cpp
index daae008c04..ff6124b94e 100755
--- a/Modules/Core/src/Controllers/mitkStatusBar.cpp
+++ b/Modules/Core/src/Controllers/mitkStatusBar.cpp
@@ -1,134 +1,165 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkStatusBar.h"
 #include <itkObjectFactory.h>
 #include <itkOutputWindow.h>
 
 namespace mitk
 {
   StatusBarImplementation *StatusBar::m_Implementation = nullptr;
   StatusBar *StatusBar::m_Instance = nullptr;
 
   /**
    * Display the text in the statusbar of the applikation
    */
   void StatusBar::DisplayText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayText(t);
   }
 
   /**
    * Display the text in the statusbar of the applikation for ms seconds
    */
   void StatusBar::DisplayText(const char *t, int ms)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayText(t, ms);
   }
 
   void StatusBar::DisplayErrorText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayErrorText(t);
   }
   void StatusBar::DisplayWarningText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayWarningText(t);
   }
   void StatusBar::DisplayWarningText(const char *t, int ms)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayWarningText(t, ms);
   }
   void StatusBar::DisplayGenericOutputText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGenericOutputText(t);
   }
   void StatusBar::DisplayDebugText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayDebugText(t);
   }
   void StatusBar::DisplayGreyValueText(const char *t)
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGreyValueText(t);
   }
-  void StatusBar::DisplayImageInfo(const mitk::Point3D point, const itk::Index<3> index, const mitk::ScalarType time, const mitk::ScalarType pixelValue)
+
+  static std::ostringstream WriteCommonImageInfo(Point3D point, itk::Index<3> index, ScalarType time)
   {
-    if (m_Implementation != nullptr)
-    {
-      std::stringstream stream;
-      stream.imbue(std::locale::classic());
-      stream.precision(2);
-      stream << "Position: <" << std::fixed << point[0] << ", " << std::fixed << point[1] << ", " << std::fixed << point[2] << "> mm";
-      stream << "; Index: <" << index[0] << ", " << index[1] << ", " << index[2] << "> ";
-      stream << "; Time: " << time << " ms; Pixelvalue ";
-      if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
-        stream << std::scientific;
-      stream << pixelValue;
-      m_Implementation->DisplayGreyValueText(stream.str().c_str());
-    }
+    std::ostringstream stream;
+    stream.imbue(std::locale::classic());
+    stream.precision(2);
+
+    stream << "Position: <" << std::fixed << point[0] << ", "
+                            << std::fixed << point[1] << ", "
+                            << std::fixed << point[2] << "> mm; ";
+
+    stream << "Index: <" << index[0] << ", "
+                         << index[1] << ", "
+                         << index[2] << "> ; ";
+
+    stream << "Time: " << time << " ms";
+
+    return stream;
   }
+
+  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, ScalarType time, ScalarType pixelValue)
+  {
+    if (m_Implementation == nullptr)
+      return;
+
+    std::ostringstream stream = WriteCommonImageInfo(point, index, time);
+    stream << "; Pixel value: ";
+
+    if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
+      stream << std::scientific;
+
+    stream << pixelValue;
+
+    m_Implementation->DisplayGreyValueText(stream.str().c_str());
+  }
+
+  void StatusBar::DisplayImageInfo(Point3D point, itk::Index<3> index, ScalarType time, const char *pixelValue)
+  {
+    if (m_Implementation == nullptr)
+      return;
+
+    std::ostringstream stream = WriteCommonImageInfo(point, index, time);
+    stream << "; " << pixelValue;
+
+    m_Implementation->DisplayGreyValueText(stream.str().c_str());
+  }
+
   void StatusBar::DisplayImageInfoInvalid()
   {
     if (m_Implementation != nullptr)
       m_Implementation->DisplayGreyValueText("No image information at this position!");
   }
   void StatusBar::Clear()
   {
     if (m_Implementation != nullptr)
       m_Implementation->Clear();
   }
   void StatusBar::SetSizeGripEnabled(bool enable)
   {
     if (m_Implementation != nullptr)
     {
       m_Implementation->SetSizeGripEnabled(enable);
     }
   }
   /**
    * Get the instance of this StatusBar
    */
   StatusBar *StatusBar::GetInstance()
   {
     if (m_Instance == nullptr) // if not set, then send a errormessage on OutputWindow
     {
       m_Instance = new StatusBar();
     }
 
     return m_Instance;
   }
 
   /**
    * Set an instance of this; application must do this!See Header!
    */
   void StatusBar::SetImplementation(StatusBarImplementation *implementation)
   {
     if (m_Implementation == implementation)
     {
       return;
     }
     m_Implementation = implementation;
   }
 
   StatusBar::StatusBar() {}
   StatusBar::~StatusBar() {}
 } // end namespace mitk
diff --git a/Modules/Core/src/Interactions/mitkDisplayInteractor.cpp b/Modules/Core/src/Interactions/mitkDisplayInteractor.cpp
index 9d8b367a1b..eeb84261c4 100644
--- a/Modules/Core/src/Interactions/mitkDisplayInteractor.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayInteractor.cpp
@@ -1,935 +1,950 @@
 /*===================================================================
 
  The Medical Imaging Interaction Toolkit (MITK)
 
  Copyright (c) German Cancer Research Center,
  Division of Medical and Biological Informatics.
  All rights reserved.
 
  This software is distributed WITHOUT ANY WARRANTY; without
  even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.
 
  See LICENSE.txt or http://www.mitk.org for details.
 
  ===================================================================*/
 
 #include "mitkDisplayInteractor.h"
 #include "mitkBaseRenderer.h"
 #include "mitkCameraController.h"
 #include "mitkInteractionPositionEvent.h"
 #include "mitkPropertyList.h"
 #include <mitkAbstractTransformGeometry.h>
 #include <mitkRotationOperation.h>
 #include <string.h>
 // level window
 #include "mitkLevelWindow.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkLine.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkStandaloneDataStorage.h"
 #include "vtkRenderWindowInteractor.h"
 
 // Rotation
 #include "mitkInteractionConst.h"
 #include "rotate_cursor.xpm"
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkRotationOperation.h>
 
-//
 #include "mitkImage.h"
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkPixelTypeMultiplex.h"
 #include "mitkStatusBar.h"
 
+#include <mitkCompositePixelValueToString.h>
+
 void mitk::DisplayInteractor::Notify(InteractionEvent *interactionEvent, bool isHandled)
 {
   // to use the state machine pattern,
   // the event is passed to the state machine interface to be handled
   if (!isHandled || m_AlwaysReact)
   {
     this->HandleEvent(interactionEvent, NULL);
   }
 }
 
 void mitk::DisplayInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("check_position_event", CheckPositionEvent);
   CONNECT_CONDITION("check_can_rotate", CheckRotationPossible);
   CONNECT_CONDITION("check_can_swivel", CheckSwivelPossible);
 
   CONNECT_FUNCTION("init", Init);
   CONNECT_FUNCTION("move", Move);
   CONNECT_FUNCTION("zoom", Zoom);
   CONNECT_FUNCTION("scroll", Scroll);
   CONNECT_FUNCTION("ScrollOneDown", ScrollOneDown);
   CONNECT_FUNCTION("ScrollOneUp", ScrollOneUp);
   CONNECT_FUNCTION("levelWindow", AdjustLevelWindow);
   CONNECT_FUNCTION("setCrosshair", SetCrosshair);
 
   CONNECT_FUNCTION("updateStatusbar", UpdateStatusbar)
   CONNECT_FUNCTION("startRotation", StartRotation);
   CONNECT_FUNCTION("endRotation", EndRotation);
   CONNECT_FUNCTION("rotate", Rotate);
 
   CONNECT_FUNCTION("swivel", Swivel);
 }
 
 mitk::DisplayInteractor::DisplayInteractor()
   : m_IndexToSliceModifier(4),
     m_AutoRepeat(false),
     m_InvertScrollDirection(false),
     m_InvertZoomDirection(false),
     m_InvertMoveDirection(false),
     m_InvertLevelWindowDirection(false),
     m_AlwaysReact(false),
     m_ZoomFactor(2),
     m_LinkPlanes(true)
 {
   m_StartCoordinateInMM.Fill(0);
   m_LastDisplayCoordinate.Fill(0);
   m_LastCoordinateInMM.Fill(0);
   m_CurrentDisplayCoordinate.Fill(0);
 }
 
 mitk::DisplayInteractor::~DisplayInteractor()
 {
 }
 
 bool mitk::DisplayInteractor::CheckPositionEvent(const InteractionEvent *interactionEvent)
 {
   const InteractionPositionEvent *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
   if (positionEvent == NULL)
   {
     return false;
   }
 
   return true;
 }
 
 bool mitk::DisplayInteractor::CheckRotationPossible(const mitk::InteractionEvent *interactionEvent)
 {
   // Decide between moving and rotation slices.
   /*
   Detailed logic:
 
   1. Find the SliceNavigationController that has sent the event: this one defines our rendering plane and will NOT be
   rotated. Needs not even be counted or checked.
   2. Inspect every other SliceNavigationController
   - calculate the line intersection of this SliceNavigationController's plane with our rendering plane
   - if there is NO interesection, ignore and continue
   - IF there is an intersection
   - check the mouse cursor's distance from that line.
   0. if the line is NOT near the cursor, remember the plane as "one of the other planes" (which can be rotated in
   "locked" mode)
   1. on first line near the cursor,  just remember this intersection line as THE other plane that we want to rotate
   2. on every consecutive line near the cursor, check if the line is geometrically identical to the line that we want to
   rotate
   - if yes, we just push this line to the "other" lines and rotate it along
   - if no, then we have a situation where the mouse is near two other lines (e.g. crossing point) and don't want to
   rotate
   */
   const InteractionPositionEvent *posEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
   if (posEvent == nullptr)
     return false;
 
   BaseRenderer *clickedRenderer = posEvent->GetSender();
   const PlaneGeometry *ourViewportGeometry = (clickedRenderer->GetCurrentWorldPlaneGeometry());
 
   if (!ourViewportGeometry)
     return false;
 
   Point3D cursorPosition = posEvent->GetPositionInWorld();
   const PlaneGeometry *geometryToBeRotated = NULL; // this one is under the mouse cursor
   const PlaneGeometry *anyOtherGeometry = NULL;    // this is also visible (for calculation of intersection ONLY)
   Line3D intersectionLineWithGeometryToBeRotated;
 
   bool hitMultipleLines(false);
   m_SNCsToBeRotated.clear();
 
   const double threshholdDistancePixels = 12.0;
 
   auto renWindows = interactionEvent->GetSender()->GetRenderingManager()->GetAllRegisteredRenderWindows();
 
   for (auto renWin : renWindows)
   {
     SliceNavigationController *snc = BaseRenderer::GetInstance(renWin)->GetSliceNavigationController();
 
     // If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
     if (BaseRenderer::GetInstance(renWin)->GetMapperID() == BaseRenderer::Standard3D)
       continue;
 
     const PlaneGeometry *otherRenderersRenderPlane = snc->GetCurrentPlaneGeometry();
     if (otherRenderersRenderPlane == NULL)
       continue; // ignore, we don't see a plane
 
     // check if there is an intersection
     Line3D intersectionLine; // between rendered/clicked geometry and the one being analyzed
     if (!ourViewportGeometry->IntersectionLine(otherRenderersRenderPlane, intersectionLine))
     {
       continue; // we ignore this plane, it's parallel to our plane
     }
 
     // check distance from intersection line
     double distanceFromIntersectionLine = intersectionLine.Distance(cursorPosition);
 
     // far away line, only remember for linked rotation if necessary
     if (distanceFromIntersectionLine > threshholdDistancePixels)
     {
       anyOtherGeometry = otherRenderersRenderPlane; // we just take the last one, so overwrite each iteration (we just
                                                     // need some crossing point)
       // TODO what about multiple crossings? NOW we have undefined behavior / random crossing point is used
       if (m_LinkPlanes)
       {
         m_SNCsToBeRotated.push_back(snc);
       }
     }
     else // close to cursor
     {
       if (geometryToBeRotated == NULL) // first one close to the cursor
       {
         geometryToBeRotated = otherRenderersRenderPlane;
         intersectionLineWithGeometryToBeRotated = intersectionLine;
         m_SNCsToBeRotated.push_back(snc);
       }
       else
       {
         // compare to the line defined by geometryToBeRotated: if identical, just rotate this otherRenderersRenderPlane
         // together with the primary one
         //                                                     if different, DON'T rotate
         if (intersectionLine.IsParallel(intersectionLineWithGeometryToBeRotated) &&
             intersectionLine.Distance(intersectionLineWithGeometryToBeRotated.GetPoint1()) < mitk::eps)
         {
           m_SNCsToBeRotated.push_back(snc);
         }
         else
         {
           hitMultipleLines = true;
         }
       }
     }
   }
 
   bool moveSlices(true);
 
   if (geometryToBeRotated && anyOtherGeometry && ourViewportGeometry && !hitMultipleLines)
   {
     // assure all three are valid, so calculation of center of rotation can be done
     moveSlices = false;
   }
   // question in state machine is: "rotate?"
   if (moveSlices) // i.e. NOT rotate
   {
     return false;
   }
   else
   { // we DO have enough information for rotation
     m_LastCursorPosition = intersectionLineWithGeometryToBeRotated.Project(
       cursorPosition); // remember where the last cursor position ON THE LINE has been observed
 
     if (anyOtherGeometry->IntersectionPoint(
           intersectionLineWithGeometryToBeRotated,
           m_CenterOfRotation)) // find center of rotation by intersection with any of the OTHER lines
     {
       return true;
     }
     else
     {
       return false;
     }
   }
   return false;
 }
 
 bool mitk::DisplayInteractor::CheckSwivelPossible(const mitk::InteractionEvent *interactionEvent)
 {
   const ScalarType ThresholdDistancePixels = 6.0;
 
   // Decide between moving and rotation: if we're close to the crossing
   // point of the planes, moving mode is entered, otherwise
   // rotation/swivel mode
   const InteractionPositionEvent *posEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 
   BaseRenderer *renderer = interactionEvent->GetSender();
 
   if (!posEvent || !renderer)
     return false;
 
   const Point3D &cursor = posEvent->GetPositionInWorld();
 
   m_SNCsToBeRotated.clear();
 
   const PlaneGeometry *clickedGeometry(NULL);
   const PlaneGeometry *otherGeometry1(NULL);
   const PlaneGeometry *otherGeometry2(NULL);
 
   auto renWindows = interactionEvent->GetSender()->GetRenderingManager()->GetAllRegisteredRenderWindows();
 
   for (auto renWin : renWindows)
   {
     SliceNavigationController *snc = BaseRenderer::GetInstance(renWin)->GetSliceNavigationController();
 
     // If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
     if (BaseRenderer::GetInstance(renWin)->GetMapperID() == BaseRenderer::Standard3D)
       continue;
 
     // unsigned int slice = (*iter)->GetSlice()->GetPos();
     // unsigned int time  = (*iter)->GetTime()->GetPos();
 
     const PlaneGeometry *planeGeometry = snc->GetCurrentPlaneGeometry();
     if (!planeGeometry)
       continue;
 
     if (snc == renderer->GetSliceNavigationController())
     {
       clickedGeometry = planeGeometry;
       m_SNCsToBeRotated.push_back(snc);
     }
     else
     {
       if (otherGeometry1 == NULL)
       {
         otherGeometry1 = planeGeometry;
       }
       else
       {
         otherGeometry2 = planeGeometry;
       }
       if (m_LinkPlanes)
       {
         // If planes are linked, apply rotation to all planes
         m_SNCsToBeRotated.push_back(snc);
       }
     }
   }
 
   mitk::Line3D line;
   mitk::Point3D point;
   if ((clickedGeometry != NULL) && (otherGeometry1 != NULL) && (otherGeometry2 != NULL) &&
       clickedGeometry->IntersectionLine(otherGeometry1, line) && otherGeometry2->IntersectionPoint(line, point))
   {
     m_CenterOfRotation = point;
     if (m_CenterOfRotation.EuclideanDistanceTo(cursor) < ThresholdDistancePixels)
     {
       return false;
     }
     else
     {
       m_ReferenceCursor = posEvent->GetPointerPositionOnScreen();
 
       // Get main axes of rotation plane and store it for rotation step
       m_RotationPlaneNormal = clickedGeometry->GetNormal();
 
       ScalarType xVector[] = {1.0, 0.0, 0.0};
       ScalarType yVector[] = {0.0, 1.0, 0.0};
       clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(xVector), m_RotationPlaneXVector);
       clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(yVector), m_RotationPlaneYVector);
 
       m_RotationPlaneNormal.Normalize();
       m_RotationPlaneXVector.Normalize();
       m_RotationPlaneYVector.Normalize();
 
       m_PreviousRotationAxis.Fill(0.0);
       m_PreviousRotationAxis[2] = 1.0;
       m_PreviousRotationAngle = 0.0;
 
       return true;
     }
   }
   else
   {
     return false;
   }
   return false;
 }
 
 void mitk::DisplayInteractor::Init(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
 
   m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
   m_CurrentDisplayCoordinate = m_LastDisplayCoordinate;
   positionEvent->GetSender()->DisplayToPlane(m_LastDisplayCoordinate, m_StartCoordinateInMM);
   m_LastCoordinateInMM = m_StartCoordinateInMM;
 }
 
 void mitk::DisplayInteractor::Move(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   BaseRenderer *sender = interactionEvent->GetSender();
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
 
   float invertModifier = -1.0;
   if (m_InvertMoveDirection)
   {
     invertModifier = 1.0;
   }
   // perform translation
   Vector2D moveVector = (positionEvent->GetPointerPositionOnScreen() - m_LastDisplayCoordinate) * invertModifier;
   moveVector *= sender->GetScaleFactorMMPerDisplayUnit();
   sender->GetCameraController()->MoveBy(moveVector);
   sender->GetRenderingManager()->RequestUpdate(sender->GetRenderWindow());
   m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 }
 
 void mitk::DisplayInteractor::SetCrosshair(mitk::StateMachineAction *, mitk::InteractionEvent *interactionEvent)
 {
   const BaseRenderer::Pointer sender = interactionEvent->GetSender();
   auto renWindows = sender->GetRenderingManager()->GetAllRegisteredRenderWindows();
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
   Point3D pos = positionEvent->GetPositionInWorld();
 
   for (auto renWin : renWindows)
   {
     if (BaseRenderer::GetInstance(renWin)->GetMapperID() == BaseRenderer::Standard2D &&
         renWin != sender->GetRenderWindow())
       BaseRenderer::GetInstance(renWin)->GetSliceNavigationController()->SelectSliceByPoint(pos);
   }
 }
 
 void mitk::DisplayInteractor::Zoom(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   const BaseRenderer::Pointer sender = interactionEvent->GetSender();
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
 
   float factor = 1.0;
   float distance = 0;
 
   if (m_ZoomDirection == "updown")
   {
     distance = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
   }
   else
   {
     distance = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
   }
 
   if (m_InvertZoomDirection)
   {
     distance *= -1.0;
   }
 
   // set zooming speed
   if (distance < 0.0)
   {
     factor = 1.0 / m_ZoomFactor;
   }
   else if (distance > 0.0)
   {
     factor = 1.0 * m_ZoomFactor;
   }
 
   if (factor != 1.0)
   {
     sender->GetCameraController()->Zoom(factor, m_StartCoordinateInMM);
     sender->GetRenderingManager()->RequestUpdate(sender->GetRenderWindow());
   }
 
   m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
   m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
 }
 
 void mitk::DisplayInteractor::Scroll(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
 
   mitk::SliceNavigationController::Pointer sliceNaviController =
     interactionEvent->GetSender()->GetSliceNavigationController();
   if (sliceNaviController)
   {
     int delta = 0;
     // Scrolling direction
     if (m_ScrollDirection == "updown")
     {
       delta = static_cast<int>(m_LastDisplayCoordinate[1] - positionEvent->GetPointerPositionOnScreen()[1]);
     }
     else
     {
       delta = static_cast<int>(m_LastDisplayCoordinate[0] - positionEvent->GetPointerPositionOnScreen()[0]);
     }
 
     if (m_InvertScrollDirection)
     {
       delta *= -1;
     }
 
     // Set how many pixels the mouse has to be moved to scroll one slice
     // if we moved less than 'm_IndexToSliceModifier' pixels slice ONE slice only
     if (delta > 0 && delta < m_IndexToSliceModifier)
     {
       delta = m_IndexToSliceModifier;
     }
     else if (delta < 0 && delta > -m_IndexToSliceModifier)
     {
       delta = -m_IndexToSliceModifier;
     }
     delta /= m_IndexToSliceModifier;
 
     int newPos = sliceNaviController->GetSlice()->GetPos() + delta;
 
     // if auto repeat is on, start at first slice if you reach the last slice and vice versa
     int maxSlices = sliceNaviController->GetSlice()->GetSteps();
     if (m_AutoRepeat)
     {
       while (newPos < 0)
       {
         newPos += maxSlices;
       }
 
       while (newPos >= maxSlices)
       {
         newPos -= maxSlices;
       }
     }
     else
     {
       // if the new slice is below 0 we still show slice 0
       // due to the stepper using unsigned int we have to do this ourselves
       if (newPos < 1)
       {
         newPos = 0;
       }
     }
     // set the new position
     sliceNaviController->GetSlice()->SetPos(newPos);
     m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
     m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
   }
 }
 
 void mitk::DisplayInteractor::ScrollOneDown(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   mitk::SliceNavigationController::Pointer sliceNaviController =
     interactionEvent->GetSender()->GetSliceNavigationController();
   if (!sliceNaviController->GetSliceLocked())
   {
     mitk::Stepper *stepper = sliceNaviController->GetSlice();
     if (stepper->GetSteps() <= 1)
     {
       stepper = sliceNaviController->GetTime();
     }
     stepper->Next();
   }
 }
 
 void mitk::DisplayInteractor::ScrollOneUp(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   mitk::SliceNavigationController::Pointer sliceNaviController =
     interactionEvent->GetSender()->GetSliceNavigationController();
   if (!sliceNaviController->GetSliceLocked())
   {
     mitk::Stepper *stepper = sliceNaviController->GetSlice();
     if (stepper->GetSteps() <= 1)
     {
       stepper = sliceNaviController->GetTime();
     }
     stepper->Previous();
   }
 }
 
 void mitk::DisplayInteractor::AdjustLevelWindow(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   BaseRenderer::Pointer sender = interactionEvent->GetSender();
   InteractionPositionEvent *positionEvent = static_cast<InteractionPositionEvent *>(interactionEvent);
 
   m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
   m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
   // search for active image
   mitk::DataStorage::Pointer storage = sender->GetDataStorage();
   mitk::DataNode::Pointer node = NULL;
   mitk::DataStorage::SetOfObjects::ConstPointer allImageNodes =
     storage->GetSubset(mitk::NodePredicateDataType::New("Image"));
   for (unsigned int i = 0; i < allImageNodes->size(); i++)
   {
     bool isActiveImage = false;
     bool propFound = allImageNodes->at(i)->GetBoolProperty("imageForLevelWindow", isActiveImage);
 
     if (propFound && isActiveImage)
     {
       node = allImageNodes->at(i);
       continue;
     }
   }
   if (node.IsNull())
   {
     node = storage->GetNode(mitk::NodePredicateDataType::New("Image"));
   }
   if (node.IsNull())
   {
     return;
   }
 
   mitk::LevelWindow lv = mitk::LevelWindow();
   node->GetLevelWindow(lv);
   ScalarType level = lv.GetLevel();
   ScalarType window = lv.GetWindow();
 
   int levelIndex = 0;
   int windowIndex = 1;
 
   if (m_LevelDirection != "leftright")
   {
     levelIndex = 1;
     windowIndex = 0;
   }
 
   int directionModifier = 1;
   if (m_InvertLevelWindowDirection)
   {
     directionModifier = -1;
   }
 
   // calculate adjustments from mouse movements
   level += (m_CurrentDisplayCoordinate[levelIndex] - m_LastDisplayCoordinate[levelIndex]) * static_cast<ScalarType>(2) *
            directionModifier;
   window += (m_CurrentDisplayCoordinate[windowIndex] - m_LastDisplayCoordinate[windowIndex]) *
             static_cast<ScalarType>(2) * directionModifier;
 
   lv.SetLevelWindow(level, window);
   dynamic_cast<mitk::LevelWindowProperty *>(node->GetProperty("levelwindow"))->SetLevelWindow(lv);
 
   sender->GetRenderingManager()->RequestUpdateAll();
 }
 
 void mitk::DisplayInteractor::StartRotation(mitk::StateMachineAction *, mitk::InteractionEvent *)
 {
   this->SetMouseCursor(rotate_cursor_xpm, 0, 0);
 }
 
 void mitk::DisplayInteractor::EndRotation(mitk::StateMachineAction *, mitk::InteractionEvent *)
 {
   this->ResetMouseCursor();
 }
 
 void mitk::DisplayInteractor::Rotate(mitk::StateMachineAction *, mitk::InteractionEvent *event)
 {
   const InteractionPositionEvent *posEvent = dynamic_cast<const InteractionPositionEvent *>(event);
   if (posEvent == nullptr)
     return;
 
   Point3D cursor = posEvent->GetPositionInWorld();
 
   Vector3D toProjected = m_LastCursorPosition - m_CenterOfRotation;
   Vector3D toCursor = cursor - m_CenterOfRotation;
 
   // cross product: | A x B | = |A| * |B| * sin(angle)
   Vector3D axisOfRotation;
   vnl_vector_fixed<ScalarType, 3> vnlDirection = vnl_cross_3d(toCursor.GetVnlVector(), toProjected.GetVnlVector());
   axisOfRotation.SetVnlVector(vnlDirection);
 
   // scalar product: A * B = |A| * |B| * cos(angle)
   // tan = sin / cos
   ScalarType angle = -atan2((double)(axisOfRotation.GetNorm()), (double)(toCursor * toProjected));
   angle *= 180.0 / vnl_math::pi;
   m_LastCursorPosition = cursor;
 
   // create RotationOperation and apply to all SNCs that should be rotated
   RotationOperation rotationOperation(OpROTATE, m_CenterOfRotation, axisOfRotation, angle);
 
   // iterate the OTHER slice navigation controllers: these are filled in DoDecideBetweenRotationAndSliceSelection
   for (SNCVector::iterator iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     TimeGeometry *timeGeometry = (*iter)->GetCreatedWorldGeometry();
     if (!timeGeometry)
       continue;
 
     timeGeometry->ExecuteOperation(&rotationOperation);
 
     (*iter)->SendCreatedWorldGeometryUpdate();
   }
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::DisplayInteractor::Swivel(mitk::StateMachineAction *, mitk::InteractionEvent *event)
 {
   const InteractionPositionEvent *posEvent = dynamic_cast<const InteractionPositionEvent *>(event);
 
   if (!posEvent)
     return;
 
   // Determine relative mouse movement projected onto world space
   Point2D cursor = posEvent->GetPointerPositionOnScreen();
   Vector2D relativeCursor = cursor - m_ReferenceCursor;
   Vector3D relativeCursorAxis = m_RotationPlaneXVector * relativeCursor[0] + m_RotationPlaneYVector * relativeCursor[1];
 
   // Determine rotation axis (perpendicular to rotation plane and cursor
   // movement)
   Vector3D rotationAxis = itk::CrossProduct(m_RotationPlaneNormal, relativeCursorAxis);
 
   ScalarType rotationAngle = relativeCursor.GetNorm() / 2.0;
 
   // Restore the initial plane pose by undoing the previous rotation
   // operation
   RotationOperation op(OpROTATE, m_CenterOfRotation, m_PreviousRotationAxis, -m_PreviousRotationAngle);
 
   SNCVector::iterator iter;
   for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     if (!(*iter)->GetSliceRotationLocked())
     {
       TimeGeometry *timeGeometry = (*iter)->GetCreatedWorldGeometry();
       if (!timeGeometry)
         continue;
 
       timeGeometry->ExecuteOperation(&op);
       (*iter)->SendCreatedWorldGeometryUpdate();
     }
   }
 
   // Apply new rotation operation to all relevant SNCs
   RotationOperation op2(OpROTATE, m_CenterOfRotation, rotationAxis, rotationAngle);
 
   for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
   {
     if (!(*iter)->GetSliceRotationLocked())
     {
       // Retrieve the TimeGeometry of this SliceNavigationController
       TimeGeometry *timeGeometry = (*iter)->GetCreatedWorldGeometry();
       if (!timeGeometry)
         continue;
 
       // Execute the new rotation
       timeGeometry->ExecuteOperation(&op2);
 
       // Notify listeners
       (*iter)->SendCreatedWorldGeometryUpdate();
     }
   }
 
   m_PreviousRotationAxis = rotationAxis;
   m_PreviousRotationAngle = rotationAngle;
 
   RenderingManager::GetInstance()->RequestUpdateAll();
   return;
 }
 
 void mitk::DisplayInteractor::UpdateStatusbar(mitk::StateMachineAction *, mitk::InteractionEvent *event)
 {
   const InteractionPositionEvent *posEvent = dynamic_cast<const InteractionPositionEvent *>(event);
 
   if (!posEvent)
     return;
 
   std::string statusText;
   TNodePredicateDataType<mitk::Image>::Pointer isImageData = TNodePredicateDataType<mitk::Image>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes =
     posEvent->GetSender()->GetDataStorage()->GetSubset(isImageData).GetPointer();
 
   // posEvent->GetPositionInWorld() would return the world position at the
   // time of initiating the interaction. However, we need to update the
   // status bar with the position after changing slice. Therefore, we
   // translate the same display position with the renderer again to
   // get the new world position.
   Point3D worldposition;
   event->GetSender()->DisplayToWorld(posEvent->GetPointerPositionOnScreen(), worldposition);
 
   mitk::Image::Pointer image3D;
   mitk::DataNode::Pointer node;
   mitk::DataNode::Pointer topSourceNode;
 
   int component = 0;
 
   node = this->GetTopLayerNode(nodes, worldposition, posEvent->GetSender());
   if (node.IsNotNull())
   {
     bool isBinary(false);
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes =
         posEvent->GetSender()->GetDataStorage()->GetSources(node, NULL, true);
       if (!sourcenodes->empty())
       {
         topSourceNode = this->GetTopLayerNode(sourcenodes, worldposition, posEvent->GetSender());
       }
       if (topSourceNode.IsNotNull())
       {
         image3D = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
         topSourceNode->GetIntProperty("Image.Displayed Component", component);
       }
       else
       {
         image3D = dynamic_cast<mitk::Image *>(node->GetData());
         node->GetIntProperty("Image.Displayed Component", component);
       }
     }
     else
     {
       image3D = dynamic_cast<mitk::Image *>(node->GetData());
       node->GetIntProperty("Image.Displayed Component", component);
     }
   }
 
   // get the position and gray value from the image and build up status bar text
-  if (image3D.IsNotNull())
+  auto statusBar = StatusBar::GetInstance();
+
+  if (image3D.IsNotNull() && statusBar != nullptr)
   {
     itk::Index<3> p;
     image3D->GetGeometry()->WorldToIndex(worldposition, p);
-    mitk::ScalarType pixelValue;
-    mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
-                            image3D->GetChannelDescriptor().GetPixelType(),
-                            image3D,
-                            image3D->GetVolumeData(posEvent->GetSender()->GetTimeStep()),
-                            p,
-                            pixelValue,
-                            component);
-    mitk::StatusBar::GetInstance()->DisplayImageInfo(worldposition, p, posEvent->GetSender()->GetTime(), pixelValue);
+
+    auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
+
+    if (pixelType == itk::ImageIOBase::RGB || pixelType == itk::ImageIOBase::RGBA)
+    {
+      std::string pixelValue = "Pixel RGB(A) value: ";
+      pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
+      statusBar->DisplayImageInfo(worldposition, p, posEvent->GetSender()->GetTime(), pixelValue.c_str());
+    }
+    else
+    {
+      mitk::ScalarType pixelValue;
+      mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
+        image3D->GetChannelDescriptor().GetPixelType(),
+        image3D,
+        image3D->GetVolumeData(posEvent->GetSender()->GetTimeStep()),
+        p,
+        pixelValue,
+        component);
+      statusBar->DisplayImageInfo(worldposition, p, posEvent->GetSender()->GetTime(), pixelValue);
+    }
   }
   else
   {
-    mitk::StatusBar::GetInstance()->DisplayImageInfoInvalid();
+    statusBar->DisplayImageInfoInvalid();
   }
 }
 
 void mitk::DisplayInteractor::ConfigurationChanged()
 {
   mitk::PropertyList::Pointer properties = GetAttributes();
   // auto repeat
   std::string strAutoRepeat = "";
   if (properties->GetStringProperty("autoRepeat", strAutoRepeat))
   {
     if (strAutoRepeat == "true")
     {
       m_AutoRepeat = true;
     }
     else
     {
       m_AutoRepeat = false;
     }
   }
   // pixel movement for scrolling one slice
   std::string strPixelPerSlice = "";
   if (properties->GetStringProperty("pixelPerSlice", strPixelPerSlice))
   {
     m_IndexToSliceModifier = atoi(strPixelPerSlice.c_str());
   }
   else
   {
     m_IndexToSliceModifier = 4;
   }
   // scroll direction
   if (!properties->GetStringProperty("scrollDirection", m_ScrollDirection))
   {
     m_ScrollDirection = "updown";
   }
 
   m_InvertScrollDirection = GetBoolProperty(properties, "invertScrollDirection", false);
 
   // zoom direction
   if (!properties->GetStringProperty("zoomDirection", m_ZoomDirection))
   {
     m_ZoomDirection = "updown";
   }
 
   m_InvertZoomDirection = GetBoolProperty(properties, "invertZoomDirection", false);
 
   m_InvertMoveDirection = GetBoolProperty(properties, "invertMoveDirection", false);
 
   if (!properties->GetStringProperty("levelWindowDirection", m_LevelDirection))
   {
     m_LevelDirection = "leftright";
   }
 
   m_InvertLevelWindowDirection = GetBoolProperty(properties, "invertLevelWindowDirection", false);
 
   // coupled rotation
   std::string strCoupled = "";
   if (properties->GetStringProperty("coupled", strCoupled))
   {
     if (strCoupled == "true")
       m_LinkPlanes = true;
     else
       m_LinkPlanes = false;
   }
 
   // zoom factor
   std::string strZoomFactor = "";
   properties->GetStringProperty("zoomFactor", strZoomFactor);
   m_ZoomFactor = .05;
   if (atoi(strZoomFactor.c_str()) > 0)
   {
     m_ZoomFactor = 1.0 + (atoi(strZoomFactor.c_str()) / 100.0);
   }
   // allwaysReact
   std::string strAlwaysReact = "";
   if (properties->GetStringProperty("alwaysReact", strAlwaysReact))
   {
     if (strAlwaysReact == "true")
     {
       m_AlwaysReact = true;
     }
     else
     {
       m_AlwaysReact = false;
     }
   }
   else
   {
     m_AlwaysReact = false;
   }
 }
 
 bool mitk::DisplayInteractor::FilterEvents(InteractionEvent *interactionEvent, DataNode * /*dataNode*/)
 {
   if (interactionEvent->GetSender() == nullptr)
     return false;
   if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard3D)
     return false;
 
   return true;
 }
 
 bool mitk::DisplayInteractor::GetBoolProperty(mitk::PropertyList::Pointer propertyList,
                                               const char *propertyName,
                                               bool defaultValue)
 {
   std::string valueAsString;
   if (!propertyList->GetStringProperty(propertyName, valueAsString))
   {
     return defaultValue;
   }
   else
   {
     if (valueAsString == "true")
     {
       return true;
     }
     else
     {
       return false;
     }
   }
 }
 
 mitk::DataNode::Pointer mitk::DisplayInteractor::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes,
                                                                  mitk::Point3D worldposition,
                                                                  BaseRenderer *ren)
 {
   mitk::DataNode::Pointer node;
 
   if (nodes.IsNotNull())
   {
     int maxlayer = -32768;
     bool isHelper(false);
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
       nodes->at(x)->GetBoolProperty("helper object", isHelper);
       if (nodes->at(x)->GetData()->GetGeometry()->IsInside(worldposition) && isHelper == false)
       {
         int layer = 0;
         if (!(nodes->at(x)->GetIntProperty("layer", layer)))
           continue;
         if (layer > maxlayer)
         {
           if (static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(ren))
           {
             node = nodes->at(x);
             maxlayer = layer;
           }
         }
       }
     }
   }
   return node;
 }
diff --git a/Modules/Core/test/files.cmake b/Modules/Core/test/files.cmake
index 0d7a477e06..c90005a992 100644
--- a/Modules/Core/test/files.cmake
+++ b/Modules/Core/test/files.cmake
@@ -1,196 +1,197 @@
 # tests with no extra command line parameter
 set(MODULE_TESTS
   # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
   #
   #     Example: #mitkMyTest #this test is commented out because of bug 12345
   #
   # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
   # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
   # mark it as critical.
 
   ################## DISABLED TESTS #################################################
   #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more
   #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529
   #mitkRegistrationBaseTest.cpp #tested class  mitkRegistrationBase doesn't exist any more
   #mitkSegmentationInterpolationTest.cpp #file doesn't exist!
   #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist!
   #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK
   #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more
   #mitkTestUtilSharedLibrary.cpp #Linker problem with this test...
   #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details.
 
   ################# RUNNING TESTS ###################################################
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkDataNodeTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkFileReaderRegistryTest.cpp
   #mitkFileWriterRegistryTest.cpp
   mitkFloatToStringTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometry3DEqualTest.cpp
   mitkGeometryDataIOTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkImageCastTest.cpp
   mitkImageEqualTest.cpp
   mitkImageDataItemTest.cpp
   mitkImageGeneratorTest.cpp
   mitkIOUtilTest.cpp
   mitkBaseDataTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetOnEmptyTest.cpp
   mitkPointSetLocaleTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetReaderTest.cpp
   mitkPointSetPointOperationsTest.cpp
   mitkProgressBarTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   mitkPropertyPersistenceTest.cpp
   mitkPropertyPersistenceInfoTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeGeometryTest.cpp
   mitkProportionalTimeGeometryTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   mitkStepperTest.cpp
   mitkRenderingManagerTest.cpp
+  mitkCompositePixelValueToStringTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkShaderRepositoryTest.cpp
   mitkPlanePositionManagerTest.cpp
   mitkAffineTransformBaseTest.cpp
   mitkPropertyAliasesTest.cpp
   mitkPropertyDescriptionsTest.cpp
   mitkPropertyExtensionsTest.cpp
   mitkPropertyFiltersTest.cpp
   mitkTinyXMLTest.cpp
   mitkRawImageFileReaderTest.cpp
   mitkInteractionEventTest.cpp
   mitkLookupTableTest.cpp
   mitkSTLFileReaderTest.cpp
   mitkPointTypeConversionTest.cpp
   mitkVectorTypeConversionTest.cpp
   mitkMatrixTypeConversionTest.cpp
   mitkArrayTypeConversionTest.cpp
   mitkSurfaceToImageFilterTest.cpp
   mitkBaseGeometryTest.cpp
   mitkImageToSurfaceFilterTest.cpp
   mitkEqualTest.cpp
   mitkLineTest.cpp
   mitkArbitraryTimeGeometryTest
   mitkItkImageIOTest.cpp
   mitkRotatedSlice4DTest.cpp
   mitkLevelWindowManagerCppUnitTest.cpp
   mitkVectorPropertyTest.cpp
   mitkTemporoSpatialStringPropertyTest.cpp
   mitkPropertyNameHelperTest.cpp
 )
 
 if(MITK_ENABLE_RENDERING_TESTING)
 set(MODULE_TESTS
   ${MODULE_TESTS}
   mitkPlaneGeometryDataMapper2DTest.cpp
   mitkPointSetDataInteractorTest.cpp #since mitkInteractionTestHelper is currently creating a vtkRenderWindow
   mitkSurfaceVtkMapper2DTest.cpp #new rendering test in CppUnit style
   mitkSurfaceVtkMapper2D3DTest.cpp # comparisons/consistency 2D/3D
 )
 endif()
 
 
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGE
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACE
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     mitkDataStorageTest.cpp
     mitkDicomSeriesReaderTest.cpp
     mitkDICOMLocaleTest.cpp
     mitkDataNodeTest.cpp
     mitkEventConfigTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkImageVtkMapper2DOpacityTransferFunctionTest.cpp
     mitkImageVtkMapper2DLookupTableTest.cpp
     mitkSurfaceVtkMapper3DTest
     mitkSurfaceVtkMapper3DTexturedSphereTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkPointSetVtkMapper2DTransformedPointsTest.cpp
     mitkVTKRenderWindowSizeTest.cpp
     mitkMultiComponentImageDataComparisonFilterTest.cpp
     mitkImageToItkTest.cpp
     mitkImageSliceSelectorTest.cpp
     mitkSurfaceDepthPeelingTest.cpp
 )
 
 # Currently not working on windows because of a rendering timing issue
 # see bug 18083 for details
 if(NOT WIN32)
  set(MODULE_CUSTOM_TESTS ${MODULE_CUSTOM_TESTS} mitkSurfaceDepthSortingTest.cpp)
 endif()
 
 set(RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
diff --git a/Modules/Core/test/mitkCompositePixelValueToStringTest.cpp b/Modules/Core/test/mitkCompositePixelValueToStringTest.cpp
new file mode 100644
index 0000000000..5d4e882608
--- /dev/null
+++ b/Modules/Core/test/mitkCompositePixelValueToStringTest.cpp
@@ -0,0 +1,330 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkTestingMacros.h"
+#include <mitkTestFixture.h>
+#include <mitkTestingConfig.h>
+
+#include <itkImage.h>
+#include <mitkCompositePixelValueToString.h>
+#include <mitkImage.h>
+#include <mitkImageAccessByItk.h>
+#include <sstream>
+
+class mitkCompositePixelValueToStringTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkCompositePixelValueToStringTestSuite);
+  MITK_TEST(TestConvertRGBUnsignedChar2D_CorrectResult);
+  MITK_TEST(TestConvertRGBUnsignedChar3D_CorrectResult);
+  MITK_TEST(TestConvertRGBAUnsignedChar2D_CorrectResult);
+  MITK_TEST(TestConvertRGBAUnsignedChar3D_CorrectResult);
+  MITK_TEST(TestConvertRGBLong_Exception);
+  MITK_TEST(TestConvertInt_Exception);
+  MITK_TEST(TestConvertRGBIndexOutside_NoResult);
+  MITK_TEST(TestConvertNullImage_Exception);
+
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+public:
+  void setUp() override {}
+  void TestConvertRGBUnsignedChar2D_CorrectResult()
+  {
+    typedef itk::RGBPixel<unsigned char> PixelType;
+    typedef itk::Image<PixelType, 2> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    pixelValue = ConvertCompositePixelValueToString(mitkImage, index3D);
+
+    CPPUNIT_ASSERT(pixelValue.compare("0  125  250") == 0);
+  }
+
+  void TestConvertRGBUnsignedChar3D_CorrectResult()
+  {
+    typedef itk::RGBPixel<unsigned char> PixelType;
+    typedef itk::Image<PixelType, 3> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    pixelValue = ConvertCompositePixelValueToString(mitkImage, index3D);
+
+    CPPUNIT_ASSERT(pixelValue.compare("0  125  250") == 0);
+  }
+
+  void TestConvertRGBAUnsignedChar2D_CorrectResult()
+  {
+    typedef itk::RGBAPixel<unsigned char> PixelType;
+    typedef itk::Image<PixelType, 2> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250, 42);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    pixelValue = ConvertCompositePixelValueToString(mitkImage, index3D);
+
+    CPPUNIT_ASSERT(pixelValue.compare("0  125  250  42") == 0);
+  }
+
+  void TestConvertRGBAUnsignedChar3D_CorrectResult()
+  {
+    typedef itk::RGBAPixel<unsigned char> PixelType;
+    typedef itk::Image<PixelType, 3> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250, 42);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    pixelValue = ConvertCompositePixelValueToString(mitkImage, index3D);
+
+    CPPUNIT_ASSERT(pixelValue.compare("0  125  250  42") == 0);
+  }
+
+  void TestConvertRGBLong_Exception()
+  {
+    typedef itk::RGBAPixel<long> PixelType;
+    typedef itk::Image<PixelType, 3> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250, 42);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    CPPUNIT_ASSERT_THROW(ConvertCompositePixelValueToString(mitkImage, index3D), mitk::AccessByItkException);
+  }
+
+  void TestConvertInt_Exception()
+  {
+    typedef itk::Image<int, 3> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    int pixel = 21;
+
+    image->SetPixel(pixelIndex, pixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    CPPUNIT_ASSERT_THROW(ConvertCompositePixelValueToString(mitkImage, index3D), mitk::AccessByItkException);
+  }
+
+  void TestConvertRGBIndexOutside_NoResult()
+  {
+    typedef itk::RGBPixel<unsigned char> PixelType;
+    typedef itk::Image<PixelType, 2> ImageType;
+
+    ImageType::RegionType region;
+    ImageType::IndexType start;
+    start.Fill(0);
+
+    ImageType::SizeType size;
+    size.Fill(1);
+
+    region.SetSize(size);
+    region.SetIndex(start);
+
+    ImageType::Pointer image = ImageType::New();
+    image->SetRegions(region);
+    image->Allocate();
+
+    ImageType::IndexType pixelIndex;
+    pixelIndex.Fill(0);
+
+    PixelType rgbPixel;
+    rgbPixel.Set(0, 125, 250);
+
+    image->SetPixel(pixelIndex, rgbPixel);
+
+    mitk::Image::Pointer mitkImage = mitk::Image::New();
+    mitkImage->InitializeByItk(image.GetPointer());
+    mitkImage->SetVolume(image->GetBufferPointer());
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(5);
+
+    pixelValue = ConvertCompositePixelValueToString(mitkImage, index3D);
+
+    CPPUNIT_ASSERT(pixelValue.compare("Out of bounds") == 0);
+  }
+
+  void TestConvertNullImage_Exception()
+  {
+    mitk::Image::Pointer mitkImage;
+
+    std::string pixelValue;
+    itk::Index<3> index3D;
+    index3D.Fill(0);
+
+    CPPUNIT_ASSERT_THROW(ConvertCompositePixelValueToString(mitkImage, index3D), mitk::Exception);
+  }
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkCompositePixelValueToString)
diff --git a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
index 0cfef766f7..34abd87c69 100644
--- a/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
+++ b/Plugins/org.mitk.gui.qt.imagenavigator/src/internal/QmitkImageNavigatorView.cpp
@@ -1,537 +1,555 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkImageNavigatorView.h"
 
 #include <QmitkStepperAdapter.h>
 #include <QmitkRenderWindow.h>
 
 #include <mitkTimeGeometry.h>
 
 #include <berryConstants.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkStatusBar.h>
 #include <mitkPixelTypeMultiplex.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkNodePredicateProperty.h>
 
+#include <mitkCompositePixelValueToString.h>
+
 const std::string QmitkImageNavigatorView::VIEW_ID = "org.mitk.views.imagenavigator";
 
 
 static mitk::DataNode::Pointer GetTopLayerNode(const mitk::DataStorage::SetOfObjects::ConstPointer nodes, const mitk::Point3D &position, mitk::BaseRenderer* renderer)
 {
     mitk::DataNode::Pointer node;
     int  maxlayer = -32768;
 
     if(nodes.IsNotNull())
     {
         // find node with largest layer, that is the node shown on top in the render window
         for (unsigned int x = 0; x < nodes->size(); x++)
         {
             if ( (nodes->at(x)->GetData()->GetGeometry() != NULL) &&
                  nodes->at(x)->GetData()->GetGeometry()->IsInside(position) )
             {
                 int layer = 0;
                 if(!(nodes->at(x)->GetIntProperty("layer", layer))) continue;
                 if(layer > maxlayer)
                 {
                     if( static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(renderer) )
                     {
                         node = nodes->at(x);
                         maxlayer = layer;
                     }
                 }
             }
         }
     }
 
     return node;
 }
 
 QmitkImageNavigatorView::QmitkImageNavigatorView()
   : m_AxialStepper(0)
   , m_SagittalStepper(0)
   , m_FrontalStepper(0)
   , m_TimeStepper(0)
   , m_Parent(0)
   , m_IRenderWindowPart(0)
 {
 }
 
 QmitkImageNavigatorView::~QmitkImageNavigatorView()
 {
 }
 
 void QmitkImageNavigatorView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
   m_Controls.m_SliceNavigatorAxial->SetInverseDirection(true);
 
   connect(m_Controls.m_XWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_YWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
   connect(m_Controls.m_ZWorldCoordinateSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnMillimetreCoordinateValueChanged()));
 
   m_Parent->setEnabled(false);
 
   mitk::IRenderWindowPart* renderPart = this->GetRenderWindowPart();
   this->RenderWindowPartActivated(renderPart);
 }
 
 void QmitkImageNavigatorView::SetFocus ()
 {
   m_Controls.m_XWorldCoordinateSpinBox->setFocus();
 }
 
 void QmitkImageNavigatorView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (this->m_IRenderWindowPart != renderWindowPart)
   {
     this->m_IRenderWindowPart = renderWindowPart;
     this->m_Parent->setEnabled(true);
 
     QmitkRenderWindow* renderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       if (m_AxialStepper) m_AxialStepper->deleteLater();
       m_AxialStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorAxial,
                                                      renderWindow->GetSliceNavigationController()->GetSlice(),
                                                      "sliceNavigatorAxialFromSimpleExample");
       m_Controls.m_SliceNavigatorAxial->setEnabled(true);
       m_Controls.m_AxialLabel->setEnabled(true);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(true);
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
       connect(m_AxialStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorAxial->setEnabled(false);
       m_Controls.m_AxialLabel->setEnabled(false);
       m_Controls.m_ZWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       if (m_SagittalStepper) m_SagittalStepper->deleteLater();
       m_SagittalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorSagittal,
                                                   renderWindow->GetSliceNavigationController()->GetSlice(),
                                                   "sliceNavigatorSagittalFromSimpleExample");
       m_Controls.m_SliceNavigatorSagittal->setEnabled(true);
       m_Controls.m_SagittalLabel->setEnabled(true);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(true);
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
       connect(m_SagittalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorSagittal->setEnabled(false);
       m_Controls.m_SagittalLabel->setEnabled(false);
       m_Controls.m_YWorldCoordinateSpinBox->setEnabled(false);
     }
 
     renderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       if (m_FrontalStepper) m_FrontalStepper->deleteLater();
       m_FrontalStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorFrontal,
                                                  renderWindow->GetSliceNavigationController()->GetSlice(),
                                                  "sliceNavigatorFrontalFromSimpleExample");
       m_Controls.m_SliceNavigatorFrontal->setEnabled(true);
       m_Controls.m_CoronalLabel->setEnabled(true);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(true);
       connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(OnRefetch()));
       connect(m_FrontalStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorFrontal->setEnabled(false);
       m_Controls.m_CoronalLabel->setEnabled(false);
       m_Controls.m_XWorldCoordinateSpinBox->setEnabled(false);
     }
 
     mitk::SliceNavigationController* timeController = renderWindowPart->GetTimeNavigationController();
     if (timeController)
     {
       if (m_TimeStepper) m_TimeStepper->deleteLater();
       m_TimeStepper = new QmitkStepperAdapter(m_Controls.m_SliceNavigatorTime,
                                               timeController->GetTime(),
                                               "sliceNavigatorTimeFromSimpleExample");
       m_Controls.m_SliceNavigatorTime->setEnabled(true);
       m_Controls.m_TimeLabel->setEnabled(true);
       connect(m_TimeStepper, SIGNAL(Refetch()), this, SLOT(UpdateStatusBar()));
     }
     else
     {
       m_Controls.m_SliceNavigatorTime->setEnabled(false);
       m_Controls.m_TimeLabel->setEnabled(false);
     }
   }
 }
 
 void QmitkImageNavigatorView::UpdateStatusBar()
 {
   if (m_IRenderWindowPart != nullptr)
   {
     mitk::Point3D position = m_IRenderWindowPart->GetSelectedPosition();
     mitk::BaseRenderer::Pointer renderer = mitk::BaseRenderer::GetInstance(m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetVtkRenderWindow());
     mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetSubset(isImageData).GetPointer();
 
     if (nodes.IsNotNull())
     {
       mitk::Image::Pointer image3D;
       mitk::DataNode::Pointer node;
       mitk::DataNode::Pointer topSourceNode;
 
       int component = 0;
 
       node = GetTopLayerNode(nodes, position, renderer);
 
       if (node.IsNotNull())
       {
         bool isBinary(false);
         node->GetBoolProperty("binary", isBinary);
         if (isBinary)
         {
           mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = this->GetDataStorage()->GetSources(node, NULL, true);
           if (!sourcenodes->empty())
           {
             topSourceNode = GetTopLayerNode(sourcenodes, position, renderer);
           }
           if (topSourceNode.IsNotNull())
           {
             image3D = dynamic_cast<mitk::Image*>(topSourceNode->GetData());
             topSourceNode->GetIntProperty("Image.Displayed Component", component);
           }
           else
           {
             image3D = dynamic_cast<mitk::Image*>(node->GetData());
             node->GetIntProperty("Image.Displayed Component", component);
           }
         }
         else
         {
           image3D = dynamic_cast<mitk::Image*>(node->GetData());
           node->GetIntProperty("Image.Displayed Component", component);
         }
       }
 
-      // get the position and gray value from the image and build up status bar text
-      if (image3D.IsNotNull())
+      // get the position and pixel value from the image and build up status bar text
+      auto statusBar = mitk::StatusBar::GetInstance();
+
+      if (image3D.IsNotNull() && statusBar != nullptr)
       {
         itk::Index<3> p;
         image3D->GetGeometry()->WorldToIndex(position, p);
-        mitk::ScalarType pixelValue;
-        mitkPixelTypeMultiplex5(
-          mitk::FastSinglePixelAccess,
-          image3D->GetChannelDescriptor().GetPixelType(),
-          image3D,
-          image3D->GetVolumeData(renderer->GetTimeStep()),
-          p,
-          pixelValue,
-          component);
-        mitk::StatusBar::GetInstance()->DisplayImageInfo(position, p, renderer->GetTime(), pixelValue);
+
+        auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
+
+        if (pixelType == itk::ImageIOBase::RGB || pixelType == itk::ImageIOBase::RGBA)
+        {
+          std::string pixelValue = "Pixel RGB(A) value: ";
+          pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
+          statusBar->DisplayImageInfo(position, p, renderer->GetTime(), pixelValue.c_str());
+        }
+        else
+        {
+          itk::Index<3> p;
+          image3D->GetGeometry()->WorldToIndex(position, p);
+          mitk::ScalarType pixelValue;
+          mitkPixelTypeMultiplex5(
+            mitk::FastSinglePixelAccess,
+            image3D->GetChannelDescriptor().GetPixelType(),
+            image3D,
+            image3D->GetVolumeData(renderer->GetTimeStep()),
+            p,
+            pixelValue,
+            component);
+          statusBar->DisplayImageInfo(position, p, renderer->GetTime(), pixelValue);
+        }
       }
       else
       {
-        mitk::StatusBar::GetInstance()->DisplayImageInfoInvalid();
+        statusBar->DisplayImageInfoInvalid();
       }
     }
   }
 }
 
 void QmitkImageNavigatorView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_IRenderWindowPart = 0;
   m_Parent->setEnabled(false);
 }
 
 int QmitkImageNavigatorView::GetSizeFlags(bool width)
 {
   if(!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkImageNavigatorView::ComputePreferredSize(bool width, int /*availableParallel*/, int /*availablePerpendicular*/, int preferredResult)
 {
   if(width==false)
   {
     return 200;
   }
   else
   {
     return preferredResult;
   }
 }
 
 int QmitkImageNavigatorView::GetClosestAxisIndex(mitk::Vector3D normal)
 {
   // cos(theta) = normal . axis
   // cos(theta) = (a, b, c) . (d, e, f)
   // cos(theta) = (a, b, c) . (1, 0, 0) = a
   // cos(theta) = (a, b, c) . (0, 1, 0) = b
   // cos(theta) = (a, b, c) . (0, 0, 1) = c
   double absCosThetaWithAxis[3];
 
   for (int i = 0; i < 3; i++)
   {
     absCosThetaWithAxis[i] = fabs(normal[i]);
   }
   int largestIndex = 0;
   double largestValue = absCosThetaWithAxis[0];
   for (int i = 1; i < 3; i++)
   {
     if (absCosThetaWithAxis[i] > largestValue)
     {
       largestValue = absCosThetaWithAxis[i];
       largestIndex = i;
     }
   }
   return largestIndex;
 }
 
 void QmitkImageNavigatorView::SetBorderColors()
 {
   if (m_IRenderWindowPart)
   {
     QString decoColor;
 
     QmitkRenderWindow* renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("axial");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("sagittal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
 
     renderWindow = m_IRenderWindowPart->GetQmitkRenderWindow("coronal");
     if (renderWindow)
     {
       decoColor = GetDecorationColorOfGeometry(renderWindow);
       mitk::PlaneGeometry::ConstPointer geometry = renderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
       if (geometry.IsNotNull())
       {
         mitk::Vector3D normal = geometry->GetNormal();
         int axis = this->GetClosestAxisIndex(normal);
         this->SetBorderColor(axis, decoColor);
       }
     }
   }
 }
 
 QString QmitkImageNavigatorView::GetDecorationColorOfGeometry(QmitkRenderWindow* renderWindow)
 {
   QColor color;
   float rgb[3] = {1.0f, 1.0f, 1.0f};
   float rgbMax = 255.0f;
   mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow())->GetCurrentWorldPlaneGeometryNode()->GetColor(rgb);
   color.setRed(static_cast<int>(rgb[0]*rgbMax + 0.5));
   color.setGreen(static_cast<int>(rgb[1]*rgbMax + 0.5));
   color.setBlue(static_cast<int>(rgb[2]*rgbMax + 0.5));
   QString colorAsString = QString(color.name());
   return colorAsString;
 }
 
 void QmitkImageNavigatorView::SetBorderColor(int axis, QString colorAsStyleSheetString)
 {
   if (axis == 0)
   {
     this->SetBorderColor(m_Controls.m_XWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 1)
   {
     this->SetBorderColor(m_Controls.m_YWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
   else if (axis == 2)
   {
     this->SetBorderColor(m_Controls.m_ZWorldCoordinateSpinBox, colorAsStyleSheetString);
   }
 }
 
 void QmitkImageNavigatorView::SetBorderColor(QDoubleSpinBox *spinBox, QString colorAsStyleSheetString)
 {
   assert(spinBox);
   spinBox->setStyleSheet(QString("border: 2px solid ") + colorAsStyleSheetString + ";");
 }
 
 void QmitkImageNavigatorView::SetStepSizes()
 {
   this->SetStepSize(0);
   this->SetStepSize(1);
   this->SetStepSize(2);
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis)
 {
   if (m_IRenderWindowPart)
   {
     mitk::BaseGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D crossPositionInIndexCoordinates;
       mitk::Point3D crossPositionInIndexCoordinatesPlus1;
       mitk::Point3D crossPositionInMillimetresPlus1;
       mitk::Vector3D transformedAxisDirection;
 
       mitk::Point3D crossPositionInMillimetres = m_IRenderWindowPart->GetSelectedPosition();
       geometry->WorldToIndex(crossPositionInMillimetres, crossPositionInIndexCoordinates);
 
       crossPositionInIndexCoordinatesPlus1 = crossPositionInIndexCoordinates;
       crossPositionInIndexCoordinatesPlus1[axis] += 1;
 
       geometry->IndexToWorld(crossPositionInIndexCoordinatesPlus1, crossPositionInMillimetresPlus1);
 
       transformedAxisDirection = crossPositionInMillimetresPlus1 - crossPositionInMillimetres;
 
       int closestAxisInMillimetreSpace = this->GetClosestAxisIndex(transformedAxisDirection);
       double stepSize = transformedAxisDirection.GetNorm();
       this->SetStepSize(closestAxisInMillimetreSpace, stepSize);
     }
   }
 }
 
 void QmitkImageNavigatorView::SetStepSize(int axis, double stepSize)
 {
   if (axis == 0)
   {
     m_Controls.m_XWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 1)
   {
     m_Controls.m_YWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
   else if (axis == 2)
   {
     m_Controls.m_ZWorldCoordinateSpinBox->setSingleStep(stepSize);
   }
 }
 
 void QmitkImageNavigatorView::OnMillimetreCoordinateValueChanged()
 {
   if (m_IRenderWindowPart)
   {
     mitk::TimeGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNotNull())
     {
       mitk::Point3D positionInWorldCoordinates;
       positionInWorldCoordinates[0] = m_Controls.m_XWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[1] = m_Controls.m_YWorldCoordinateSpinBox->value();
       positionInWorldCoordinates[2] = m_Controls.m_ZWorldCoordinateSpinBox->value();
 
       m_IRenderWindowPart->SetSelectedPosition(positionInWorldCoordinates);
     }
   }
 }
 
 void QmitkImageNavigatorView::OnRefetch()
 {
   if (m_IRenderWindowPart)
   {
     mitk::BaseGeometry::ConstPointer geometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldGeometry3D();
     mitk::TimeGeometry::ConstPointer timeGeometry = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetInputWorldTimeGeometry();
 
     if (geometry.IsNull() && timeGeometry.IsNotNull())
     {
       mitk::TimeStepType timeStep = m_IRenderWindowPart->GetActiveQmitkRenderWindow()->GetSliceNavigationController()->GetTime()->GetPos();
       geometry = timeGeometry->GetGeometryForTimeStep(timeStep);
     }
 
     if (geometry.IsNotNull())
     {
       mitk::BoundingBox::BoundsArrayType bounds = geometry->GetBounds();
 
       mitk::Point3D cornerPoint1InIndexCoordinates;
       cornerPoint1InIndexCoordinates[0] = bounds[0];
       cornerPoint1InIndexCoordinates[1] = bounds[2];
       cornerPoint1InIndexCoordinates[2] = bounds[4];
 
       mitk::Point3D cornerPoint2InIndexCoordinates;
       cornerPoint2InIndexCoordinates[0] = bounds[1];
       cornerPoint2InIndexCoordinates[1] = bounds[3];
       cornerPoint2InIndexCoordinates[2] = bounds[5];
 
       if (!geometry->GetImageGeometry())
       {
         cornerPoint1InIndexCoordinates[0] += 0.5;
         cornerPoint1InIndexCoordinates[1] += 0.5;
         cornerPoint1InIndexCoordinates[2] += 0.5;
         cornerPoint2InIndexCoordinates[0] -= 0.5;
         cornerPoint2InIndexCoordinates[1] -= 0.5;
         cornerPoint2InIndexCoordinates[2] -= 0.5;
       }
 
       mitk::Point3D crossPositionInWorldCoordinates = m_IRenderWindowPart->GetSelectedPosition();
 
       mitk::Point3D cornerPoint1InWorldCoordinates;
       mitk::Point3D cornerPoint2InWorldCoordinates;
 
       geometry->IndexToWorld(cornerPoint1InIndexCoordinates, cornerPoint1InWorldCoordinates);
       geometry->IndexToWorld(cornerPoint2InIndexCoordinates, cornerPoint2InWorldCoordinates);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(true);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(true);
 
       m_Controls.m_XWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMinimum(std::min(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
       m_Controls.m_XWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[0], cornerPoint2InWorldCoordinates[0]));
       m_Controls.m_YWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[1], cornerPoint2InWorldCoordinates[1]));
       m_Controls.m_ZWorldCoordinateSpinBox->setMaximum(std::max(cornerPoint1InWorldCoordinates[2], cornerPoint2InWorldCoordinates[2]));
 
       m_Controls.m_XWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[0]);
       m_Controls.m_YWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[1]);
       m_Controls.m_ZWorldCoordinateSpinBox->setValue(crossPositionInWorldCoordinates[2]);
 
       m_Controls.m_XWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_YWorldCoordinateSpinBox->blockSignals(false);
       m_Controls.m_ZWorldCoordinateSpinBox->blockSignals(false);
     }
 
     this->SetBorderColors();
 
   }
 }