diff --git a/Modules/Core/include/mitkImagePixelAccessor.h b/Modules/Core/include/mitkImagePixelAccessor.h
index cb63988558..05bafa2215 100644
--- a/Modules/Core/include/mitkImagePixelAccessor.h
+++ b/Modules/Core/include/mitkImagePixelAccessor.h
@@ -1,141 +1,135 @@
 /*===================================================================
 
 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 MITKIMAGEPIXELACCESSOR_H
 #define MITKIMAGEPIXELACCESSOR_H
 
 #include "mitkImage.h"
 #include "mitkImageDataItem.h"
 
 #include <typeinfo>
 
 namespace mitk
 {
   /**
    * @brief Provides templated image access for all inheriting classes
    * @tparam TPixel defines the PixelType
    * @tparam VDimension defines the dimension for accessing data
    * @ingroup Data
    */
   template <class TPixel, unsigned int VDimension = 3>
   class ImagePixelAccessor
   {
-  private:
-    friend class Image;
-
   public:
     typedef itk::Index<VDimension> IndexType;
     typedef ImagePixelAccessor<TPixel, VDimension> ImagePixelAccessorType;
     typedef Image::ConstPointer ImageConstPointer;
 
     /** Get Dimensions from ImageDataItem */
     int GetDimension(int i) const { return m_ImageDataItem->GetDimension(i); }
 
+  private:
+  friend class Image;
+
   protected:
     /**  \param ImageDataItem* specifies the allocated image part */
     ImagePixelAccessor(ImageConstPointer iP, const mitk::ImageDataItem *iDI) : m_ImageDataItem(iDI)
     {
       if (iDI == nullptr)
       {
         m_ImageDataItem = iP->GetChannelData();
       }
       CheckData(iP.GetPointer());
     }
 
     /** Destructor */
     virtual ~ImagePixelAccessor() {}
 
-    void CheckData(const Image *image)
+    void CheckData( const Image *image )
     {
       // Check if Dimensions are correct
-      if (m_ImageDataItem == nullptr)
+      if ( m_ImageDataItem == nullptr )
       {
-        if (image->GetDimension() != VDimension)
+        if ( image->GetDimension() != VDimension )
         {
-          MITK_DEBUG << "  image->GetDimension(): " << image->GetDimension() << " , VDimension: " << VDimension;
-          mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and Image are not equal. They have to "
-                         "be equal if an entire image is requested";
+          mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and Image are not equal."
+          << " They have to be equal if an entire image is requested."
+          << " image->GetDimension(): " << image->GetDimension() << " , VDimension: " << VDimension;
         }
       }
       else
       {
-        if (m_ImageDataItem->GetDimension() != VDimension)
+        if ( m_ImageDataItem->GetDimension() != VDimension )
         {
-          MITK_DEBUG << "  m_ImageDataItem->GetDimension(): " << m_ImageDataItem->GetDimension() << " , VDimension: " << VDimension;
-          mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and ImageDataItem are not equal.";
+          mitkThrow() << "Invalid ImageAccessor: The Dimensions of ImageAccessor and ImageDataItem are not equal."
+          << " m_ImageDataItem->GetDimension(): " << m_ImageDataItem->GetDimension() << " , VDimension: " << VDimension;
         }
       }
 
-      // Check if PixelType is correct
-      if (!( typeid(image->GetPixelType()) == typeid(mitk::MakePixelType<itk::Image<TPixel, VDimension>>()) ||
-             typeid(image->GetPixelType()) == typeid(mitk::MakePixelType< itk::VectorImage<TPixel, VDimension> >
-                                                     (image->GetPixelType().GetNumberOfComponents()) ) )
-          )
+      if (!( image->GetPixelType() == mitk::MakePixelType< itk::Image< TPixel, VDimension > >() ||
+             image->GetPixelType() == mitk::MakePixelType< itk::VectorImage< TPixel, VDimension > >
+               ( image->GetPixelType().GetNumberOfComponents() ) ) )
       {
-        MITK_DEBUG << "  image->GetPixelType(): " << typeid(image->GetPixelType()).name() << std::endl
-        << "  mitk::MakePixelType< itk::Image<TPixel, VDimension> >(): "
-        << typeid(mitk::MakePixelType< itk::Image<TPixel, VDimension> >()).name()
-        << std::endl
-        << "  mitk::MakePixelType< itk::VectorImage<TPixel, VDimension> >(image->GetPixelType().GetNumberOfComponents()): "
-        << typeid(mitk::MakePixelType< itk::VectorImage<TPixel, VDimension> >(image->GetPixelType().GetNumberOfComponents())).name()
-        << std::endl;
-        mitkThrow() << "Invalid ImageAccessor: PixelTypes of Image and ImageAccessor are not equal";
+        mitkThrow() << "Invalid ImageAccessor: PixelTypes of Image and ImageAccessor are not equal."
+        << " image->GetPixelType(): " << typeid(image->GetPixelType()).name() << std::endl
+        << std::endl << "  m_ImageDataItem->GetDimension(): " << m_ImageDataItem->GetDimension() << " , VDimension: " << VDimension
+        << " , TPixel: " << typeid(TPixel).name() << " , NumberOfComponents: " << image->GetPixelType().GetNumberOfComponents() << std::endl;
       }
     }
 
     /** Holds the specified ImageDataItem */
     const ImageDataItem *m_ImageDataItem;
 
     /** \brief Pointer to the used Geometry.
      *  Since Geometry can be different to the Image (if memory was forced to be coherent) it is necessary to store
      * Geometry separately.
      */
     BaseGeometry::Pointer m_Geometry;
 
     /** \brief A Subregion defines an arbitrary area within the image.
      *  If no SubRegion is defined, the whole ImageDataItem or Image is regarded.
      *  A subregion (e.g. subvolume) can lead to non-coherent memory access where every dimension has a start- and
      * end-offset.
      */
     itk::ImageRegion<VDimension> *m_SubRegion;
 
     /** \brief Stores all extended properties of an ImageAccessor.
      * The different flags in mitk::ImageAccessorBase::Options can be unified by bitwise operations.
      */
     int m_Options;
 
     /** Get memory offset for a given image index */
     unsigned int GetOffset(const IndexType &idx) const
     {
       const unsigned int *imageDims = m_ImageDataItem->m_Dimensions;
 
       unsigned int offset = 0;
       switch (VDimension)
       {
         case 4:
           offset += idx[3] * imageDims[0] * imageDims[1] * imageDims[2];
         case 3:
           offset += idx[2] * imageDims[0] * imageDims[1];
         case 2:
           offset += idx[0] + idx[1] * imageDims[0];
           break;
       }
       return offset;
     }
   };
 }
 
 #endif // MITKIMAGEACCESSOR_H
diff --git a/Modules/Core/src/IO/mitkPixelType.cpp b/Modules/Core/src/IO/mitkPixelType.cpp
index 2d0db71dc2..d64847862f 100644
--- a/Modules/Core/src/IO/mitkPixelType.cpp
+++ b/Modules/Core/src/IO/mitkPixelType.cpp
@@ -1,184 +1,185 @@
 /*===================================================================
 
 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 <typeinfo>//mdh/todo
 #include "mitkPixelType.h"
 #include <mitkLogMacros.h>
 
 mitk::PixelType::PixelType(const mitk::PixelType &other)
   : m_ComponentType(other.m_ComponentType),
     m_PixelType(other.m_PixelType),
     m_ComponentTypeName(other.m_ComponentTypeName),
     m_PixelTypeName(other.m_PixelTypeName),
     m_NumberOfComponents(other.m_NumberOfComponents),
     m_BytesPerComponent(other.m_BytesPerComponent)
 {
 }
 
 mitk::PixelType &mitk::PixelType::operator=(const PixelType &other)
 {
   m_ComponentType = other.m_ComponentType;
   m_PixelType = other.m_PixelType;
   m_ComponentTypeName = other.m_ComponentTypeName;
   m_PixelTypeName = other.m_PixelTypeName;
   m_NumberOfComponents = other.m_NumberOfComponents;
   m_BytesPerComponent = other.m_BytesPerComponent;
 
   return *this;
 }
 
 itk::ImageIOBase::IOPixelType mitk::PixelType::GetPixelType() const
 {
   return m_PixelType;
 }
 
 int mitk::PixelType::GetComponentType() const
 {
   return m_ComponentType;
 }
 
 std::string mitk::PixelType::GetPixelTypeAsString() const
 {
   return m_PixelTypeName;
 }
 
 std::string mitk::PixelType::GetComponentTypeAsString() const
 {
   return m_ComponentTypeName;
 }
 
 std::string mitk::PixelType::GetTypeAsString() const
 {
   return m_PixelTypeName + " (" + m_ComponentTypeName + ")";
 }
 
 size_t mitk::PixelType::GetSize() const
 {
   return (m_NumberOfComponents * m_BytesPerComponent);
 }
 
 size_t mitk::PixelType::GetBpe() const
 {
   return this->GetSize() * 8;
 }
 
 size_t mitk::PixelType::GetNumberOfComponents() const
 {
   return m_NumberOfComponents;
 }
 
 size_t mitk::PixelType::GetBitsPerComponent() const
 {
   return m_BytesPerComponent * 8;
 }
 
 mitk::PixelType::~PixelType()
 {
 }
 
 mitk::PixelType::PixelType(const int componentType,
                            const ItkIOPixelType pixelType,
                            std::size_t bytesPerComponent,
                            std::size_t numberOfComponents,
                            const std::string &componentTypeName,
                            const std::string &pixelTypeName)
   : m_ComponentType(componentType),
     m_PixelType(pixelType),
     m_ComponentTypeName(componentTypeName),
     m_PixelTypeName(pixelTypeName),
     m_NumberOfComponents(numberOfComponents),
     m_BytesPerComponent(bytesPerComponent)
 {
 }
 
 bool mitk::PixelType::operator==(const mitk::PixelType &rhs) const
 {
-  MITK_DEBUG << "operator==" << std::endl;
-
-  MITK_DEBUG << "m_NumberOfComponents = " << m_NumberOfComponents << " " << rhs.m_NumberOfComponents << std::endl;
-  MITK_DEBUG << "m_BytesPerComponent = " << m_BytesPerComponent << " " << rhs.m_BytesPerComponent << std::endl;
-  MITK_DEBUG << "m_PixelTypeName = " << m_PixelTypeName << " " << rhs.m_PixelTypeName << std::endl;
-  MITK_DEBUG << "m_PixelType = " << m_PixelType << " " << rhs.m_PixelType << std::endl;
-
-  bool returnValue =
-    (this->m_PixelType == rhs.m_PixelType && this->m_ComponentType == rhs.m_ComponentType &&
-     this->m_NumberOfComponents == rhs.m_NumberOfComponents && this->m_BytesPerComponent == rhs.m_BytesPerComponent);
-
-  if (returnValue)
-    MITK_DEBUG << " [TRUE] ";
-  else
-    MITK_DEBUG << " [FALSE] ";
+  //mdh/todo:std::cout -> MITK_DEBUG
+  std::cout << "|> mitk::PixelType::operator== " << std::endl
+            << "|m_BytesPerComponent = " << m_BytesPerComponent << ", " << rhs.m_BytesPerComponent << std::endl
+            << "|m_NumberOfComponents = " << m_NumberOfComponents << ", " << rhs.m_NumberOfComponents << std::endl
+            << "|m_PixelTypeName = " << m_PixelTypeName << ", " << rhs.m_PixelTypeName << std::endl
+            << "|m_ComponentTypeName = " << m_ComponentTypeName << ", " << rhs.m_ComponentTypeName << std::endl
+            << "|m_PixelType = " << m_PixelType << ", " << rhs.m_PixelType << std::endl
+            << "|m_ComponentType = " << m_ComponentType << ", " << rhs.m_ComponentType << std::endl;
+
+  bool returnValue = ( this->m_PixelType == rhs.m_PixelType
+                    && this->m_ComponentType == rhs.m_ComponentType
+                    && this->m_NumberOfComponents == rhs.m_NumberOfComponents
+                    && this->m_BytesPerComponent == rhs.m_BytesPerComponent );
+
+  if (returnValue){ MITK_DEBUG << " [TRUE] "; }
+  else{ MITK_DEBUG << " [FALSE] "; }
 
   return returnValue;
 }
 
 bool mitk::PixelType::operator!=(const mitk::PixelType &rhs) const
 {
   return !(this->operator==(rhs));
 }
 
 mitk::PixelType mitk::MakePixelType(vtkImageData *vtkimagedata)
 {
   int numOfComponents = vtkimagedata->GetNumberOfScalarComponents();
 
   switch (vtkimagedata->GetScalarType())
   {
     case VTK_BIT:
     case VTK_CHAR:
       return mitk::MakePixelType<char, char>(numOfComponents);
       break;
 
     case VTK_UNSIGNED_CHAR:
       return mitk::MakePixelType<unsigned char, unsigned char>(numOfComponents);
       break;
 
     case VTK_SHORT:
       return mitk::MakePixelType<short, short>(numOfComponents);
       break;
 
     case VTK_UNSIGNED_SHORT:
       return mitk::MakePixelType<unsigned short, unsigned short>(numOfComponents);
       break;
 
     case VTK_INT:
       return mitk::MakePixelType<int, int>(numOfComponents);
       break;
 
     case VTK_UNSIGNED_INT:
       return mitk::MakePixelType<unsigned int, unsigned int>(numOfComponents);
       break;
 
     case VTK_LONG:
       return mitk::MakePixelType<long, long>(numOfComponents);
       break;
 
     case VTK_UNSIGNED_LONG:
       return mitk::MakePixelType<unsigned long, unsigned long>(numOfComponents);
       break;
 
     case VTK_FLOAT:
       return mitk::MakePixelType<float, float>(numOfComponents);
       break;
 
     case VTK_DOUBLE:
       return mitk::MakePixelType<double, double>(numOfComponents);
       break;
 
     default:
       break;
   }
 
   mitkThrow() << "tried to make pixeltype from vtkimage of unknown data type(short, char, int, ...)";
 }