diff --git a/Modules/DICOMReader/include/mitkDICOMDatasetAccess.h b/Modules/DICOMReader/include/mitkDICOMDatasetAccess.h
index 35e94f27e6..19cf6c9ac1 100644
--- a/Modules/DICOMReader/include/mitkDICOMDatasetAccess.h
+++ b/Modules/DICOMReader/include/mitkDICOMDatasetAccess.h
@@ -1,52 +1,66 @@
 /*===================================================================
 
 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 mitkDICOMDatasetAccess_h
 #define mitkDICOMDatasetAccess_h
 
 #include "mitkDICOMTag.h"
 
 #include "MitkDICOMReaderExports.h"
 
 namespace mitk
 {
+  /**
+  Helper class that is used for the result of DICOMDatasetAccess::GetTagValueAsString
+   */
+  struct MITKDICOMREADER_EXPORT DICOMDatasetFinding
+  {
+    std::string value;
+    /**Indicates if value is valid or not.*/
+    bool isValid;
+
+    DICOMDatasetFinding() : isValid(false), value("")
+    {};
+  };
 
 /**
   \ingroup DICOMReaderModule
   \brief Interface to datasets that is presented to sorting classes such as DICOMDatasetSorter.
 
   Minimal interface to hide actual implementation, which might rely on GDCM.
 */
 class MITKDICOMREADER_EXPORT DICOMDatasetAccess
 {
   public:
 
     /// \brief Return a filename if possible.
     /// If DICOM is not read from file but from somewhere else (network, database), we might not have files.
     virtual std::string GetFilenameIfAvailable() const = 0;
 
-    /// \brief Return the raw value of the tag as a string
-    virtual std::string GetTagValueAsString(const mitk::DICOMTag& tag) const = 0;
+    /** \brief Return the raw value of the tag as a string.
+    \param tag Tag which value should be retreived.
+    */
+    virtual DICOMDatasetFinding GetTagValueAsString(const DICOMTag& tag) const = 0;
 
     virtual ~DICOMDatasetAccess() {};
 };
 
 
 typedef std::vector<DICOMDatasetAccess*> DICOMDatasetList;
 
 }
 
 #endif
diff --git a/Modules/DICOMReader/include/mitkDICOMGDCMImageFrameInfo.h b/Modules/DICOMReader/include/mitkDICOMGDCMImageFrameInfo.h
index 07d21bd2ea..7cce89dd94 100644
--- a/Modules/DICOMReader/include/mitkDICOMGDCMImageFrameInfo.h
+++ b/Modules/DICOMReader/include/mitkDICOMGDCMImageFrameInfo.h
@@ -1,71 +1,71 @@
 /*===================================================================
 
 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 mitkDICOMGDCMImageFrameInfo_h
 #define mitkDICOMGDCMImageFrameInfo_h
 
 #include "mitkDICOMImageFrameInfo.h"
 #include "mitkDICOMDatasetAccess.h"
 
 #include "gdcmScanner.h"
 
 namespace mitk
 {
   /**
     \ingroup DICOMReaderModule
     \brief The dataset access implementation for DICOMITKSeriesGDCMReader, based on GDCM.
 
     This class combines a DICOMImageFrameInfo object with the scanning results
     from gdcm::Scanner. The scanning results will be used to implement the tag
     access methods of DICOMDatasetAccess.
   */
   class MITKDICOMREADER_EXPORT DICOMGDCMImageFrameInfo : public itk::LightObject, public DICOMDatasetAccess
   {
     public:
 
       mitkClassMacroItkParent(DICOMGDCMImageFrameInfo, itk::LightObject);
       itkNewMacro( DICOMGDCMImageFrameInfo );
       mitkNewMacro1Param( DICOMGDCMImageFrameInfo, const std::string&);
       mitkNewMacro2Param( DICOMGDCMImageFrameInfo, const std::string&, unsigned int );
       mitkNewMacro1Param( DICOMGDCMImageFrameInfo, DICOMImageFrameInfo::Pointer);
       mitkNewMacro2Param( DICOMGDCMImageFrameInfo, DICOMImageFrameInfo::Pointer, gdcm::Scanner::TagToValue const&);
 
       virtual ~DICOMGDCMImageFrameInfo();
 
-      virtual std::string GetTagValueAsString(const DICOMTag&) const override;
+      virtual DICOMDatasetFinding GetTagValueAsString(const DICOMTag&) const override;
 
       std::string GetFilenameIfAvailable() const override;
 
       /// The frame that this objects refers to
       DICOMImageFrameInfo::Pointer GetFrameInfo() const;
       /// The frame that this objects refers to
       void SetFrameInfo(DICOMImageFrameInfo::Pointer frameinfo);
 
     protected:
 
       DICOMImageFrameInfo::Pointer m_FrameInfo;
 
       DICOMGDCMImageFrameInfo(DICOMImageFrameInfo::Pointer frameinfo);
       DICOMGDCMImageFrameInfo(DICOMImageFrameInfo::Pointer frameinfo, gdcm::Scanner::TagToValue const& tagToValueMapping);
       DICOMGDCMImageFrameInfo(const std::string& filename = "", unsigned int frameNo = 0);
 
       const gdcm::Scanner::TagToValue m_TagForValue;
   };
 
   typedef std::vector<DICOMGDCMImageFrameInfo::Pointer> DICOMGDCMImageFrameList;
 }
 
 #endif
diff --git a/Modules/DICOMReader/include/mitkDICOMGDCMTagScanner.h b/Modules/DICOMReader/include/mitkDICOMGDCMTagScanner.h
index d975f44cce..cb35c334cf 100644
--- a/Modules/DICOMReader/include/mitkDICOMGDCMTagScanner.h
+++ b/Modules/DICOMReader/include/mitkDICOMGDCMTagScanner.h
@@ -1,107 +1,107 @@
 /*===================================================================
 
 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 mitkDICOMGDCMTagScanner_h
 #define mitkDICOMGDCMTagScanner_h
 
 #include "mitkDICOMTagCache.h"
 #include "mitkDICOMEnums.h"
 
 #include "mitkDICOMGDCMImageFrameInfo.h"
 
 #include <gdcmScanner.h>
 
 namespace mitk
 {
 
   /**
     \ingroup DICOMReaderModule
     \brief Encapsulates the tag scanning process for a set of DICOM files.
 
     Formerly integrated as a part of DICOMITKSeriesGDCMReader, the tag
     scanning part has been factored out into this DICOMGDCMTagScanner class
     in order to allow a single scan for multiple reader alternatives. This
     helps much in the selection process of e.g. DICOMFileReaderSelector.
 
     The class works similar to gdcm::Scanner, just with the MITK set of classes:
      - add a number of DICOM tags that should be read
      - set a list of files that should be scanned for named tags
      - call Scan()
      - retrieve the scan results
        - via GetFrameInfoList() or
        - via GetTagValue()
 
     When used in a process where multiple classes will access the scan
     results, care should be taken that all the tags and files of interest
     are communicated to DICOMGDCMTagScanner before requesting the results!
   */
   class MITKDICOMREADER_EXPORT DICOMGDCMTagScanner : public DICOMTagCache
   {
     public:
 
       mitkClassMacro( DICOMGDCMTagScanner, DICOMTagCache );
       itkFactorylessNewMacro( DICOMGDCMTagScanner );
       itkCloneMacro(Self);
 
       /**
         \brief Add this tag to the scanning process.
       */
       virtual void AddTag(const DICOMTag& tag);
       /**
         \brief Add a list of tags to the scanning process.
       */
       virtual void AddTags(const DICOMTagList& tags);
 
       /**
         \brief Define the list of files to scan.
         This does not ADD to an internal list, but it replaces the
         whole list of files.
       */
       virtual void SetInputFiles(const StringList& filenames);
 
       /**
         \brief Start the scanning process.
         Calling Scan() will invalidate previous scans, forgetting
         all about files and tags from files that have been scanned
         previously.
       */
       virtual void Scan();
 
       /**
         \brief Retrieve a result list for file-by-file tag access.
       */
       virtual DICOMGDCMImageFrameList GetFrameInfoList() const;
 
       /**
         \brief Directly retrieve the tag value for a given frame and tag.
       */
-      virtual std::string GetTagValue(DICOMImageFrameInfo* frame, const DICOMTag& tag) const override;
+      virtual DICOMDatasetFinding GetTagValue(DICOMImageFrameInfo* frame, const DICOMTag& tag) const override;
 
       protected:
 
       DICOMGDCMTagScanner();
       DICOMGDCMTagScanner(const DICOMGDCMTagScanner&);
       virtual ~DICOMGDCMTagScanner();
 
       std::set<DICOMTag> m_ScannedTags;
 
       gdcm::Scanner m_GDCMScanner;
       StringList m_InputFilenames;
       DICOMGDCMImageFrameList m_ScanResult;
   };
 }
 
 #endif
diff --git a/Modules/DICOMReader/include/mitkDICOMTagCache.h b/Modules/DICOMReader/include/mitkDICOMTagCache.h
index 1684ac3a06..4c74493c60 100644
--- a/Modules/DICOMReader/include/mitkDICOMTagCache.h
+++ b/Modules/DICOMReader/include/mitkDICOMTagCache.h
@@ -1,52 +1,53 @@
 /*===================================================================
 
 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 mitkDICOMTagCache_h
 #define mitkDICOMTagCache_h
 
 #include "itkObjectFactory.h"
 #include "mitkCommon.h"
 
 #include "mitkDICOMTag.h"
+#include "mitkDICOMDatasetAccess.h"
 
 #include "MitkDICOMReaderExports.h"
 
 namespace mitk
 {
 
   class DICOMImageFrameInfo;
 
   /**
     \ingroup DICOMReaderModule
     \brief ...
   */
   class MITKDICOMREADER_EXPORT DICOMTagCache : public itk::Object
   {
     public:
 
       mitkClassMacroItkParent( DICOMTagCache, itk::Object );
 
-      virtual std::string GetTagValue(DICOMImageFrameInfo* frame, const DICOMTag& tag) const = 0;
+      virtual DICOMDatasetFinding GetTagValue(DICOMImageFrameInfo* frame, const DICOMTag& tag) const = 0;
 
       protected:
 
       DICOMTagCache();
       DICOMTagCache(const DICOMTagCache&);
       virtual ~DICOMTagCache();
   };
 }
 
 #endif
diff --git a/Modules/DICOMReader/src/mitkDICOMGDCMImageFrameInfo.cpp b/Modules/DICOMReader/src/mitkDICOMGDCMImageFrameInfo.cpp
index c38ee1fd75..8b3d8f709c 100644
--- a/Modules/DICOMReader/src/mitkDICOMGDCMImageFrameInfo.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMGDCMImageFrameInfo.cpp
@@ -1,119 +1,126 @@
 /*===================================================================
 
   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 "mitkDICOMGDCMImageFrameInfo.h"
 
 mitk::DICOMGDCMImageFrameInfo
 ::DICOMGDCMImageFrameInfo(const std::string& filename, unsigned int frameNo)
 :itk::LightObject()
 ,m_FrameInfo( DICOMImageFrameInfo::New(filename, frameNo) )
 ,m_TagForValue()
 {
 }
 
 mitk::DICOMGDCMImageFrameInfo
 ::DICOMGDCMImageFrameInfo(DICOMImageFrameInfo::Pointer frameinfo)
 :itk::LightObject()
 ,m_FrameInfo(frameinfo)
 ,m_TagForValue()
 {
 }
 
 mitk::DICOMGDCMImageFrameInfo
 ::DICOMGDCMImageFrameInfo(DICOMImageFrameInfo::Pointer frameinfo, gdcm::Scanner::TagToValue const& tagToValueMapping)
 :itk::LightObject()
 ,m_FrameInfo(frameinfo)
 ,m_TagForValue(tagToValueMapping)
 {
 }
 
 mitk::DICOMGDCMImageFrameInfo::
 ~DICOMGDCMImageFrameInfo()
 {
 }
 
-std::string
+mitk::DICOMDatasetFinding
 mitk::DICOMGDCMImageFrameInfo
 ::GetTagValueAsString(const DICOMTag& tag) const
 {
   const auto mappedValue = m_TagForValue.find( gdcm::Tag(tag.GetGroup(), tag.GetElement()) );
+  DICOMDatasetFinding result;
 
   if (mappedValue != m_TagForValue.cend())
   {
+    result.isValid = true;
+
     if (mappedValue->second != nullptr)
     {
       std::string s(mappedValue->second);
       try
       {
-        return s.erase(s.find_last_not_of(" \n\r\t")+1);
+        result.value = s.erase(s.find_last_not_of(" \n\r\t")+1);
       }
       catch(...)
       {
-        return s;
+        result.value = s;
       }
     }
     else
     {
-      return std::string("");
+      result.value = "";
     }
   }
   else
   {
     const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
     const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
 
     if (tag == tagImagePositionPatient)
     {
-      return std::string("0\\0\\0");
+      result.isValid = true;
+      result.value = std::string("0\\0\\0");
     }
     else if (tag == tagImageOrientation)
     {
-      return std::string("1\\0\\0\\0\\1\\0");
+      result.isValid = true;
+      result.value = std::string("1\\0\\0\\0\\1\\0");
     }
     else
     {
-      return std::string("");
+      result.isValid = false;
+      result.value = "";
     }
   }
+  return result;
 }
 
 std::string
 mitk::DICOMGDCMImageFrameInfo
 ::GetFilenameIfAvailable() const
 {
   if (m_FrameInfo.IsNotNull())
   {
     return m_FrameInfo->Filename;
   }
   else
   {
     return std::string("");
   }
 }
 
 mitk::DICOMImageFrameInfo::Pointer
 mitk::DICOMGDCMImageFrameInfo
 ::GetFrameInfo() const
 {
   return m_FrameInfo;
 }
 
 void
   mitk::DICOMGDCMImageFrameInfo
 ::SetFrameInfo(DICOMImageFrameInfo::Pointer frameinfo)
 {
   m_FrameInfo = frameinfo;
 }
diff --git a/Modules/DICOMReader/src/mitkDICOMGDCMTagScanner.cpp b/Modules/DICOMReader/src/mitkDICOMGDCMTagScanner.cpp
index a7f82066ab..5c69034198 100644
--- a/Modules/DICOMReader/src/mitkDICOMGDCMTagScanner.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMGDCMTagScanner.cpp
@@ -1,116 +1,123 @@
 /*===================================================================
 
 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 "mitkDICOMGDCMTagScanner.h"
 
 mitk::DICOMGDCMTagScanner::DICOMGDCMTagScanner()
 {
 }
 
 mitk::DICOMGDCMTagScanner::DICOMGDCMTagScanner( const DICOMGDCMTagScanner& other )
 : DICOMTagCache( other )
 {
 }
 
 mitk::DICOMGDCMTagScanner::~DICOMGDCMTagScanner()
 {
 }
 
-std::string mitk::DICOMGDCMTagScanner::GetTagValue( DICOMImageFrameInfo* frame, const DICOMTag& tag ) const
+mitk::DICOMDatasetFinding mitk::DICOMGDCMTagScanner::GetTagValue( DICOMImageFrameInfo* frame, const DICOMTag& tag ) const
 {
   assert( frame );
 
   for ( auto frameIter = m_ScanResult.cbegin(); frameIter != m_ScanResult.cend(); ++frameIter )
   {
     if ( ( *frameIter )->GetFrameInfo().IsNotNull() && ( *( ( *frameIter )->GetFrameInfo() ) == *frame ) )
     {
-      return ( *frameIter )->GetTagValueAsString( tag );
+      return (*frameIter)->GetTagValueAsString(tag);
     }
   }
 
   if ( m_ScannedTags.find( tag ) != m_ScannedTags.cend() )
   {
     if ( std::find( m_InputFilenames.cbegin(), m_InputFilenames.cend(), frame->Filename )
          != m_InputFilenames.cend() )
     {
       // precondition of gdcm::Scanner::GetValue() fulfilled
-      return m_GDCMScanner.GetValue( frame->Filename.c_str(), gdcm::Tag( tag.GetGroup(), tag.GetElement() ) );
+      const char* value = m_GDCMScanner.GetValue( frame->Filename.c_str(), gdcm::Tag( tag.GetGroup(), tag.GetElement() ) );
+      DICOMDatasetFinding result;
+      if (value)
+      {
+        result.isValid = true;
+        result.value = value;
+      }
+      return result;
     }
     else
     {
       // callers are required to tell us about the filenames they are interested in
       // this is a helpful reminder for them to inform us
       std::stringstream errorstring;
       errorstring << "Invalid call to DICOMGDCMTagScanner::GetTagValue( "
                   << "'" << frame->Filename << "', frame " << frame->FrameNo
                   << " ). Filename was never mentioned before!";
       MITK_ERROR << errorstring.str();
       throw std::invalid_argument( errorstring.str() );
     }
   }
   else
   {
     // callers are required to tell us about the tags they are interested in
     // this is a helpful reminder for them to inform us
     std::stringstream errorstring;
     errorstring << "Invalid call to DICOMGDCMTagScanner::GetTagValue( ";
     tag.Print( errorstring );
     errorstring << " ). Tag was never mentioned before!";
     MITK_ERROR << errorstring.str();
     throw std::invalid_argument( errorstring.str() );
   }
 }
 
 void mitk::DICOMGDCMTagScanner::AddTag( const DICOMTag& tag )
 {
   m_ScannedTags.insert( tag );
   m_GDCMScanner.AddTag(
     gdcm::Tag( tag.GetGroup(), tag.GetElement() ) ); // also a set, duplicate calls to AddTag don't hurt
 }
 
 void mitk::DICOMGDCMTagScanner::AddTags( const DICOMTagList& tags )
 {
   for ( auto tagIter = tags.cbegin(); tagIter != tags.cend(); ++tagIter )
   {
     this->AddTag( *tagIter );
   }
 }
 
 void mitk::DICOMGDCMTagScanner::SetInputFiles( const StringList& filenames )
 {
   m_InputFilenames = filenames;
 }
 
 
 void mitk::DICOMGDCMTagScanner::Scan()
 {
   // TODO integrate push/pop locale??
   m_GDCMScanner.Scan( m_InputFilenames );
 
   m_ScanResult.clear();
   m_ScanResult.reserve( m_InputFilenames.size() );
 
   for ( auto inputIter = m_InputFilenames.cbegin(); inputIter != m_InputFilenames.cend(); ++inputIter )
   {
     m_ScanResult.push_back( DICOMGDCMImageFrameInfo::New( DICOMImageFrameInfo::New( *inputIter, 0 ),
                                                           m_GDCMScanner.GetMapping( inputIter->c_str() ) ) );
   }
 }
 
 mitk::DICOMGDCMImageFrameList mitk::DICOMGDCMTagScanner::GetFrameInfoList() const
 {
   return m_ScanResult;
 }
diff --git a/Modules/DICOMReader/src/mitkDICOMImageBlockDescriptor.cpp b/Modules/DICOMReader/src/mitkDICOMImageBlockDescriptor.cpp
index 95ae7a2d38..4af316bbc2 100644
--- a/Modules/DICOMReader/src/mitkDICOMImageBlockDescriptor.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMImageBlockDescriptor.cpp
@@ -1,807 +1,810 @@
 /*===================================================================
 
 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 "mitkDICOMImageBlockDescriptor.h"
 #include "mitkStringProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include <gdcmUIDs.h>
 
 mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor()
 : m_ReaderImplementationLevel( SOPClassUnknown )
 , m_PropertyList( PropertyList::New() )
 , m_TagCache( nullptr )
 , m_PropertiesOutOfDate( true )
 {
   m_PropertyFunctor = &mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues;
 }
 
 mitk::DICOMImageBlockDescriptor::~DICOMImageBlockDescriptor()
 {
 }
 
 mitk::DICOMImageBlockDescriptor::DICOMImageBlockDescriptor( const DICOMImageBlockDescriptor& other )
 : m_ImageFrameList( other.m_ImageFrameList )
 , m_MitkImage( other.m_MitkImage )
 , m_SliceIsLoaded( other.m_SliceIsLoaded )
 , m_ReaderImplementationLevel( other.m_ReaderImplementationLevel )
 , m_TiltInformation( other.m_TiltInformation )
 , m_PropertyList( other.m_PropertyList->Clone() )
 , m_TagCache( other.m_TagCache )
 , m_PropertiesOutOfDate( other.m_PropertiesOutOfDate )
 , m_AdditionalTagList( other.m_AdditionalTagList )
 , m_PropertyFunctor( other.m_PropertyFunctor )
 {
   if ( m_MitkImage )
   {
     m_MitkImage = m_MitkImage->Clone();
   }
 
   m_PropertyFunctor = &mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues;
 }
 
 mitk::DICOMImageBlockDescriptor& mitk::DICOMImageBlockDescriptor::
   operator=( const DICOMImageBlockDescriptor& other )
 {
   if ( this != &other )
   {
     m_ImageFrameList            = other.m_ImageFrameList;
     m_MitkImage                 = other.m_MitkImage;
     m_SliceIsLoaded             = other.m_SliceIsLoaded;
     m_ReaderImplementationLevel = other.m_ReaderImplementationLevel;
     m_TiltInformation           = other.m_TiltInformation;
 
     m_AdditionalTagList = other.m_AdditionalTagList;
     m_PropertyFunctor = other.m_PropertyFunctor;
 
     if ( other.m_PropertyList )
     {
       m_PropertyList = other.m_PropertyList->Clone();
     }
 
     if ( other.m_MitkImage )
     {
       m_MitkImage = other.m_MitkImage->Clone();
     }
 
     m_TagCache            = other.m_TagCache;
     m_PropertiesOutOfDate = other.m_PropertiesOutOfDate;
   }
   return *this;
 }
 
 mitk::DICOMTagList mitk::DICOMImageBlockDescriptor::GetTagsOfInterest()
 {
   DICOMTagList completeList;
 
   completeList.push_back( DICOMTag( 0x0018, 0x1164 ) ); // pixel spacing
   completeList.push_back( DICOMTag( 0x0028, 0x0030 ) ); // imager pixel spacing
 
   completeList.push_back( DICOMTag( 0x0008, 0x0018 ) ); // sop instance UID
   completeList.push_back( DICOMTag( 0x0008, 0x0016 ) ); // sop class UID
 
   completeList.push_back( DICOMTag( 0x0020, 0x0011 ) ); // series number
   completeList.push_back( DICOMTag( 0x0008, 0x1030 ) ); // study description
   completeList.push_back( DICOMTag( 0x0008, 0x103e ) ); // series description
   completeList.push_back( DICOMTag( 0x0008, 0x0060 ) ); // modality
   completeList.push_back( DICOMTag( 0x0018, 0x0024 ) ); // sequence name
   completeList.push_back( DICOMTag( 0x0020, 0x0037 ) ); // image orientation
 
   completeList.push_back( DICOMTag( 0x0020, 0x1041 ) ); // slice location
   completeList.push_back( DICOMTag( 0x0020, 0x0012 ) ); // acquisition number
   completeList.push_back( DICOMTag( 0x0020, 0x0013 ) ); // instance number
   completeList.push_back( DICOMTag( 0x0020, 0x0032 ) ); // image position patient
 
   completeList.push_back( DICOMTag( 0x0028, 0x1050 ) ); // window center
   completeList.push_back( DICOMTag( 0x0028, 0x1051 ) ); // window width
   completeList.push_back( DICOMTag( 0x0008, 0x0008 ) ); // image type
   completeList.push_back( DICOMTag( 0x0028, 0x0004 ) ); // photometric interpretation
 
   return completeList;
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetAdditionalTagsOfInterest(
   const std::unordered_map<const char*, mitk::DICOMTag>& tagList )
 {
   m_AdditionalTagList = tagList;
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetTiltInformation( const GantryTiltInformation& info )
 {
   m_TiltInformation = info;
 }
 
 const mitk::GantryTiltInformation mitk::DICOMImageBlockDescriptor::GetTiltInformation() const
 {
   return m_TiltInformation;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetImageFrameList( const DICOMImageFrameList& framelist )
 {
   m_ImageFrameList = framelist;
   m_SliceIsLoaded.resize( framelist.size() );
   m_SliceIsLoaded.assign( framelist.size(), false );
 
   m_PropertiesOutOfDate = true;
 }
 
 const mitk::DICOMImageFrameList& mitk::DICOMImageBlockDescriptor::GetImageFrameList() const
 {
   return m_ImageFrameList;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetMitkImage( Image::Pointer image )
 {
   if ( m_MitkImage != image )
   {
     if ( m_TagCache.IsNull() )
     {
       MITK_ERROR << "Unable to describe MITK image with properties without a tag-cache object!";
       m_MitkImage = nullptr;
       return;
     }
 
     if ( m_ImageFrameList.empty() )
     {
       MITK_ERROR << "Unable to describe MITK image with properties without a frame list!";
       m_MitkImage = nullptr;
       return;
     }
 
     // Should verify that the image matches m_ImageFrameList and m_TagCache
     // however, this is hard to do without re-analyzing all
     // TODO we should at least make sure that the number of frames is identical (plus rows/columns,
     // orientation)
     //      without gantry tilt correction, we can also check image origin
 
     m_MitkImage = this->DescribeImageWithProperties( this->FixupSpacing( image ) );
   }
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::GetMitkImage() const
 {
   return m_MitkImage;
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::FixupSpacing( Image* mitkImage )
 {
   if ( mitkImage )
   {
     Vector3D imageSpacing = mitkImage->GetGeometry()->GetSpacing();
 
     ScalarType desiredSpacingX = imageSpacing[0];
     ScalarType desiredSpacingY = imageSpacing[1];
     this->GetDesiredMITKImagePixelSpacing(
       desiredSpacingX, desiredSpacingY ); // prefer pixel spacing over imager pixel spacing
 
     if ( desiredSpacingX <= 0 || desiredSpacingY <= 0 )
     {
       return mitkImage;
     }
 
     MITK_DEBUG << "Loaded image with spacing " << imageSpacing[0] << ", " << imageSpacing[1];
     MITK_DEBUG << "Found correct spacing info " << desiredSpacingX << ", " << desiredSpacingY;
 
     imageSpacing[0] = desiredSpacingX;
     imageSpacing[1] = desiredSpacingY;
     mitkImage->GetGeometry()->SetSpacing( imageSpacing );
   }
 
   return mitkImage;
 }
 void mitk::DICOMImageBlockDescriptor::SetSliceIsLoaded( unsigned int index, bool isLoaded )
 {
   if ( index < m_SliceIsLoaded.size() )
   {
     m_SliceIsLoaded[index] = isLoaded;
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool mitk::DICOMImageBlockDescriptor::IsSliceLoaded( unsigned int index ) const
 {
   if ( index < m_SliceIsLoaded.size() )
   {
     return m_SliceIsLoaded[index];
   }
   else
   {
     std::stringstream ss;
     ss << "Index " << index << " out of range (" << m_SliceIsLoaded.size() << " indices reserved)";
     throw std::invalid_argument( ss.str() );
   }
 }
 
 bool mitk::DICOMImageBlockDescriptor::AllSlicesAreLoaded() const
 {
   bool allLoaded = true;
   for ( auto iter = m_SliceIsLoaded.cbegin(); iter != m_SliceIsLoaded.cend(); ++iter )
   {
     allLoaded &= *iter;
   }
 
   return allLoaded;
 }
 
 /*
    PS defined      IPS defined     PS==IPS
         0               0                     --> UNKNOWN spacing, loader will invent
         0               1                     --> spacing as at detector surface
         1               0                     --> spacing as in patient
         1               1             0       --> detector surface spacing CORRECTED for geometrical
    magnifications: spacing as in patient
         1               1             1       --> detector surface spacing NOT corrected for geometrical
    magnifications: spacing as at detector
 */
 mitk::PixelSpacingInterpretation mitk::DICOMImageBlockDescriptor::GetPixelSpacingInterpretation() const
 {
   if ( m_ImageFrameList.empty() || m_TagCache.IsNull() )
   {
     MITK_ERROR << "Invalid call to GetPixelSpacingInterpretation. Need to have initialized tag-cache!";
     return SpacingUnknown;
   }
 
   const std::string pixelSpacing       = this->GetPixelSpacing();
   const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
 
   if ( pixelSpacing.empty() )
   {
     if ( imagerPixelSpacing.empty() )
     {
       return SpacingUnknown;
     }
     else
     {
       return SpacingAtDetector;
     }
   }
   else // Pixel Spacing defined
   {
     if ( imagerPixelSpacing.empty() )
     {
       return SpacingInPatient;
     }
     else if ( pixelSpacing != imagerPixelSpacing )
     {
       return SpacingInPatient;
     }
     else
     {
       return SpacingAtDetector;
     }
   }
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetPixelSpacing() const
 {
   if ( m_ImageFrameList.empty() || m_TagCache.IsNull() )
   {
     MITK_ERROR << "Invalid call to GetPixelSpacing. Need to have initialized tag-cache!";
     return std::string( "" );
   }
 
   static const DICOMTag tagPixelSpacing( 0x0028, 0x0030 );
-  return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing );
+  return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagPixelSpacing ).value;
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetImagerPixelSpacing() const
 {
   if ( m_ImageFrameList.empty() || m_TagCache.IsNull() )
   {
     MITK_ERROR << "Invalid call to GetImagerPixelSpacing. Need to have initialized tag-cache!";
     return std::string( "" );
   }
 
   static const DICOMTag tagImagerPixelSpacing( 0x0018, 0x1164 );
-  return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing );
+  return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagImagerPixelSpacing ).value;
 }
 
 void mitk::DICOMImageBlockDescriptor::GetDesiredMITKImagePixelSpacing( ScalarType& spacingX,
                                                                        ScalarType& spacingY ) const
 {
   const std::string pixelSpacing = this->GetPixelSpacing();
   // preference for "in patient" pixel spacing
   if ( !DICOMStringToSpacing( pixelSpacing, spacingX, spacingY ) )
   {
     const std::string imagerPixelSpacing = this->GetImagerPixelSpacing();
     // fallback to "on detector" spacing
     if ( !DICOMStringToSpacing( imagerPixelSpacing, spacingX, spacingY ) )
     {
       // last resort: invent something
       spacingX = spacingY = 1.0;
     }
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetProperty( const std::string& key, BaseProperty* value )
 {
   m_PropertyList->SetProperty( key, value );
 }
 
 mitk::BaseProperty* mitk::DICOMImageBlockDescriptor::GetProperty( const std::string& key ) const
 {
   this->UpdateImageDescribingProperties();
   return m_PropertyList->GetProperty( key );
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetPropertyAsString( const std::string& key ) const
 {
   this->UpdateImageDescribingProperties();
   const mitk::BaseProperty::Pointer property = m_PropertyList->GetProperty( key );
   if ( property.IsNotNull() )
   {
     return property->GetValueAsString();
   }
   else
   {
     return std::string( "" );
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetFlag( const std::string& key, bool value )
 {
   m_PropertyList->ReplaceProperty( key, BoolProperty::New( value ) );
 }
 
 bool mitk::DICOMImageBlockDescriptor::GetFlag( const std::string& key, bool defaultValue ) const
 {
   this->UpdateImageDescribingProperties();
   BoolProperty::ConstPointer boolProp = dynamic_cast<BoolProperty*>( this->GetProperty( key ) );
   if ( boolProp.IsNotNull() )
   {
     return boolProp->GetValue();
   }
   else
   {
     return defaultValue;
   }
 }
 
 void mitk::DICOMImageBlockDescriptor::SetIntProperty( const std::string& key, int value )
 {
   m_PropertyList->ReplaceProperty( key, IntProperty::New( value ) );
 }
 
 int mitk::DICOMImageBlockDescriptor::GetIntProperty( const std::string& key, int defaultValue ) const
 {
   this->UpdateImageDescribingProperties();
   IntProperty::ConstPointer intProp = dynamic_cast<IntProperty*>( this->GetProperty( key ) );
   if ( intProp.IsNotNull() )
   {
     return intProp->GetValue();
   }
   else
   {
     return defaultValue;
   }
 }
 
 double mitk::DICOMImageBlockDescriptor::stringtodouble( const std::string& str ) const
 {
   double d;
   std::string trimmedstring( str );
   try
   {
     trimmedstring = trimmedstring.erase( trimmedstring.find_last_not_of( " \n\r\t" ) + 1 );
   }
   catch ( ... )
   {
     // no last not of
   }
 
   std::string firstcomponent( trimmedstring );
   try
   {
     firstcomponent = trimmedstring.erase( trimmedstring.find_first_of( "\\" ) );
   }
   catch ( ... )
   {
     // no last not of
   }
 
   std::istringstream converter( firstcomponent );
   if ( !firstcomponent.empty() && ( converter >> d ) && converter.eof() )
   {
     return d;
   }
   else
   {
     throw std::invalid_argument( "Argument is not a convertable number" );
   }
 }
 
 mitk::Image::Pointer mitk::DICOMImageBlockDescriptor::DescribeImageWithProperties( Image* mitkImage )
 {
   // TODO: this is a collection of properties that have been provided by the
   // legacy DicomSeriesReader.
   // We should at some point clean up this collection and name them in a more
   // consistent way!
 
   if ( !mitkImage )
     return mitkImage;
 
   // first part: add some tags that describe individual slices
   // these propeties are defined at analysis time (see UpdateImageDescribingProperties())
 
   const std::string propertyKeySliceLocation  = "dicom.image.0020.1041";
   const std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
   const std::string propertyKeySOPInstanceUID = "dicom.image.0008.0018";
 
   mitkImage->SetProperty( propertyKeySliceLocation.c_str(), this->GetProperty( "sliceLocationForSlices" ) );
   mitkImage->SetProperty( propertyKeyInstanceNumber.c_str(), this->GetProperty( "instanceNumberForSlices" ) );
   mitkImage->SetProperty( propertyKeySOPInstanceUID.c_str(), this->GetProperty( "SOPInstanceUIDForSlices" ) );
   mitkImage->SetProperty( "files", this->GetProperty( "filenamesForSlices" ) );
 
   for ( auto iter = m_AdditionalTagList.cbegin(); iter != m_AdditionalTagList.cend(); ++iter )
   {
     mitkImage->SetProperty( iter->first, this->GetProperty( iter->first ) );
   }
 
 
   // second part: add properties that describe the whole image block
   mitkImage->SetProperty( "dicomseriesreader.SOPClassUID", StringProperty::New( this->GetSOPClassUID() ) );
 
   mitkImage->SetProperty( "dicomseriesreader.SOPClass", StringProperty::New( this->GetSOPClassUIDAsName() ) );
 
   mitkImage->SetProperty(
     "dicomseriesreader.PixelSpacingInterpretationString",
     StringProperty::New( PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) ) );
   mitkImage->SetProperty(
     "dicomseriesreader.PixelSpacingInterpretation",
     GenericProperty<PixelSpacingInterpretation>::New( this->GetPixelSpacingInterpretation() ) );
 
   mitkImage->SetProperty(
     "dicomseriesreader.ReaderImplementationLevelString",
     StringProperty::New( ReaderImplementationLevelToString( m_ReaderImplementationLevel ) ) );
 
   mitkImage->SetProperty( "dicomseriesreader.ReaderImplementationLevel",
                           GenericProperty<ReaderImplementationLevel>::New( m_ReaderImplementationLevel ) );
 
   mitkImage->SetProperty( "dicomseriesreader.GantyTiltCorrected",
                           BoolProperty::New( this->GetTiltInformation().IsRegularGantryTilt() ) );
 
   mitkImage->SetProperty( "dicomseriesreader.3D+t", BoolProperty::New( this->GetFlag( "3D+t", false ) ) );
 
   // level window
   const std::string windowCenter = this->GetPropertyAsString( "windowCenter" );
   const std::string windowWidth  = this->GetPropertyAsString( "windowWidth" );
   try
   {
     const double level  = stringtodouble( windowCenter );
     const double window = stringtodouble( windowWidth );
     mitkImage->SetProperty( "levelwindow", LevelWindowProperty::New( LevelWindow( level, window ) ) );
   }
   catch ( ... )
   {
     // nothing, no levelwindow to be predicted...
   }
 
   const std::string modality = this->GetPropertyAsString( "modality" );
   mitkImage->SetProperty( "modality", StringProperty::New( modality ) );
 
   mitkImage->SetProperty( "dicom.pixel.PhotometricInterpretation",
                           this->GetProperty( "photometricInterpretation" ) );
   mitkImage->SetProperty( "dicom.image.imagetype", this->GetProperty( "imagetype" ) );
 
   mitkImage->SetProperty( "dicom.study.StudyDescription", this->GetProperty( "studyDescription" ) );
   mitkImage->SetProperty( "dicom.series.SeriesDescription", this->GetProperty( "seriesDescription" ) );
 
   mitkImage->SetProperty( "dicom.pixel.Rows", this->GetProperty( "rows" ) );
   mitkImage->SetProperty( "dicom.pixel.Columns", this->GetProperty( "columns" ) );
 
 
   // third part: get something from ImageIO. BUT this needs to be created elsewhere. or not at all!
 
   return mitkImage;
 }
 
 void mitk::DICOMImageBlockDescriptor::SetReaderImplementationLevel( const ReaderImplementationLevel& level )
 {
   m_ReaderImplementationLevel = level;
 }
 
 mitk::ReaderImplementationLevel mitk::DICOMImageBlockDescriptor::GetReaderImplementationLevel() const
 {
   return m_ReaderImplementationLevel;
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUID() const
 {
   if ( !m_ImageFrameList.empty() && m_TagCache.IsNotNull() )
   {
     static const DICOMTag tagSOPClassUID( 0x0008, 0x0016 );
-    return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID );
+    return m_TagCache->GetTagValue( m_ImageFrameList.front(), tagSOPClassUID ).value;
   }
   else
   {
     MITK_ERROR
       << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUID(). Need to have initialized tag-cache!";
     return std::string( "" );
   }
 }
 
 std::string mitk::DICOMImageBlockDescriptor::GetSOPClassUIDAsName() const
 {
   if ( !m_ImageFrameList.empty() && m_TagCache.IsNotNull() )
   {
     gdcm::UIDs uidKnowledge;
     uidKnowledge.SetFromUID( this->GetSOPClassUID().c_str() );
 
     const char* name = uidKnowledge.GetName();
     if ( name )
     {
       return std::string( name );
     }
     else
     {
       return std::string( "" );
     }
   }
   else
   {
     MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::GetSOPClassUIDAsName(). Need to have "
                   "initialized tag-cache!";
     return std::string( "" );
   }
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetTagCache( DICOMTagCache* privateCache )
 {
   // this must only be used during loading and never afterwards
   m_TagCache = privateCache;
 }
 
 #define printPropertyRange( label, property_name )                                 \
   \
 {                                                                             \
     const std::string first = this->GetPropertyAsString( #property_name "First" ); \
     const std::string last  = this->GetPropertyAsString( #property_name "Last" );  \
     if ( !first.empty() || !last.empty() )                                         \
     {                                                                              \
       if ( first == last )                                                         \
       {                                                                            \
         os << "  " label ": '" << first << "'" << std::endl;                       \
       }                                                                            \
       else                                                                         \
       {                                                                            \
         os << "  " label ": '" << first << "' - '" << last << "'" << std::endl;    \
       }                                                                            \
     }                                                                              \
   \
 }
 
 #define printProperty( label, property_name )                              \
   \
 {                                                                     \
     const std::string first = this->GetPropertyAsString( #property_name ); \
     if ( !first.empty() )                                                  \
     {                                                                      \
       os << "  " label ": '" << first << "'" << std::endl;                 \
     }                                                                      \
   \
 }
 
 #define printBool( label, commands )                                           \
   \
 {                                                                         \
     os << "  " label ": '" << ( commands ? "yes" : "no" ) << "'" << std::endl; \
   \
 }
 
 
 
 
 void mitk::DICOMImageBlockDescriptor::Print(std::ostream& os, bool filenameDetails) const
 {
   os << "  Number of Frames: '" << m_ImageFrameList.size() << "'" << std::endl;
   os << "  SOP class: '" << this->GetSOPClassUIDAsName() << "'" << std::endl;
 
   printProperty( "Series Number", seriesNumber );
   printProperty( "Study Description", studyDescription );
   printProperty( "Series Description", seriesDescription );
   printProperty( "Modality", modality );
   printProperty( "Sequence Name", sequenceName );
 
   printPropertyRange( "Slice Location", sliceLocation );
   printPropertyRange( "Acquisition Number", acquisitionNumber );
   printPropertyRange( "Instance Number", instanceNumber );
   printPropertyRange( "Image Position", imagePositionPatient );
   printProperty( "Image Orientation", orientation );
 
   os << "  Pixel spacing interpretation: '"
      << PixelSpacingInterpretationToString( this->GetPixelSpacingInterpretation() ) << "'" << std::endl;
   printBool( "Gantry Tilt", this->GetTiltInformation().IsRegularGantryTilt() )
     // printBool("3D+t", this->GetFlag("3D+t",false))
 
     // os << "  MITK image loaded: '" << (this->GetMitkImage().IsNotNull() ? "yes" : "no") << "'" <<
     // std::endl;
     if ( filenameDetails )
   {
     os << "  Files in this image block:" << std::endl;
     for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end(); ++frameIter )
     {
       os << "    " << ( *frameIter )->Filename;
       if ( ( *frameIter )->FrameNo > 0 )
       {
         os << ", " << ( *frameIter )->FrameNo;
       }
       os << std::endl;
     }
   }
 }
 
 #define storeTagValueToProperty( tag_name, tag_g, tag_e )                  \
   \
 {                                                                     \
     const DICOMTag t( tag_g, tag_e );                                      \
-    const std::string tagValue = m_TagCache->GetTagValue( firstFrame, t ); \
+    const std::string tagValue = m_TagCache->GetTagValue( firstFrame, t ).value; \
     const_cast<DICOMImageBlockDescriptor*>( this )                         \
       ->SetProperty( #tag_name, StringProperty::New( tagValue ) );         \
   \
 }
 
 #define storeTagValueRangeToProperty( tag_name, tag_g, tag_e )                  \
   \
 {                                                                          \
     const DICOMTag t( tag_g, tag_e );                                           \
-    const std::string tagValueFirst = m_TagCache->GetTagValue( firstFrame, t ); \
-    const std::string tagValueLast  = m_TagCache->GetTagValue( lastFrame, t );  \
+    const std::string tagValueFirst = m_TagCache->GetTagValue( firstFrame, t ).value; \
+    const std::string tagValueLast  = m_TagCache->GetTagValue( lastFrame, t ).value;  \
     const_cast<DICOMImageBlockDescriptor*>( this )                              \
       ->SetProperty( #tag_name "First", StringProperty::New( tagValueFirst ) ); \
     const_cast<DICOMImageBlockDescriptor*>( this )                              \
       ->SetProperty( #tag_name "Last", StringProperty::New( tagValueLast ) );   \
   \
 }
 
 
 void mitk::DICOMImageBlockDescriptor::UpdateImageDescribingProperties() const
 {
   if ( !m_PropertiesOutOfDate )
     return;
 
   if ( !m_ImageFrameList.empty() )
   {
     if ( m_TagCache.IsNull() )
     {
       MITK_ERROR << "Invalid call to DICOMImageBlockDescriptor::UpdateImageDescribingProperties(). Need to "
                     "have initialized tag-cache!";
       return;
     }
 
     const DICOMImageFrameInfo::Pointer firstFrame = m_ImageFrameList.front();
     const DICOMImageFrameInfo::Pointer lastFrame  = m_ImageFrameList.back();
 
     // see macros above
     storeTagValueToProperty( seriesNumber, 0x0020, 0x0011 );
     storeTagValueToProperty( studyDescription, 0x0008, 0x1030 );
     storeTagValueToProperty( seriesDescription, 0x0008, 0x103e );
     storeTagValueToProperty( modality, 0x0008, 0x0060 );
     storeTagValueToProperty( sequenceName, 0x0018, 0x0024 );
     storeTagValueToProperty( orientation, 0x0020, 0x0037 );
     storeTagValueToProperty( rows, 0x0028, 0x0010 );
     storeTagValueToProperty( columns, 0x0028, 0x0011 );
 
     storeTagValueRangeToProperty( sliceLocation, 0x0020, 0x1041 );
     storeTagValueRangeToProperty( acquisitionNumber, 0x0020, 0x0012 );
     storeTagValueRangeToProperty( instanceNumber, 0x0020, 0x0013 );
     storeTagValueRangeToProperty( imagePositionPatient, 0x0020, 0x0032 );
 
     storeTagValueToProperty( windowCenter, 0x0028, 0x1050 );
     storeTagValueToProperty( windowWidth, 0x0028, 0x1051 );
     storeTagValueToProperty( imageType, 0x0008, 0x0008 );
     storeTagValueToProperty( photometricInterpretation, 0x0028, 0x0004 );
 
     // some per-image attributes
     // frames are just numbered starting from 0. timestep 1 (the second time-step) has frames starting at
     // (number-of-frames-per-timestep)
     //     std::string propertyKeySliceLocation = "dicom.image.0020.1041";
     //     std::string propertyKeyInstanceNumber = "dicom.image.0020.0013";
     //     std::string propertyKeySOPInstanceNumber = "dicom.image.0008.0018";
 
     StringLookupTable sliceLocationForSlices;
     StringLookupTable instanceNumberForSlices;
     StringLookupTable SOPInstanceUIDForSlices;
     StringLookupTable filenamesForSlices;
 
     const DICOMTag tagSliceLocation( 0x0020, 0x1041 );
     const DICOMTag tagInstanceNumber( 0x0020, 0x0013 );
     const DICOMTag tagSOPInstanceNumber( 0x0008, 0x0018 );
 
     std::unordered_map<const char*, StringLookupTable> additionalTagResultList;
 
 
     unsigned int slice( 0 );
     for ( auto frameIter = m_ImageFrameList.begin(); frameIter != m_ImageFrameList.end();
           ++slice, ++frameIter )
     {
-      const std::string sliceLocation = m_TagCache->GetTagValue( *frameIter, tagSliceLocation );
+      const std::string sliceLocation = m_TagCache->GetTagValue( *frameIter, tagSliceLocation ).value;
       sliceLocationForSlices.SetTableValue( slice, sliceLocation );
 
-      const std::string instanceNumber = m_TagCache->GetTagValue( *frameIter, tagInstanceNumber );
+      const std::string instanceNumber = m_TagCache->GetTagValue( *frameIter, tagInstanceNumber ).value;
       instanceNumberForSlices.SetTableValue( slice, instanceNumber );
 
-      const std::string sopInstanceUID = m_TagCache->GetTagValue( *frameIter, tagSOPInstanceNumber );
+      const std::string sopInstanceUID = m_TagCache->GetTagValue( *frameIter, tagSOPInstanceNumber ).value;
       SOPInstanceUIDForSlices.SetTableValue( slice, sopInstanceUID );
 
       const std::string filename = ( *frameIter )->Filename;
       filenamesForSlices.SetTableValue( slice, filename );
 
       MITK_DEBUG << "Tag info for slice " << slice << ": SL '" << sliceLocation << "' IN '" << instanceNumber
                  << "' SOP instance UID '" << sopInstanceUID << "'";
 
       for ( auto iter = m_AdditionalTagList.cbegin(); iter != m_AdditionalTagList.cend(); ++iter )
       {
-        const std::string value = m_TagCache->GetTagValue( *frameIter, iter->second );
-        additionalTagResultList[iter->first].SetTableValue( slice, value );
+        const DICOMDatasetFinding finding = m_TagCache->GetTagValue( *frameIter, iter->second );
+        if (finding.isValid)
+        {
+          additionalTagResultList[iter->first].SetTableValue(slice, finding.value);
+        }
       }
     }
     // add property or properties with proper names
     DICOMImageBlockDescriptor* thisInstance = const_cast<DICOMImageBlockDescriptor*>( this );
     thisInstance->SetProperty( "sliceLocationForSlices",
                                StringLookupTableProperty::New( sliceLocationForSlices ) );
 
     thisInstance->SetProperty( "instanceNumberForSlices",
                                StringLookupTableProperty::New( instanceNumberForSlices ) );
 
     thisInstance->SetProperty( "SOPInstanceUIDForSlices",
                                StringLookupTableProperty::New( SOPInstanceUIDForSlices ) );
 
     thisInstance->SetProperty( "filenamesForSlices", StringLookupTableProperty::New( filenamesForSlices ) );
 
     for ( auto iter = additionalTagResultList.cbegin(); iter != additionalTagResultList.cend(); ++iter )
     {
       thisInstance->SetProperty( iter->first, m_PropertyFunctor( iter->second ) );
     }
 
     m_PropertiesOutOfDate = false;
   }
 }
 
 
 mitk::BaseProperty::Pointer
   mitk::DICOMImageBlockDescriptor::GetPropertyForDICOMValues( const StringLookupTable& stringLookupTable )
 {
   const auto& lookupTable = stringLookupTable.GetLookupTable();
   typedef std::pair<int, std::string> PairType;
   if ( std::adjacent_find(
          lookupTable.cbegin(),
          lookupTable.cend(),
          []( const PairType& lhs, const PairType& rhs ) { return lhs.second != rhs.second; } )
        == lookupTable.cend() )
   {
     return static_cast<mitk::BaseProperty::Pointer>(
       mitk::StringProperty::New( stringLookupTable.GetTableValue( 0 ) ).GetPointer() );
   }
 
   return static_cast<mitk::BaseProperty::Pointer>(
     mitk::StringLookupTableProperty::New( stringLookupTable ).GetPointer() );
 }
 
 
 void mitk::DICOMImageBlockDescriptor::SetTagLookupTableToPropertyFunctor( TagLookupTableToPropertyFunctor functor )
 {
   if ( functor != nullptr )
   {
     m_PropertyFunctor = functor;
   }
 }
diff --git a/Modules/DICOMReader/src/mitkDICOMSortByTag.cpp b/Modules/DICOMReader/src/mitkDICOMSortByTag.cpp
index 4e691f7ddd..593d4276b5 100644
--- a/Modules/DICOMReader/src/mitkDICOMSortByTag.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMSortByTag.cpp
@@ -1,176 +1,181 @@
 /*===================================================================
 
 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 "mitkDICOMSortByTag.h"
 
 mitk::DICOMSortByTag
 ::DICOMSortByTag(const DICOMTag& tag, DICOMSortCriterion::Pointer secondaryCriterion)
 :DICOMSortCriterion(secondaryCriterion)
 ,m_Tag(tag)
 {
 }
 
 mitk::DICOMSortByTag
 ::~DICOMSortByTag()
 {
 }
 
 mitk::DICOMSortByTag
 ::DICOMSortByTag(const DICOMSortByTag& other )
 :DICOMSortCriterion(other)
 ,m_Tag(other.m_Tag)
 {
 }
 
 mitk::DICOMSortByTag&
 mitk::DICOMSortByTag
 ::operator=(const DICOMSortByTag& other)
 {
   if (this != &other)
   {
     DICOMSortCriterion::operator=(other);
     m_Tag = other.m_Tag;
   }
   return *this;
 }
 
 bool
 mitk::DICOMSortByTag
 ::operator==(const DICOMSortCriterion& other) const
 {
   if (const DICOMSortByTag* otherSelf = dynamic_cast<const DICOMSortByTag*>(&other))
   {
     if (!(this->m_Tag == otherSelf->m_Tag)) return false;
 
     if (this->m_SecondaryCriterion.IsNull() && otherSelf->m_SecondaryCriterion.IsNull()) return true;
 
     if (this->m_SecondaryCriterion.IsNull() || otherSelf->m_SecondaryCriterion.IsNull()) return false;
 
     return *(this->m_SecondaryCriterion) == *(otherSelf->m_SecondaryCriterion);
   }
   else
   {
     return false;
   }
 }
 
 void
 mitk::DICOMSortByTag
 ::Print(std::ostream& os) const
 {
   m_Tag.Print(os);
 }
 
 
 mitk::DICOMTagList
 mitk::DICOMSortByTag
 ::GetTagsOfInterest() const
 {
   DICOMTagList list;
   list.push_back(m_Tag);
   return list;
 }
 
 bool
 mitk::DICOMSortByTag
 ::IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const
 {
   return this->NumericCompare(left, right, m_Tag);
 }
 
 bool
 mitk::DICOMSortByTag
 ::StringCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const
 {
   assert(left);
   assert(right);
 
-  std::string leftString = left->GetTagValueAsString(tag);
-  std::string rightString = right->GetTagValueAsString(tag);
-
-  if (leftString != rightString)
+  DICOMDatasetFinding leftFinding = left->GetTagValueAsString(tag);
+  DICOMDatasetFinding rightFinding = right->GetTagValueAsString(tag);
+  //Doesn't care if findings are valid or not. If they are not valid,
+  //value is empty, thats enough.
+  if (leftFinding.value != rightFinding.value)
   {
-    return leftString.compare(rightString) < 0;
+    return leftFinding.value.compare(rightFinding.value) < 0;
   }
   else
   {
     return this->NextLevelIsLeftBeforeRight(left, right);
   }
 }
 
 bool
 mitk::DICOMSortByTag
 ::NumericCompare(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, const DICOMTag& tag) const
 {
   assert(left);
   assert(right);
 
-  std::string leftString = left->GetTagValueAsString(tag);
-  std::string rightString = right->GetTagValueAsString(tag);
+  DICOMDatasetFinding leftFinding = left->GetTagValueAsString(tag);
+  DICOMDatasetFinding rightFinding = right->GetTagValueAsString(tag);
+  //Doesn't care if findings are valid or not. If they are not valid,
+  //value is empty, thats enough.
 
-  std::istringstream lefti(leftString);
-  std::istringstream righti(rightString);
+  std::istringstream lefti(leftFinding.value);
+  std::istringstream righti(rightFinding.value);
 
   double leftDouble(0);
   double rightDouble(0);
 
   if (    (lefti >> leftDouble) && (righti >> rightDouble)
        && lefti.eof() && righti.eof() )
   {
     if (leftDouble != rightDouble) // can we decide?
     {
       return leftDouble < rightDouble;
     }
     else // ask secondary criterion
     {
       return this->NextLevelIsLeftBeforeRight(left, right);
     }
   }
   else // no numerical conversion..
   {
     return this->StringCompare(left,right, tag); // fallback to string compare
   }
 }
 
 double
 mitk::DICOMSortByTag
 ::NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const
 {
   assert(from);
   assert(to);
 
-  std::string fromString = from->GetTagValueAsString(m_Tag);
-  std::string toString = to->GetTagValueAsString(m_Tag);
+  DICOMDatasetFinding fromFinding = from->GetTagValueAsString(m_Tag);
+  DICOMDatasetFinding toFinding = to->GetTagValueAsString(m_Tag);
+  //Doesn't care if findings are valid or not. If they are not valid,
+  //value is empty, thats enough.
 
-  std::istringstream fromi(fromString);
-  std::istringstream toi(toString);
+  std::istringstream fromi(fromFinding.value);
+  std::istringstream toi(toFinding.value);
 
   double fromDouble(0);
   double toDouble(0);
 
   if (    (fromi >> fromDouble) && (toi >> toDouble)
        && fromi.eof() && toi.eof() )
   {
     return toDouble - fromDouble;
   }
   else
   {
-    MITK_WARN << "NO NUMERIC DISTANCE between '" << fromString << "' and '" << toString << "'";
+    MITK_WARN << "NO NUMERIC DISTANCE between '" << fromFinding.value << "' and '" << toFinding.value << "'";
     return 0;
   }
 
   // TODO second-level compare?
 }
diff --git a/Modules/DICOMReader/src/mitkDICOMTagBasedSorter.cpp b/Modules/DICOMReader/src/mitkDICOMTagBasedSorter.cpp
index f3c553818f..4f054dc544 100644
--- a/Modules/DICOMReader/src/mitkDICOMTagBasedSorter.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMTagBasedSorter.cpp
@@ -1,589 +1,589 @@
 /*===================================================================
 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 "mitkDICOMTagBasedSorter.h"
 
 #include <algorithm>
 #include <iomanip>
 
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::CutDecimalPlaces(unsigned int precision)
 :m_Precision(precision)
 {
 }
 
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::CutDecimalPlaces(const CutDecimalPlaces& other)
 :m_Precision(other.m_Precision)
 {
 }
 
 std::string
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::operator()(const std::string& input) const
 {
   // be a bit tolerant for tags such as image orientation orienatation, let only the first few digits matter (http://bugs.mitk.org/show_bug.cgi?id=12263)
   // iterate all fields, convert each to a number, cut this number as configured, then return a concatenated string with all cut-off numbers
   std::ostringstream resultString;
   resultString.str(std::string());
   resultString.clear();
   resultString.setf(std::ios::fixed, std::ios::floatfield);
   resultString.precision(m_Precision);
 
   std::stringstream ss(input);
   ss.str(input);
   ss.clear();
   std::string item;
   double number(0);
   std::istringstream converter(item);
   while (std::getline(ss, item, '\\'))
   {
     converter.str(item);
     converter.clear();
     if (converter >> number && converter.eof())
     {
       // converted to double
       resultString << number;
     }
     else
     {
       // did not convert to double
       resultString << item; // just paste the unmodified string
     }
 
     if (!ss.eof())
     {
       resultString << "\\";
     }
   }
 
   return resultString.str();
 }
 
 mitk::DICOMTagBasedSorter::TagValueProcessor*
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::Clone() const
 {
   return new CutDecimalPlaces(*this);
 }
 
 
 unsigned int
 mitk::DICOMTagBasedSorter::CutDecimalPlaces
 ::GetPrecision() const
 {
   return m_Precision;
 }
 
 mitk::DICOMTagBasedSorter
 ::DICOMTagBasedSorter()
 :DICOMDatasetSorter()
 ,m_StrictSorting(false)
 ,m_ExpectDistanceOne(false)
 {
 }
 
 mitk::DICOMTagBasedSorter
 ::~DICOMTagBasedSorter()
 {
   for(auto ti = m_TagValueProcessor.begin();
       ti != m_TagValueProcessor.end();
       ++ti)
   {
     delete ti->second;
   }
 }
 
 mitk::DICOMTagBasedSorter
 ::DICOMTagBasedSorter(const DICOMTagBasedSorter& other )
 :DICOMDatasetSorter(other)
 ,m_DistinguishingTags( other.m_DistinguishingTags )
 ,m_SortCriterion( other.m_SortCriterion )
 ,m_StrictSorting( other.m_StrictSorting )
 ,m_ExpectDistanceOne( other.m_ExpectDistanceOne )
 {
   for(auto ti = other.m_TagValueProcessor.begin();
       ti != other.m_TagValueProcessor.end();
       ++ti)
   {
     m_TagValueProcessor[ti->first] = ti->second->Clone();
   }
 }
 
 mitk::DICOMTagBasedSorter&
 mitk::DICOMTagBasedSorter
 ::operator=(const DICOMTagBasedSorter& other)
 {
   if (this != &other)
   {
     DICOMDatasetSorter::operator=(other);
     m_DistinguishingTags = other.m_DistinguishingTags;
     m_SortCriterion = other.m_SortCriterion;
     m_StrictSorting = other.m_StrictSorting;
     m_ExpectDistanceOne = other.m_ExpectDistanceOne;
 
     for(auto ti = other.m_TagValueProcessor.begin();
         ti != other.m_TagValueProcessor.end();
         ++ti)
     {
       m_TagValueProcessor[ti->first] = ti->second->Clone();
     }
   }
   return *this;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::operator==(const DICOMDatasetSorter& other) const
 {
   if (const DICOMTagBasedSorter* otherSelf = dynamic_cast<const DICOMTagBasedSorter*>(&other))
   {
     if (this->m_StrictSorting != otherSelf->m_StrictSorting) return false;
     if (this->m_ExpectDistanceOne != otherSelf->m_ExpectDistanceOne) return false;
 
     bool allTagsPresentAndEqual(true);
     if (this->m_DistinguishingTags.size() != otherSelf->m_DistinguishingTags.size())
       return false;
 
     for (auto myTag = this->m_DistinguishingTags.begin();
         myTag != this->m_DistinguishingTags.end();
         ++myTag)
     {
       allTagsPresentAndEqual &= (std::find( otherSelf->m_DistinguishingTags.begin(), otherSelf->m_DistinguishingTags.end(), *myTag )
                                  != otherSelf->m_DistinguishingTags.end()); // other contains this tags
                                              // since size is equal, we don't need to check the inverse
     }
 
     if (!allTagsPresentAndEqual) return false;
 
     if (this->m_SortCriterion.IsNotNull() && otherSelf->m_SortCriterion.IsNotNull())
     {
       return *(this->m_SortCriterion) == *(otherSelf->m_SortCriterion);
     }
     else
     {
       return this->m_SortCriterion.IsNull() && otherSelf->m_SortCriterion.IsNull();
     }
   }
   else
   {
     return false;
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::PrintConfiguration(std::ostream& os, const std::string& indent) const
 {
   os << indent << "Tag based sorting "
      << "(strict=" << (m_StrictSorting?"true":"false")
      << ", expectDistanceOne=" << (m_ExpectDistanceOne?"true":"false") << "):"
      << std::endl;
 
   for (auto tagIter = m_DistinguishingTags.begin();
        tagIter != m_DistinguishingTags.end();
        ++tagIter)
   {
     os << indent << "  Split on ";
     tagIter->Print(os);
     os << std::endl;
   }
 
   DICOMSortCriterion::ConstPointer crit = m_SortCriterion.GetPointer();
   while (crit.IsNotNull())
   {
     os << indent << "   Sort by ";
     crit->Print(os);
     os << std::endl;
     crit = crit->GetSecondaryCriterion();
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetStrictSorting(bool strict)
 {
   m_StrictSorting = strict;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::GetStrictSorting() const
 {
   return m_StrictSorting;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetExpectDistanceOne(bool strict)
 {
   m_ExpectDistanceOne = strict;
 }
 
 bool
 mitk::DICOMTagBasedSorter
 ::GetExpectDistanceOne() const
 {
   return m_ExpectDistanceOne;
 }
 
 
 mitk::DICOMTagList
 mitk::DICOMTagBasedSorter
 ::GetTagsOfInterest()
 {
   DICOMTagList allTags = m_DistinguishingTags;
 
   DICOMTagList sortingRelevantTags = m_SortCriterion->GetAllTagsOfInterest();
   allTags.insert( allTags.end(), sortingRelevantTags.begin(), sortingRelevantTags.end() ); // append
 
   return allTags;
 }
 
 mitk::DICOMTagList
 mitk::DICOMTagBasedSorter
 ::GetDistinguishingTags() const
 {
   return m_DistinguishingTags;
 }
 
 const mitk::DICOMTagBasedSorter::TagValueProcessor*
 mitk::DICOMTagBasedSorter
 ::GetTagValueProcessorForDistinguishingTag(const DICOMTag& tag) const
 {
   auto loc = m_TagValueProcessor.find(tag);
   if (loc != m_TagValueProcessor.end())
   {
     return loc->second;
   }
   else
   {
     return nullptr;
   }
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::AddDistinguishingTag( const DICOMTag& tag, TagValueProcessor* tagValueProcessor )
 {
   m_DistinguishingTags.push_back(tag);
   m_TagValueProcessor[tag] = tagValueProcessor;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::SetSortCriterion( DICOMSortCriterion::ConstPointer criterion )
 {
   m_SortCriterion = criterion;
 }
 
 mitk::DICOMSortCriterion::ConstPointer
 mitk::DICOMTagBasedSorter
 ::GetSortCriterion() const
 {
   return m_SortCriterion;
 }
 
 void
 mitk::DICOMTagBasedSorter
 ::Sort()
 {
   // 1. split
   // 2. sort each group
   GroupIDToListType groups = this->SplitInputGroups();
   GroupIDToListType& sortedGroups = this->SortGroups( groups );
 
   // 3. define output
   this->SetNumberOfOutputs(sortedGroups.size());
   unsigned int outputIndex(0);
   for (auto groupIter = sortedGroups.begin();
        groupIter != sortedGroups.end();
        ++outputIndex, ++groupIter)
   {
     this->SetOutput(outputIndex, groupIter->second);
   }
 }
 
 std::string
 mitk::DICOMTagBasedSorter
 ::BuildGroupID( DICOMDatasetAccess* dataset )
 {
   // just concatenate all tag values
   assert(dataset);
   std::stringstream groupID;
   groupID << "g";
   for (auto tagIter = m_DistinguishingTags.begin();
        tagIter != m_DistinguishingTags.end();
        ++tagIter)
   {
     groupID << tagIter->GetGroup() << tagIter->GetElement(); // make group/element part of the id to cover empty tags
-    std::string rawTagValue = dataset->GetTagValueAsString(*tagIter);
+    DICOMDatasetFinding rawTagValue = dataset->GetTagValueAsString(*tagIter);
     std::string processedTagValue;
-    if ( m_TagValueProcessor[*tagIter] != nullptr )
+    if ( m_TagValueProcessor[*tagIter] != nullptr && rawTagValue.isValid)
     {
-      processedTagValue = (*m_TagValueProcessor[*tagIter])(rawTagValue);
+      processedTagValue = (*m_TagValueProcessor[*tagIter])(rawTagValue.value);
     }
     else
     {
-      processedTagValue = rawTagValue;
+      processedTagValue = rawTagValue.value;
     }
     groupID << processedTagValue;
   }
   // shorten ID?
   return groupID.str();
 }
 
 mitk::DICOMTagBasedSorter::GroupIDToListType
 mitk::DICOMTagBasedSorter
 ::SplitInputGroups()
 {
   DICOMDatasetList input = GetInput(); // copy
 
   GroupIDToListType listForGroupID;
 
   for (auto dsIter = input.begin();
        dsIter != input.end();
        ++dsIter)
   {
     DICOMDatasetAccess* dataset = *dsIter;
     assert(dataset);
 
     std::string groupID = this->BuildGroupID( dataset );
     MITK_DEBUG << "Group ID for for " << dataset->GetFilenameIfAvailable() << ": " << groupID;
     listForGroupID[groupID].push_back(dataset);
   }
 
   MITK_DEBUG << "After tag based splitting: " << listForGroupID.size() << " groups";
 
   return listForGroupID;
 }
 
 mitk::DICOMTagBasedSorter::GroupIDToListType&
 mitk::DICOMTagBasedSorter
 ::SortGroups(GroupIDToListType& groups)
 {
   if (m_SortCriterion.IsNotNull())
   {
     /*
        Three steps here:
         1. sort within each group
            - this may result in orders such as 1 2 3 4 6 7 8 10 12 13 14
         2. create new groups by enforcing consecutive order within each group
            - resorts above example like 1 2 3 4  ;  6 7 8  ;  10  ;  12 13 14
         3. sort all of the groups (not WITHIN each group) by their first frame
            - if earlier "distinguish" steps created groups like 6 7 8  ;  1 2 3 4  ; 10,
              then this step would sort them like 1 2 3 4  ;  6 7 8  ;  10
     */
 
     // Step 1: sort within the groups
     // for each output
     //   sort by all configured tags, use secondary tags when equal or empty
     //   make configurable:
     //    - sorting order (ascending, descending)
     //    - sort numerically
     //    - ... ?
     unsigned int groupIndex(0);
     for (auto gIter = groups.begin();
          gIter != groups.end();
          ++groupIndex, ++gIter)
     {
       DICOMDatasetList& dsList = gIter->second;
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
       MITK_DEBUG << "   DICOMTagBasedSorter before sorting group : " << groupIndex;
       for (auto oi = dsList.begin();
            oi != dsList.end();
            ++oi)
       {
         MITK_DEBUG << "     INPUT     : " << (*oi)->GetFilenameIfAvailable();
       }
 
       std::sort( dsList.begin(), dsList.end(), ParameterizedDatasetSort( m_SortCriterion ) );
 
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
       MITK_DEBUG << "   DICOMTagBasedSorter after sorting group : " << groupIndex;
       for (auto oi = dsList.begin();
            oi != dsList.end();
            ++oi)
       {
         MITK_DEBUG << "     OUTPUT    : " << (*oi)->GetFilenameIfAvailable();
       }
       MITK_DEBUG << "   --------------------------------------------------------------------------------";
     }
 
     GroupIDToListType consecutiveGroups;
     if (m_StrictSorting)
     {
       // Step 2: create new groups by enforcing consecutive order within each group
       unsigned int groupIndex(0);
       for (auto gIter = groups.begin();
            gIter != groups.end();
            ++gIter)
       {
         std::stringstream groupKey;
         groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
 
         DICOMDatasetList& dsList = gIter->second;
         DICOMDatasetAccess* previousDS(nullptr);
         unsigned int dsIndex(0);
         double constantDistance(0.0);
         bool constantDistanceInitialized(false);
         for (auto dataset = dsList.begin();
              dataset != dsList.end();
              ++dsIndex, ++dataset)
         {
           if (dsIndex >0) // ignore the first dataset, we cannot check any distances yet..
           {
             // for the second and every following dataset:
             // let the sorting criterion calculate a "distance"
             // if the distance is not 1, split off a new group!
             double currentDistance = m_SortCriterion->NumericDistance(previousDS, *dataset);
             if (constantDistanceInitialized)
             {
               if (fabs(currentDistance - constantDistance) < fabs(constantDistance * 0.01)) // ok, deviation of up to 1% of distance is tolerated
               {
                 // nothing to do, just ok
                 MITK_DEBUG << "Checking currentDistance==" << currentDistance << ": small enough";
               }
               //else if (currentDistance < mitk::eps) // close enough to 0
               else
               {
                 MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (current distance " << currentDistance << ", constant distance " << constantDistance << ")";
                 // split! this is done by simply creating a new group (key)
                 groupKey.str(std::string());
                 groupKey.clear();
                 groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
               }
             }
             else
             {
               // second slice: learn about the expected distance!
 
               // heuristic: if distance is an integer, we check for a special case:
               //            if the distance is integer and not 1/-1, then we assume
               //            a missing slice right after the first slice
               //            ==> split off slices
               // in all other cases: second dataset at this position, no need to split already, we are still learning about the images
 
               // addition to the above: when sorting by imagepositions, a distance other than 1 between the first two slices is
               // not unusual, actually expected... then we should not split
 
               if (m_ExpectDistanceOne)
               {
                 if ((currentDistance - (int)currentDistance == 0.0) && fabs(currentDistance) != 1.0)
                   // exact comparison. An integer should not be expressed as 1.000000000000000000000000001!
                 {
                   MITK_DEBUG << "Split consecutive group at index " << dsIndex << " (special case: expected distance 1 exactly)";
                   groupKey.str(std::string());
                   groupKey.clear();
                   groupKey << std::setfill('0') << std::setw(6) << groupIndex++;
                 }
               }
 
               MITK_DEBUG << "Initialize strict distance to currentDistance=" << currentDistance;
 
               constantDistance = currentDistance;
               constantDistanceInitialized = true;
             }
           }
           consecutiveGroups[groupKey.str()].push_back(*dataset);
           previousDS = *dataset;
         }
       }
     }
     else
     {
       consecutiveGroups = groups;
     }
 
     // Step 3: sort all of the groups (not WITHIN each group) by their first frame
     /*
       build a list-1 of datasets with the first dataset one of each group
       sort this list-1
       build a new result list-2:
        - iterate list-1, for each dataset
          - find the group that contains this dataset
          - add this group as the next element to list-2
       return list-2 as the sorted output
     */
     DICOMDatasetList firstSlices;
     for (auto gIter = consecutiveGroups.begin();
          gIter != consecutiveGroups.end();
          ++gIter)
     {
       assert(!gIter->second.empty());
       firstSlices.push_back(gIter->second.front());
     }
 
     std::sort( firstSlices.begin(), firstSlices.end(), ParameterizedDatasetSort( m_SortCriterion ) );
 
     GroupIDToListType sortedResultBlocks;
     unsigned int groupKeyValue(0);
     for (auto firstSlice = firstSlices.begin();
          firstSlice != firstSlices.end();
          ++firstSlice)
     {
       for (auto gIter = consecutiveGroups.begin();
            gIter != consecutiveGroups.end();
            ++groupKeyValue, ++gIter)
       {
         if (gIter->second.front() == *firstSlice)
         {
           std::stringstream groupKey;
           groupKey << std::setfill('0') << std::setw(6) << groupKeyValue; // try more than 999,999 groups and you are doomed (your application already is)
           sortedResultBlocks[groupKey.str()] = gIter->second;
         }
       }
     }
 
     groups = sortedResultBlocks;
   }
 
   unsigned int groupIndex(0);
   for (auto gIter = groups.begin();
       gIter != groups.end();
       ++groupIndex, ++gIter)
   {
     DICOMDatasetList& dsList = gIter->second;
     MITK_DEBUG << "   --------------------------------------------------------------------------------";
     MITK_DEBUG << "   DICOMTagBasedSorter after sorting group : " << groupIndex;
     for (auto oi = dsList.begin();
         oi != dsList.end();
         ++oi)
     {
       MITK_DEBUG << "     OUTPUT    : " << (*oi)->GetFilenameIfAvailable();
     }
     MITK_DEBUG << "   --------------------------------------------------------------------------------";
   }
 
 
   return groups;
 }
 
 mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
 ::ParameterizedDatasetSort(DICOMSortCriterion::ConstPointer criterion)
 :m_SortCriterion(criterion)
 {
 }
 
 bool
 mitk::DICOMTagBasedSorter::ParameterizedDatasetSort
 ::operator() (const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right)
 {
   assert(left);
   assert(right);
   assert(m_SortCriterion.IsNotNull());
 
   return m_SortCriterion->IsLeftBeforeRight(left, right);
 }
diff --git a/Modules/DICOMReader/src/mitkEquiDistantBlocksSorter.cpp b/Modules/DICOMReader/src/mitkEquiDistantBlocksSorter.cpp
index 36cc2986ec..faea694a2f 100644
--- a/Modules/DICOMReader/src/mitkEquiDistantBlocksSorter.cpp
+++ b/Modules/DICOMReader/src/mitkEquiDistantBlocksSorter.cpp
@@ -1,571 +1,571 @@
 /*=================================================================== 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "mitkEquiDistantBlocksSorter.h"
 
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::SliceGroupingAnalysisResult()
 {
 }
 
 mitk::DICOMDatasetList
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetBlockDatasets()
 {
   return m_GroupedFiles;
 }
 
 mitk::DICOMDatasetList
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetUnsortedDatasets()
 {
   return m_UnsortedFiles;
 }
 
 bool
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::ContainsGantryTilt()
 {
   return m_TiltInfo.IsRegularGantryTilt();
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFileToSortedBlock(DICOMDatasetAccess* dataset)
 {
   m_GroupedFiles.push_back( dataset );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFileToUnsortedBlock(DICOMDatasetAccess* dataset)
 {
   m_UnsortedFiles.push_back( dataset );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::AddFilesToUnsortedBlock(const DICOMDatasetList& datasets)
 {
   m_UnsortedFiles.insert( m_UnsortedFiles.end(), datasets.begin(), datasets.end() );
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::SetFirstFilenameOfBlock(const std::string& filename)
 {
   m_FirstFilenameOfBlock = filename;
 }
 
 std::string
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetFirstFilenameOfBlock() const
 {
   return m_FirstFilenameOfBlock;
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::SetLastFilenameOfBlock(const std::string& filename)
 {
   m_LastFilenameOfBlock = filename;
 }
 
 std::string
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetLastFilenameOfBlock() const
 {
   return m_LastFilenameOfBlock;
 }
 
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::FlagGantryTilt(const GantryTiltInformation& tiltInfo)
 {
   m_TiltInfo = tiltInfo;
 }
 
 const mitk::GantryTiltInformation&
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::GetTiltInfo() const
 {
   return m_TiltInfo;
 }
 
 void
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 ::UndoPrematureGrouping()
 {
   assert( !m_GroupedFiles.empty() );
   m_UnsortedFiles.insert( m_UnsortedFiles.begin(), m_GroupedFiles.back() );
   m_GroupedFiles.pop_back();
   m_TiltInfo = GantryTiltInformation();
 }
 
 // ------------------------ end helper class
 
 mitk::EquiDistantBlocksSorter
 ::EquiDistantBlocksSorter()
 :DICOMDatasetSorter()
 ,m_AcceptTilt(false)
 ,m_ToleratedOriginOffset(0.3)
 ,m_ToleratedOriginOffsetIsAbsolute(false)
 ,m_AcceptTwoSlicesGroups(true)
 {
 }
 
 mitk::EquiDistantBlocksSorter
 ::EquiDistantBlocksSorter(const EquiDistantBlocksSorter& other )
 :DICOMDatasetSorter(other)
 ,m_AcceptTilt(other.m_AcceptTilt)
 ,m_ToleratedOriginOffset(other.m_ToleratedOriginOffset)
 ,m_ToleratedOriginOffsetIsAbsolute(other.m_ToleratedOriginOffsetIsAbsolute)
 ,m_AcceptTwoSlicesGroups(other.m_AcceptTwoSlicesGroups)
 {
 }
 
 mitk::EquiDistantBlocksSorter
 ::~EquiDistantBlocksSorter()
 {
 }
 
 bool
 mitk::EquiDistantBlocksSorter
 ::operator==(const DICOMDatasetSorter& other) const
 {
   if (const EquiDistantBlocksSorter* otherSelf = dynamic_cast<const EquiDistantBlocksSorter*>(&other))
   {
     return this->m_AcceptTilt == otherSelf->m_AcceptTilt
         && this->m_ToleratedOriginOffsetIsAbsolute == otherSelf->m_ToleratedOriginOffsetIsAbsolute
         && this->m_AcceptTwoSlicesGroups == otherSelf->m_AcceptTwoSlicesGroups
         && (fabs(this->m_ToleratedOriginOffset - otherSelf->m_ToleratedOriginOffset) < eps);
   }
   else
   {
     return false;
   }
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::PrintConfiguration(std::ostream& os, const std::string& indent) const
 {
   std::stringstream ts;
   if (!m_ToleratedOriginOffsetIsAbsolute)
   {
     ts << "adaptive";
   }
   else
   {
     ts << m_ToleratedOriginOffset << "mm";
   }
 
   os << indent << "Sort into blocks of equidistant, well-aligned (tolerance "
      << ts.str() << ") slices "
      << (m_AcceptTilt ? "(accepting a gantry tilt)" : "")
      << std::endl;
 }
 
 
 void
 mitk::EquiDistantBlocksSorter
 ::SetAcceptTilt(bool accept)
 {
   m_AcceptTilt = accept;
 }
 
 
 bool
 mitk::EquiDistantBlocksSorter
 ::GetAcceptTilt() const
 {
   return m_AcceptTilt;
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::SetAcceptTwoSlicesGroups(bool accept)
 {
   m_AcceptTwoSlicesGroups = accept;
 }
 
 bool
 mitk::EquiDistantBlocksSorter
 ::GetAcceptTwoSlicesGroups() const
 {
   return m_AcceptTwoSlicesGroups;
 }
 
 
 mitk::EquiDistantBlocksSorter&
 mitk::EquiDistantBlocksSorter
 ::operator=(const EquiDistantBlocksSorter& other)
 {
   if (this != &other)
   {
     DICOMDatasetSorter::operator=(other);
     m_AcceptTilt = other.m_AcceptTilt;
     m_ToleratedOriginOffset = other.m_ToleratedOriginOffset;
     m_ToleratedOriginOffsetIsAbsolute = other.m_ToleratedOriginOffsetIsAbsolute;
     m_AcceptTwoSlicesGroups = other.m_AcceptTwoSlicesGroups;
   }
   return *this;
 }
 
 mitk::DICOMTagList
 mitk::EquiDistantBlocksSorter
 ::GetTagsOfInterest()
 {
   DICOMTagList tags;
   tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
   tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
   tags.push_back( DICOMTag(0x0018, 0x1120) ); // GantryDetectorTilt
 
   return tags;
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::Sort()
 {
   DICOMDatasetList remainingInput = GetInput(); // copy
 
   typedef std::list<DICOMDatasetList> OutputListType;
   OutputListType outputs;
 
   m_SliceGroupingResults.clear();
 
   while (!remainingInput.empty()) // repeat until all files are grouped somehow
   {
     SliceGroupingAnalysisResult regularBlock = this->AnalyzeFileForITKImageSeriesReaderSpacingAssumption( remainingInput, m_AcceptTilt );
 
     DICOMDatasetList inBlock = regularBlock.GetBlockDatasets();
     DICOMDatasetList laterBlock = regularBlock.GetUnsortedDatasets();
     MITK_DEBUG << "Result: sorted 3D group with " << inBlock.size() << " files";
     for (DICOMDatasetList::const_iterator diter = inBlock.begin(); diter != inBlock.end(); ++diter)
       MITK_DEBUG << "  IN  " << (*diter)->GetFilenameIfAvailable();
     for (DICOMDatasetList::const_iterator diter = laterBlock.begin(); diter != laterBlock.end(); ++diter)
       MITK_DEBUG << " OUT  " << (*diter)->GetFilenameIfAvailable();
 
     outputs.push_back( regularBlock.GetBlockDatasets() );
     m_SliceGroupingResults.push_back( regularBlock );
     remainingInput = regularBlock.GetUnsortedDatasets();
   }
 
   unsigned int numberOfOutputs = outputs.size();
   this->SetNumberOfOutputs(numberOfOutputs);
 
   unsigned int outputIndex(0);
   for (auto oIter = outputs.begin();
        oIter != outputs.end();
        ++outputIndex, ++oIter)
   {
     this->SetOutput(outputIndex, *oIter);
   }
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::SetToleratedOriginOffsetToAdaptive(double fractionOfInterSliceDistance)
 {
   m_ToleratedOriginOffset = fractionOfInterSliceDistance;
   m_ToleratedOriginOffsetIsAbsolute = false;
 
   if (m_ToleratedOriginOffset < 0.0)
   {
     MITK_WARN << "Call SetToleratedOriginOffsetToAdaptive() only with positive numbers between 0.0 and 1.0, read documentation!";
   }
 
   if (m_ToleratedOriginOffset > 0.5)
   {
     MITK_WARN << "EquiDistantBlocksSorter is now accepting large errors, take care of measurements, they could appear at unprecise locations!";
   }
 }
 
 void
 mitk::EquiDistantBlocksSorter
 ::SetToleratedOriginOffset(double millimeters)
 {
   m_ToleratedOriginOffset = millimeters;
   m_ToleratedOriginOffsetIsAbsolute = true;
   if (m_ToleratedOriginOffset < 0.0)
   {
     MITK_WARN << "Negative tolerance set to SetToleratedOriginOffset()!";
   }
 }
 
 double
 mitk::EquiDistantBlocksSorter
 ::GetToleratedOriginOffset() const
 {
   return m_ToleratedOriginOffset;
 }
 
 bool
 mitk::EquiDistantBlocksSorter
 ::IsToleratedOriginOffsetAbsolute() const
 {
   return m_ToleratedOriginOffsetIsAbsolute;
 }
 
 
 std::string
 mitk::EquiDistantBlocksSorter
 ::ConstCharStarToString(const char* s)
 {
   return s ?  std::string(s) : std::string();
 }
 
 mitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult
 mitk::EquiDistantBlocksSorter
 ::AnalyzeFileForITKImageSeriesReaderSpacingAssumption(
   const DICOMDatasetList& datasets,
   bool groupImagesWithGantryTilt)
 {
   // result.first = files that fit ITK's assumption
   // result.second = files that do not fit, should be run through AnalyzeFileForITKImageSeriesReaderSpacingAssumption() again
   SliceGroupingAnalysisResult result;
 
   // we const_cast here, because I could not use a map.at(), which would make the code much more readable
   const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
   const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
 
   Vector3D fromFirstToSecondOrigin; fromFirstToSecondOrigin.Fill(0.0);
   bool fromFirstToSecondOriginInitialized(false);
   Point3D thisOrigin;
   thisOrigin.Fill(0.0f);
   Point3D lastOrigin;
   lastOrigin.Fill(0.0f);
   Point3D lastDifferentOrigin;
   lastDifferentOrigin.Fill(0.0f);
 
   bool lastOriginInitialized(false);
 
   MITK_DEBUG << "--------------------------------------------------------------------------------";
   MITK_DEBUG << "Analyzing " << datasets.size() << " files for z-spacing assumption of ITK's ImageSeriesReader (group tilted: " << groupImagesWithGantryTilt << ")";
   unsigned int fileIndex(0);
   double toleratedOriginError(0.005); // default: max. 1/10mm error when measurement crosses 20 slices in z direction (too strict? we don't know better)
   for (auto dsIter = datasets.begin();
        dsIter != datasets.end();
        ++dsIter, ++fileIndex)
   {
     bool fileFitsIntoPattern(false);
     std::string thisOriginString;
     // Read tag value into point3D. PLEASE replace this by appropriate GDCM code if you figure out how to do that
-    thisOriginString = (*dsIter)->GetTagValueAsString( tagImagePositionPatient );
+    thisOriginString = (*dsIter)->GetTagValueAsString(tagImagePositionPatient).value;
 
     if (thisOriginString.empty())
     {
       // don't let such files be in a common group. Everything without position information will be loaded as a single slice:
       // with standard DICOM files this can happen to: CR, DX, SC
       MITK_DEBUG << "    ==> Sort away " << *dsIter << " for later analysis (no position information)"; // we already have one occupying this position
 
       if ( result.GetBlockDatasets().empty() ) // nothing WITH position information yet
       {
         // ==> this is a group of its own, stop processing, come back later
         result.AddFileToSortedBlock( *dsIter );
 
         DICOMDatasetList remainingFiles;
         remainingFiles.insert( remainingFiles.end(), dsIter+1, datasets.end() );
         result.AddFilesToUnsortedBlock( remainingFiles );
 
         fileFitsIntoPattern = false;
         break; // no files anymore
       }
       else
       {
         // ==> this does not match, consider later
         result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
         fileFitsIntoPattern = false;
         continue; // next file
       }
     }
 
     bool ignoredConversionError(-42); // hard to get here, no graceful way to react
     thisOrigin = DICOMStringToPoint3D( thisOriginString, ignoredConversionError );
 
     MITK_DEBUG << "  " << fileIndex << " " << (*dsIter)->GetFilenameIfAvailable()
                        << " at "
                        /* << thisOriginString */ << "(" << thisOrigin[0] << "," << thisOrigin[1] << "," << thisOrigin[2] << ")";
 
     if ( lastOriginInitialized && (thisOrigin == lastOrigin) )
     {
       MITK_DEBUG << "    ==> Sort away " << *dsIter << " for separate time step"; // we already have one occupying this position
       result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
       fileFitsIntoPattern = false;
     }
     else
     {
       if (!fromFirstToSecondOriginInitialized && lastOriginInitialized) // calculate vector as soon as possible when we get a new position
       {
         fromFirstToSecondOrigin = thisOrigin - lastDifferentOrigin;
         fromFirstToSecondOriginInitialized = true;
 
         // classic mode without tolerance!
         if (!m_ToleratedOriginOffsetIsAbsolute)
         {
           MITK_DEBUG << "Distance of two slices: " << fromFirstToSecondOrigin.GetNorm() << "mm";
           toleratedOriginError =
             fromFirstToSecondOrigin.GetNorm() * 0.3; // a third of the slice distance
           //  (less than half, which would mean that a slice is displayed where another slice should actually be)
         }
         else
         {
           toleratedOriginError = m_ToleratedOriginOffset;
         }
         MITK_DEBUG << "Accepting errors in actual versus expected origin up to " << toleratedOriginError << "mm";
 
         // Here we calculate if this slice and the previous one are well aligned,
         // i.e. we test if the previous origin is on a line through the current
         // origin, directed into the normal direction of the current slice.
 
         // If this is NOT the case, then we have a data set with a TILTED GANTRY geometry,
         // which cannot be simply loaded into a single mitk::Image at the moment.
         // For this case, we flag this finding in the result and DicomSeriesReader
         // can correct for that later.
 
         Vector3D right; right.Fill(0.0);
         Vector3D up; right.Fill(0.0); // might be down as well, but it is just a name at this point
-        std::string orientationValue = (*dsIter)->GetTagValueAsString( tagImageOrientation );
+        std::string orientationValue = (*dsIter)->GetTagValueAsString( tagImageOrientation ).value;
         DICOMStringToOrientationVectors( orientationValue, right, up, ignoredConversionError );
 
         GantryTiltInformation tiltInfo( lastDifferentOrigin, thisOrigin, right, up, 1 );
 
         if ( tiltInfo.IsSheared() )
         {
           /* optimistic approach, accepting gantry tilt: save file for later, check all further files */
 
           // at this point we have TWO slices analyzed! if they are the only two files, we still split, because there is no third to verify our tilting assumption.
           // later with a third being available, we must check if the initial tilting vector is still valid. if yes, continue.
           // if NO, we need to split the already sorted part (result.first) and the currently analyzed file (*dsIter)
 
           // tell apart gantry tilt from overall skewedness
           // sort out irregularly sheared slices, that IS NOT tilting
 
           if ( groupImagesWithGantryTilt && tiltInfo.IsRegularGantryTilt() )
           {
             assert(!datasets.empty());
 
             result.FlagGantryTilt(tiltInfo);
             result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
             result.SetFirstFilenameOfBlock( datasets.front()->GetFilenameIfAvailable() );
             result.SetLastFilenameOfBlock( datasets.back()->GetFilenameIfAvailable() );
             fileFitsIntoPattern = true;
           }
           else // caller does not want tilt compensation OR shearing is more complicated than tilt
           {
             result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
             fileFitsIntoPattern = false;
           }
         }
         else // not sheared
         {
           result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
       else if (fromFirstToSecondOriginInitialized) // we already know the offset between slices
       {
         Point3D assumedOrigin = lastDifferentOrigin + fromFirstToSecondOrigin;
 
         Vector3D originError = assumedOrigin - thisOrigin;
         double norm = originError.GetNorm();
 
         if (norm > toleratedOriginError)
         {
           MITK_DEBUG << "  File does not fit into the inter-slice distance pattern (diff = "
                                << norm << ", allowed "
                                << toleratedOriginError << ").";
           MITK_DEBUG << "  Expected position (" << assumedOrigin[0] << ","
                                             << assumedOrigin[1] << ","
                                             << assumedOrigin[2] << "), got position ("
                                             << thisOrigin[0] << ","
                                             << thisOrigin[1] << ","
                                             << thisOrigin[2] << ")";
           MITK_DEBUG  << "    ==> Sort away " << *dsIter << " for later analysis";
 
           // At this point we know we deviated from the expectation of ITK's ImageSeriesReader
           // We split the input file list at this point, i.e. all files up to this one (excluding it)
           // are returned as group 1, the remaining files (including the faulty one) are group 2
 
           /* Optimistic approach: check if any of the remaining slices fits in */
           result.AddFileToUnsortedBlock( *dsIter ); // sort away for further analysis
           fileFitsIntoPattern = false;
         }
         else
         {
           result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
           fileFitsIntoPattern = true;
         }
       }
       else // this should be the very first slice
       {
         result.AddFileToSortedBlock( *dsIter ); // this file is good for current block
         fileFitsIntoPattern = true;
       }
     }
 
     // record current origin for reference in later iterations
     if ( !lastOriginInitialized || ( fileFitsIntoPattern && (thisOrigin != lastOrigin) ) )
     {
       lastDifferentOrigin = thisOrigin;
     }
 
     lastOrigin = thisOrigin;
     lastOriginInitialized = true;
   }
 
   if ( result.ContainsGantryTilt() )
   {
     // check here how many files were grouped.
     // IF it was only two files AND we assume tiltedness (e.g. save "distance")
     // THEN we would want to also split the two previous files (simple) because
     // we don't have any reason to assume they belong together
 
     // Above behavior can be configured via m_AcceptTwoSlicesGroups, the default being "do accept"
     if ( result.GetBlockDatasets().size() == 2 && !m_AcceptTwoSlicesGroups )
     {
       result.UndoPrematureGrouping();
     }
   }
 
   // update tilt info to get maximum precision
   // earlier, tilt was only calculated from first and second slice.
   // now that we know the whole range, we can re-calculate using the very first and last slice
   if ( result.ContainsGantryTilt() && result.GetBlockDatasets().size() > 1 )
   {
     try
     {
       DICOMDatasetList datasets = result.GetBlockDatasets();
       DICOMDatasetAccess* firstDataset = datasets.front();
       DICOMDatasetAccess* lastDataset = datasets.back();
       unsigned int numberOfSlicesApart = datasets.size() - 1;
 
-      std::string orientationString = firstDataset->GetTagValueAsString( tagImageOrientation );
-      std::string firstOriginString = firstDataset->GetTagValueAsString( tagImagePositionPatient );
-      std::string lastOriginString = lastDataset->GetTagValueAsString( tagImagePositionPatient );
+      std::string orientationString = firstDataset->GetTagValueAsString( tagImageOrientation ).value;
+      std::string firstOriginString = firstDataset->GetTagValueAsString( tagImagePositionPatient ).value;
+      std::string lastOriginString = lastDataset->GetTagValueAsString( tagImagePositionPatient ).value;
 
       result.FlagGantryTilt( GantryTiltInformation::MakeFromTagValues( firstOriginString, lastOriginString, orientationString, numberOfSlicesApart ));
     }
     catch (...)
     {
       // just do not flag anything, we are ok
     }
   }
 
   return result;
 }
diff --git a/Modules/DICOMReader/src/mitkITKDICOMSeriesReaderHelper.cpp b/Modules/DICOMReader/src/mitkITKDICOMSeriesReaderHelper.cpp
index abb1fd56ef..5ee2ac74e6 100644
--- a/Modules/DICOMReader/src/mitkITKDICOMSeriesReaderHelper.cpp
+++ b/Modules/DICOMReader/src/mitkITKDICOMSeriesReaderHelper.cpp
@@ -1,386 +1,386 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include <dcvrdt.h>
 
 #define BOOST_DATE_TIME_NO_LIB
 //Prevent unnecessary/unwanted auto link in this compilation when activating boost libraries in the MITK superbuild
 //It is necessary because BOOST_ALL_DYN_LINK overwrites BOOST_DATE_TIME_NO_LIB
 #if defined(BOOST_ALL_DYN_LINK)
   #undef BOOST_ALL_DYN_LINK
 #endif
 
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 
 #include "mitkITKDICOMSeriesReaderHelper.h"
 #include "mitkITKDICOMSeriesReaderHelper.txx"
 
 #include "mitkDICOMGDCMTagScanner.h"
 #include "mitkArbitraryTimeGeometry.h"
 
 #define switch3DCase(IOType, T) \
   case IOType: return LoadDICOMByITK< T >(filenames, correctTilt, tiltInfo, io);
 
 bool
   mitk::ITKDICOMSeriesReaderHelper
   ::CanHandleFile(const std::string& filename)
 {
   MITK_DEBUG << "ITKDICOMSeriesReaderHelper::CanHandleFile " << filename;
   itk::GDCMImageIO::Pointer tester = itk::GDCMImageIO::New();
   return tester->CanReadFile(filename.c_str());
 }
 
 mitk::Image::Pointer
   mitk::ITKDICOMSeriesReaderHelper
   ::Load( const StringContainer& filenames, bool correctTilt, const GantryTiltInformation& tiltInfo )
 {
   if( filenames.empty() )
   {
     MITK_DEBUG << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
     return nullptr; // this is not actually an error but the result is very simple
   }
 
   typedef itk::GDCMImageIO DcmIoType;
   DcmIoType::Pointer io = DcmIoType::New();
 
   try
   {
     if (io->CanReadFile(filenames.front().c_str()))
     {
       io->SetFileName(filenames.front().c_str());
       io->ReadImageInformation();
 
       if (io->GetPixelType() == itk::ImageIOBase::SCALAR)
       {
         switch (io->GetComponentType())
         {
           switch3DCase(DcmIoType::UCHAR, unsigned char)
             switch3DCase(DcmIoType::CHAR, char)
             switch3DCase(DcmIoType::USHORT, unsigned short)
             switch3DCase(DcmIoType::SHORT, short)
             switch3DCase(DcmIoType::UINT, unsigned int)
             switch3DCase(DcmIoType::INT, int)
             switch3DCase(DcmIoType::ULONG, long unsigned int)
             switch3DCase(DcmIoType::LONG, long int)
             switch3DCase(DcmIoType::FLOAT, float)
             switch3DCase(DcmIoType::DOUBLE, double)
         default:
           MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
       else if (io->GetPixelType() == itk::ImageIOBase::RGB)
       {
         switch (io->GetComponentType())
         {
           switch3DCase(DcmIoType::UCHAR, itk::RGBPixel<unsigned char>)
             switch3DCase(DcmIoType::CHAR, itk::RGBPixel<char>)
             switch3DCase(DcmIoType::USHORT, itk::RGBPixel<unsigned short>)
             switch3DCase(DcmIoType::SHORT, itk::RGBPixel<short>)
             switch3DCase(DcmIoType::UINT, itk::RGBPixel<unsigned int>)
             switch3DCase(DcmIoType::INT, itk::RGBPixel<int>)
             switch3DCase(DcmIoType::ULONG, itk::RGBPixel<long unsigned int>)
             switch3DCase(DcmIoType::LONG, itk::RGBPixel<long int>)
             switch3DCase(DcmIoType::FLOAT, itk::RGBPixel<float>)
             switch3DCase(DcmIoType::DOUBLE, itk::RGBPixel<double>)
         default:
           MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
 
       MITK_ERROR << "Unsupported DICOM pixel type";
       return nullptr;
     }
   }
   catch(itk::MemoryAllocationError& e)
   {
     MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
   }
   catch(std::exception& e)
   {
     MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
   }
   catch(...)
   {
     MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
   }
 
   return nullptr;
 }
 
 #define switch3DnTCase(IOType, T) \
   case IOType: return LoadDICOMByITK3DnT< T >(filenamesLists, correctTilt, tiltInfo, io);
 
 mitk::Image::Pointer
   mitk::ITKDICOMSeriesReaderHelper
   ::Load3DnT( const StringContainerList& filenamesLists, bool correctTilt, const GantryTiltInformation& tiltInfo )
 {
   if( filenamesLists.empty() || filenamesLists.front().empty() )
   {
     MITK_DEBUG << "Calling LoadDicomSeries with empty filename string container. Probably invalid application logic.";
     return nullptr; // this is not actually an error but the result is very simple
   }
 
   typedef itk::GDCMImageIO DcmIoType;
   DcmIoType::Pointer io = DcmIoType::New();
 
   try
   {
     if (io->CanReadFile(filenamesLists.front().front().c_str()))
     {
       io->SetFileName(filenamesLists.front().front().c_str());
       io->ReadImageInformation();
 
       if (io->GetPixelType() == itk::ImageIOBase::SCALAR)
       {
         switch (io->GetComponentType())
         {
           switch3DnTCase(DcmIoType::UCHAR, unsigned char)
             switch3DnTCase(DcmIoType::CHAR, char)
             switch3DnTCase(DcmIoType::USHORT, unsigned short)
             switch3DnTCase(DcmIoType::SHORT, short)
             switch3DnTCase(DcmIoType::UINT, unsigned int)
             switch3DnTCase(DcmIoType::INT, int)
             switch3DnTCase(DcmIoType::ULONG, long unsigned int)
             switch3DnTCase(DcmIoType::LONG, long int)
             switch3DnTCase(DcmIoType::FLOAT, float)
             switch3DnTCase(DcmIoType::DOUBLE, double)
         default:
           MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
       else if (io->GetPixelType() == itk::ImageIOBase::RGB)
       {
         switch (io->GetComponentType())
         {
           switch3DnTCase(DcmIoType::UCHAR, itk::RGBPixel<unsigned char>)
             switch3DnTCase(DcmIoType::CHAR, itk::RGBPixel<char>)
             switch3DnTCase(DcmIoType::USHORT, itk::RGBPixel<unsigned short>)
             switch3DnTCase(DcmIoType::SHORT, itk::RGBPixel<short>)
             switch3DnTCase(DcmIoType::UINT, itk::RGBPixel<unsigned int>)
             switch3DnTCase(DcmIoType::INT, itk::RGBPixel<int>)
             switch3DnTCase(DcmIoType::ULONG, itk::RGBPixel<long unsigned int>)
             switch3DnTCase(DcmIoType::LONG, itk::RGBPixel<long int>)
             switch3DnTCase(DcmIoType::FLOAT, itk::RGBPixel<float>)
             switch3DnTCase(DcmIoType::DOUBLE, itk::RGBPixel<double>)
         default:
           MITK_ERROR << "Found unsupported DICOM scalar pixel type: (enum value) " << io->GetComponentType();
         }
       }
 
       MITK_ERROR << "Unsupported DICOM pixel type";
       return nullptr;
     }
   }
   catch(itk::MemoryAllocationError& e)
   {
     MITK_ERROR << "Out of memory. Cannot load DICOM series: " << e.what();
   }
   catch(std::exception& e)
   {
     MITK_ERROR << "Error encountered when loading DICOM series:" << e.what();
   }
   catch(...)
   {
     MITK_ERROR << "Unspecified error encountered when loading DICOM series.";
   }
 
   return nullptr;
 }
 
 bool ConvertDICOMDateTimeString(const std::string& dateString, const std::string& timeString, OFDateTime& time)
 {
   OFString content(timeString.c_str());
 
   if (!dateString.empty())
   {
     content = OFString(dateString.c_str()).append(content);
   }
 
   OFCondition result = DcmDateTime::getOFDateTimeFromString(content,time);
 
   return result.good();
 }
 
 boost::posix_time::ptime ConvertOFDateTimeToPTime(const OFDateTime& time)
 {
   boost::gregorian::date boostDate(time.getDate().getYear(),time.getDate().getMonth(),time.getDate().getDay());
   boost::posix_time::time_duration boostTime = boost::posix_time::hours(time.getTime().getHour())
                                               +boost::posix_time::minutes(time.getTime().getMinute())
                                               +boost::posix_time::seconds(time.getTime().getSecond())
                                               +boost::posix_time::milliseconds(time.getTime().getMilliSecond());
 
   boost::posix_time::ptime result(boostDate,boostTime);
 
   return result;
 }
 
 OFDateTime GetLowerDateTime(const OFDateTime& time1, const OFDateTime& time2)
 {
   OFDateTime result = time1;
 
   if ((time2.getDate()<time1.getDate()) ||
       ((time2.getDate() == time1.getDate()) && (time2.getTime()<time1.getTime())))
   {
     result = time2;
   }
 
   return result;
 }
 
 OFDateTime GetUpperDateTime(const OFDateTime& time1, const OFDateTime& time2)
 {
   OFDateTime result = time1;
 
   if ((time2.getDate()>time1.getDate()) ||
       ((time2.getDate() == time1.getDate()) && (time2.getTime()>time1.getTime())))
   {
     result = time2;
   }
 
   return result;
 }
 
 double ComputeMiliSecDuration(const OFDateTime& start, const OFDateTime& stop)
 {
   boost::posix_time::ptime startTime = ConvertOFDateTimeToPTime(start);
   boost::posix_time::ptime stopTime = ConvertOFDateTimeToPTime(stop);
 
   ::boost::posix_time::time_duration duration = stopTime - startTime;
 
   double result = duration.total_milliseconds();
 
   return result;
 }
 
 bool
   mitk::ITKDICOMSeriesReaderHelper::ExtractTimeBoundsOfTimeStep (const StringContainer& filenamesOfTimeStep, DateTimeBounds& bounds)
 {
   DICOMTag acquisitionDateTag(0x0008, 0x0022);
   DICOMTag acquisitionTimeTag(0x0008, 0x0032);
 
   DICOMGDCMTagScanner::Pointer filescanner = DICOMGDCMTagScanner::New();
   filescanner->SetInputFiles(filenamesOfTimeStep);
   filescanner->AddTag( acquisitionDateTag );
   filescanner->AddTag( acquisitionTimeTag );
   filescanner->Scan();
 
   DICOMGDCMImageFrameList frameList = filescanner->GetFrameInfoList();
 
   bool result = false;
   bool first = true;
 
   for (DICOMGDCMImageFrameList::const_iterator pos = frameList.begin(); pos != frameList.end(); ++pos)
   {
-    std::string dateStr = (*pos)->GetTagValueAsString(acquisitionDateTag);
-    std::string timeStr = (*pos)->GetTagValueAsString(acquisitionTimeTag);
+    std::string dateStr = (*pos)->GetTagValueAsString(acquisitionDateTag).value;
+    std::string timeStr = (*pos)->GetTagValueAsString(acquisitionTimeTag).value;
 
     OFDateTime time;
     bool convertResult = ConvertDICOMDateTimeString(dateStr, timeStr, time);
 
     if (convertResult)
     {
       if (first)
       {
         bounds[0] = time;
         bounds[1] = time;
         first = false;
       }
       else
       {
         bounds[0] = GetLowerDateTime(bounds[0], time);
         bounds[1] = GetUpperDateTime(bounds[1], time);
       }
       result = true;
     }
   }
 
   return result;
 };
 
 mitk::ITKDICOMSeriesReaderHelper::TimeBoundsList
   mitk::ITKDICOMSeriesReaderHelper::ExtractTimeBoundsOfTimeSteps (const StringContainerList& filenamesOfTimeSteps)
 {
   TimeBoundsList result;
 
   OFDateTime baseLine;
   bool baseLineSet = false;
 
   for(StringContainerList::const_iterator pos = filenamesOfTimeSteps.begin(); pos!=filenamesOfTimeSteps.end(); ++pos)
   {
     TimeBounds bounds(0.0);
     DateTimeBounds dateTimeBounds;
 
     if(ExtractTimeBoundsOfTimeStep(*pos,dateTimeBounds))
     {
       if(!baseLineSet)
       {
         baseLineSet = true;
         baseLine = dateTimeBounds[0];
       }
 
       bounds[0] = ComputeMiliSecDuration(baseLine, dateTimeBounds[0]);
       bounds[1] = ComputeMiliSecDuration(baseLine, dateTimeBounds[1]);
     }
 
     result.push_back(bounds);
   }
 
   return result;
 };
 
 mitk::TimeGeometry::Pointer
   mitk::ITKDICOMSeriesReaderHelper::
   GenerateTimeGeometry(const BaseGeometry* templateGeometry, const TimeBoundsList& boundsList)
 {
   TimeGeometry::Pointer timeGeometry;
 
   double check = 0.0;
   for (TimeBoundsList::size_type pos = 0; pos < boundsList.size(); ++pos)
   {
     check += boundsList[pos][0];
     check += boundsList[pos][1];
   }
 
   if (check == 0.0)
   { //if all bounds are zero we assume that the bounds could not be correctly determined
     //and as a fallback generate a time geometry in the old mitk style
     ProportionalTimeGeometry::Pointer newTimeGeometry = ProportionalTimeGeometry::New();
     newTimeGeometry->Initialize(templateGeometry, boundsList.size());
     timeGeometry = newTimeGeometry.GetPointer();
   }
   else
   {
     ArbitraryTimeGeometry::Pointer newTimeGeometry = ArbitraryTimeGeometry::New();
     newTimeGeometry->ClearAllGeometries();
     newTimeGeometry->ReserveSpaceForGeometries(boundsList.size());
 
     for (TimeBoundsList::size_type pos = 0; pos < boundsList.size(); ++pos)
     {
       TimeBounds bounds = boundsList[pos];
       if (pos + 1 < boundsList.size())
       {
         bounds[1] = boundsList[pos + 1][0];
       }
 
       newTimeGeometry->AppendTimeStepClone(templateGeometry, bounds[1], bounds[0]);
     }
     timeGeometry = newTimeGeometry.GetPointer();
   }
 
   return timeGeometry;
 };
diff --git a/Modules/DICOMReader/src/mitkNormalDirectionConsistencySorter.cpp b/Modules/DICOMReader/src/mitkNormalDirectionConsistencySorter.cpp
index d478287f86..90b9e86c4b 100644
--- a/Modules/DICOMReader/src/mitkNormalDirectionConsistencySorter.cpp
+++ b/Modules/DICOMReader/src/mitkNormalDirectionConsistencySorter.cpp
@@ -1,171 +1,171 @@
 /*=================================================================== 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.
 
 ===================================================================*/
 
 //#define MBILOG_ENABLE_DEBUG
 
 #include "mitkNormalDirectionConsistencySorter.h"
 
 #include <algorithm>
 
 mitk::NormalDirectionConsistencySorter
 ::NormalDirectionConsistencySorter()
 :DICOMDatasetSorter()
 {
 }
 
 mitk::NormalDirectionConsistencySorter
 ::NormalDirectionConsistencySorter(const NormalDirectionConsistencySorter& other )
 :DICOMDatasetSorter(other)
 {
 }
 
 mitk::NormalDirectionConsistencySorter
 ::~NormalDirectionConsistencySorter()
 {
 }
 
 void
 mitk::NormalDirectionConsistencySorter
 ::PrintConfiguration(std::ostream& os, const std::string& indent) const
 {
   os << indent << "NormalDirectionConsistencySorter" << std::endl;
 }
 
 
 mitk::NormalDirectionConsistencySorter&
 mitk::NormalDirectionConsistencySorter
 ::operator=(const NormalDirectionConsistencySorter& other)
 {
   if (this != &other)
   {
     DICOMDatasetSorter::operator=(other);
   }
   return *this;
 }
 
 bool
 mitk::NormalDirectionConsistencySorter
 ::operator==(const DICOMDatasetSorter& other) const
 {
   return dynamic_cast<const NormalDirectionConsistencySorter*>(&other) != nullptr;
 }
 
 
 mitk::DICOMTagList
 mitk::NormalDirectionConsistencySorter
 ::GetTagsOfInterest()
 {
   DICOMTagList tags;
   tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
   tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
 
   return tags;
 }
 
 void
 mitk::NormalDirectionConsistencySorter
 ::Sort()
 {
   DICOMDatasetList datasets = GetInput();
 
   if (datasets.size() > 1)
   {
     // at some point in the code, there is the expectation that
     // the direction of the slice normals is the same as the direction between
     // first and last slice origin. We need to make this sure here, because
     // we want to feed the files into itk::ImageSeriesReader with the consistent
     // setting of ReverseOrderOff.
 
     static const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
     static const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
 
     DICOMDatasetAccess* firstDS = datasets.front();
     DICOMDatasetAccess*  lastDS = datasets.back();
 
     // make sure here that the direction from slice to slice is the direction of
     // image normals...
-    const std::string imageOrientationString = firstDS->GetTagValueAsString( tagImageOrientation );
-    const std::string imagePositionPatientFirst = firstDS->GetTagValueAsString( tagImagePositionPatient );
-    const std::string imagePositionPatientLast = lastDS->GetTagValueAsString( tagImagePositionPatient );
+    const std::string imageOrientationString = firstDS->GetTagValueAsString( tagImageOrientation ).value;
+    const std::string imagePositionPatientFirst = firstDS->GetTagValueAsString(tagImagePositionPatient).value;
+    const std::string imagePositionPatientLast = lastDS->GetTagValueAsString(tagImagePositionPatient).value;
 
     Vector3D right; right.Fill(0.0);
     Vector3D up; up.Fill(0.0);
     bool hasOrientation(false);
     DICOMStringToOrientationVectors( imageOrientationString,
         right, up, hasOrientation );
 
     Point3D firstOrigin; firstOrigin.Fill(0.0f);
     bool firstHasOrigin(false);
     firstOrigin = DICOMStringToPoint3D( imagePositionPatientFirst, firstHasOrigin );
 
     Point3D lastOrigin; lastOrigin.Fill(0.0f);
     bool lastHasOrigin(false);
     lastOrigin = DICOMStringToPoint3D( imagePositionPatientLast, lastHasOrigin );
 
     Vector3D normal;
     normal[0] = right[1] * up[2] - right[2] * up[1];
     normal[1] = right[2] * up[0] - right[0] * up[2];
     normal[2] = right[0] * up[1] - right[1] * up[0];
     normal.Normalize();
 
     Vector3D directionOfSlices;
     directionOfSlices = lastOrigin - firstOrigin;
     directionOfSlices.Normalize();
 
     double projection = normal * directionOfSlices;
 
     MITK_DEBUG << "Making sense of \norientation '" << imageOrientationString
                << "'\nfirst position '" << imagePositionPatientFirst
                << "'\nlast position '" << imagePositionPatientLast << "'";
     MITK_DEBUG << "Normal: " << normal;
     MITK_DEBUG << "Direction of slices: " << directionOfSlices;
     MITK_DEBUG << "Projection of direction onto slice normal: " << projection;
 
     if ( projection < 0.0 )
     {
       MITK_DEBUG << "Need to reverse filenames";
       std::reverse( datasets.begin(), datasets.end() );
 
       m_TiltInfo = GantryTiltInformation::MakeFromTagValues(
           imagePositionPatientLast,
           imagePositionPatientFirst,
           imageOrientationString,
           datasets.size() - 1
           );
     }
     else
     {
       m_TiltInfo = GantryTiltInformation::MakeFromTagValues(
           imagePositionPatientFirst,
           imagePositionPatientLast,
           imageOrientationString,
           datasets.size() - 1
           );
     }
   }
   else // just ONE dataset, do not forget to reset tilt information
   {
     m_TiltInfo = GantryTiltInformation(); // empty info
   }
 
   this->SetNumberOfOutputs(1);
   this->SetOutput(0, datasets);
 }
 
 mitk::GantryTiltInformation
 mitk::NormalDirectionConsistencySorter
 ::GetTiltInformation() const
 {
   return m_TiltInfo;
 }
diff --git a/Modules/DICOMReader/src/mitkSortByImagePositionPatient.cpp b/Modules/DICOMReader/src/mitkSortByImagePositionPatient.cpp
index 6000f99d87..746372888a 100644
--- a/Modules/DICOMReader/src/mitkSortByImagePositionPatient.cpp
+++ b/Modules/DICOMReader/src/mitkSortByImagePositionPatient.cpp
@@ -1,168 +1,168 @@
 /*===================================================================
 
 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 "mitkSortByImagePositionPatient.h"
 #include "mitkDICOMTag.h"
 
 mitk::SortByImagePositionPatient
 ::SortByImagePositionPatient(DICOMSortCriterion::Pointer secondaryCriterion)
 :DICOMSortCriterion(secondaryCriterion)
 {
 }
 
 mitk::SortByImagePositionPatient
 ::~SortByImagePositionPatient()
 {
 }
 
 mitk::SortByImagePositionPatient
 ::SortByImagePositionPatient(const SortByImagePositionPatient& other )
 :DICOMSortCriterion(other)
 {
 }
 
 mitk::SortByImagePositionPatient&
 mitk::SortByImagePositionPatient
 ::operator=(const SortByImagePositionPatient& other)
 {
   if (this != &other)
   {
     DICOMSortCriterion::operator=(other);
   }
   return *this;
 }
 
 bool
 mitk::SortByImagePositionPatient
 ::operator==(const DICOMSortCriterion& other) const
 {
   return dynamic_cast<const SortByImagePositionPatient*>(&other) != nullptr; // same class
 }
 
 void
 mitk::SortByImagePositionPatient
 ::Print(std::ostream& os) const
 {
   os << "(0020,0032) Image Position (Patient) along normal of (0020,0037) Image Orientation (Patient)";
 }
 
 mitk::DICOMTagList
 mitk::SortByImagePositionPatient
 ::GetTagsOfInterest() const
 {
   DICOMTagList tags;
   tags.push_back( DICOMTag(0x0020, 0x0032) ); // ImagePositionPatient
   tags.push_back( DICOMTag(0x0020, 0x0037) ); // ImageOrientationPatient
 
   return tags;
 }
 
 bool
 mitk::SortByImagePositionPatient
 ::IsLeftBeforeRight(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right) const
 {
   bool possible(false);
   double distance = InternalNumericDistance(left, right, possible); // returns 0.0 if not possible
   if (possible)
   {
     return distance > 0.0;
   }
   else
   {
     return this->NextLevelIsLeftBeforeRight(left, right);
   }
 }
 
 double
 mitk::SortByImagePositionPatient
 ::InternalNumericDistance(const mitk::DICOMDatasetAccess* left, const mitk::DICOMDatasetAccess* right, bool& possible) const
 {
   // sort by distance to world origin, assuming (almost) equal orientation
   static const DICOMTag tagImagePositionPatient = DICOMTag(0x0020,0x0032); // Image Position (Patient)
   static const DICOMTag    tagImageOrientation = DICOMTag(0x0020, 0x0037); // Image Orientation
 
   Vector3D leftRight; leftRight.Fill(0.0);
   Vector3D leftUp; leftUp.Fill(0.0);
   bool leftHasOrientation(false);
-  DICOMStringToOrientationVectors( left->GetTagValueAsString( tagImageOrientation ),
+  DICOMStringToOrientationVectors( left->GetTagValueAsString( tagImageOrientation ).value,
                                    leftRight, leftUp, leftHasOrientation );
 
   Vector3D rightRight; rightRight.Fill(0.0);
   Vector3D rightUp; rightUp.Fill(0.0);
   bool rightHasOrientation(false);
-  DICOMStringToOrientationVectors( right->GetTagValueAsString( tagImageOrientation ),
+  DICOMStringToOrientationVectors(right->GetTagValueAsString(tagImageOrientation).value,
                                    rightRight, rightUp, rightHasOrientation );
 
   Point3D leftOrigin; leftOrigin.Fill(0.0f);
   bool leftHasOrigin(false);
-  leftOrigin = DICOMStringToPoint3D( left->GetTagValueAsString( tagImagePositionPatient ), leftHasOrigin );
+  leftOrigin = DICOMStringToPoint3D(left->GetTagValueAsString(tagImagePositionPatient).value, leftHasOrigin);
 
   Point3D rightOrigin; rightOrigin.Fill(0.0f);
   bool rightHasOrigin(false);
-  rightOrigin = DICOMStringToPoint3D( right->GetTagValueAsString( tagImagePositionPatient ), rightHasOrigin );
+  rightOrigin = DICOMStringToPoint3D(right->GetTagValueAsString(tagImagePositionPatient).value, rightHasOrigin);
 
   //   we tolerate very small differences in image orientation, since we got to know about
   //   acquisitions where these values change across a single series (7th decimal digit)
   //   (http://bugs.mitk.org/show_bug.cgi?id=12263)
   //   still, we want to check if our assumption of 'almost equal' orientations is valid
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     if (   fabs(leftRight[dim] - rightRight[dim]) > 0.0001
         || fabs(leftUp[dim] - rightUp[dim]) > 0.0001)
     {
       MITK_ERROR << "Dicom images have different orientations.";
       throw std::logic_error("Dicom images have different orientations. Call GetSeries() first to separate images.");
     }
   }
 
   Vector3D normal;
   normal[0] = leftRight[1] * leftUp[2] - leftRight[2] * leftUp[1];
   normal[1] = leftRight[2] * leftUp[0] - leftRight[0] * leftUp[2];
   normal[2] = leftRight[0] * leftUp[1] - leftRight[1] * leftUp[0];
 
   double leftDistance = 0.0;
   double rightDistance = 0.0;
 
   // this computes the distance from world origin (0,0,0) ALONG THE NORMAL of the image planes
   for (unsigned int dim = 0; dim < 3; ++dim)
   {
     leftDistance += normal[dim] * leftOrigin[dim];
     rightDistance += normal[dim] * rightOrigin[dim];
   }
 
   // if we can sort by just comparing the distance, we do exactly that
   if ( fabs(leftDistance - rightDistance) >= mitk::eps)
   {
     possible = true;
     // default: compare position
     return rightDistance - leftDistance; // if (left < right> ==> diff > 0
   }
   else
   {
     possible = false;
     return 0.0;
   }
 }
 
 
 double
 mitk::SortByImagePositionPatient
 ::NumericDistance(const mitk::DICOMDatasetAccess* from, const mitk::DICOMDatasetAccess* to) const
 {
   bool possible(false);
   double retVal = InternalNumericDistance(from, to, possible); // returns 0.0 if not possible
   return possible ? retVal : 0.0;
 }
diff --git a/Modules/DICOMReader/src/mitkThreeDnTDICOMSeriesReader.cpp b/Modules/DICOMReader/src/mitkThreeDnTDICOMSeriesReader.cpp
index 0543e5f8c5..ed81496cfb 100644
--- a/Modules/DICOMReader/src/mitkThreeDnTDICOMSeriesReader.cpp
+++ b/Modules/DICOMReader/src/mitkThreeDnTDICOMSeriesReader.cpp
@@ -1,264 +1,264 @@
 /*===================================================================
 
 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 "mitkThreeDnTDICOMSeriesReader.h"
 #include "mitkITKDICOMSeriesReaderHelper.h"
 
 mitk::ThreeDnTDICOMSeriesReader
 ::ThreeDnTDICOMSeriesReader(unsigned int decimalPlacesForOrientation)
 :DICOMITKSeriesGDCMReader(decimalPlacesForOrientation)
 ,m_Group3DandT(true)
 {
 }
 
 mitk::ThreeDnTDICOMSeriesReader
 ::ThreeDnTDICOMSeriesReader(const ThreeDnTDICOMSeriesReader& other )
 :DICOMITKSeriesGDCMReader(other)
 ,m_Group3DandT(true)
 {
 }
 
 mitk::ThreeDnTDICOMSeriesReader
 ::~ThreeDnTDICOMSeriesReader()
 {
 }
 
 mitk::ThreeDnTDICOMSeriesReader&
 mitk::ThreeDnTDICOMSeriesReader
 ::operator=(const ThreeDnTDICOMSeriesReader& other)
 {
   if (this != &other)
   {
     DICOMITKSeriesGDCMReader::operator=(other);
     this->m_Group3DandT = other.m_Group3DandT;
   }
   return *this;
 }
 
 bool
 mitk::ThreeDnTDICOMSeriesReader
 ::operator==(const DICOMFileReader& other) const
 {
   if (const Self* otherSelf = dynamic_cast<const Self*>(&other))
   {
     return
        DICOMITKSeriesGDCMReader::operator==(other)
     && this->m_Group3DandT == otherSelf->m_Group3DandT;
   }
   else
   {
     return false;
   }
 }
 
 void
 mitk::ThreeDnTDICOMSeriesReader
 ::SetGroup3DandT(bool on)
 {
   m_Group3DandT = on;
 }
 
 bool
 mitk::ThreeDnTDICOMSeriesReader
 ::GetGroup3DandT() const
 {
   return m_Group3DandT;
 }
 
 mitk::DICOMITKSeriesGDCMReader::SortingBlockList
 mitk::ThreeDnTDICOMSeriesReader
 ::Condense3DBlocks(SortingBlockList& resultOf3DGrouping)
 {
   if (!m_Group3DandT)
   {
     return resultOf3DGrouping; // don't work if nobody asks us to
   }
 
   SortingBlockList remainingBlocks = resultOf3DGrouping;
 
   SortingBlockList non3DnTBlocks;
   SortingBlockList true3DnTBlocks;
   std::vector<unsigned int> true3DnTBlocksTimeStepCount;
 
   // we should describe our need for this tag as needed via a function
   // (however, we currently know that the superclass will always need this tag)
   const DICOMTag tagImagePositionPatient(0x0020, 0x0032);
 
   while (!remainingBlocks.empty())
   {
     // new block to fill up
     DICOMGDCMImageFrameList& firstBlock = remainingBlocks.front();
     DICOMGDCMImageFrameList current3DnTBlock = firstBlock;
     int current3DnTBlockNumberOfTimeSteps = 1;
 
     // get block characteristics of first block
     unsigned int currentBlockNumberOfSlices = firstBlock.size();
-    std::string currentBlockFirstOrigin = firstBlock.front()->GetTagValueAsString( tagImagePositionPatient );
-    std::string currentBlockLastOrigin  =  firstBlock.back()->GetTagValueAsString( tagImagePositionPatient );
+    std::string currentBlockFirstOrigin = firstBlock.front()->GetTagValueAsString( tagImagePositionPatient ).value;
+    std::string currentBlockLastOrigin  =  firstBlock.back()->GetTagValueAsString( tagImagePositionPatient ).value;
 
     remainingBlocks.pop_front();
 
     // compare all other blocks against the first one
     for (auto otherBlockIter = remainingBlocks.begin();
          otherBlockIter != remainingBlocks.end();
          /*++otherBlockIter*/) // <-- inside loop
     {
       // get block characteristics from first block
       DICOMGDCMImageFrameList& otherBlock = *otherBlockIter;
 
       unsigned int otherBlockNumberOfSlices = otherBlock.size();
-      std::string otherBlockFirstOrigin = otherBlock.front()->GetTagValueAsString( tagImagePositionPatient );
-      std::string otherBlockLastOrigin  =  otherBlock.back()->GetTagValueAsString( tagImagePositionPatient );
+      std::string otherBlockFirstOrigin = otherBlock.front()->GetTagValueAsString( tagImagePositionPatient ).value;
+      std::string otherBlockLastOrigin  =  otherBlock.back()->GetTagValueAsString( tagImagePositionPatient ).value;
 
       // add matching blocks to current3DnTBlock
       // keep other blocks for later
       if (   otherBlockNumberOfSlices == currentBlockNumberOfSlices
           && otherBlockFirstOrigin == currentBlockFirstOrigin
           && otherBlockLastOrigin == currentBlockLastOrigin
           )
       { // matching block
         ++current3DnTBlockNumberOfTimeSteps;
         current3DnTBlock.insert( current3DnTBlock.end(), otherBlock.begin(), otherBlock.end() ); // append
         // remove this block from remainingBlocks
         otherBlockIter = remainingBlocks.erase(otherBlockIter); // make sure iterator otherBlockIter is valid afterwards
       }
       else
       {
         ++otherBlockIter;
       }
     }
 
     // in any case, we now now all about the first block of our list ...
     // ... and we wither call it 3D o 3D+t
     if (current3DnTBlockNumberOfTimeSteps > 1)
     {
       true3DnTBlocks.push_back(current3DnTBlock);
       true3DnTBlocksTimeStepCount.push_back(current3DnTBlockNumberOfTimeSteps);
     }
     else
     {
       non3DnTBlocks.push_back(current3DnTBlock);
     }
   }
 
   // create output for real 3D+t blocks (other outputs will be created by superclass)
   // set 3D+t flag on output block
   this->SetNumberOfOutputs( true3DnTBlocks.size() );
   unsigned int o = 0;
   for (auto blockIter = true3DnTBlocks.begin();
        blockIter != true3DnTBlocks.end();
        ++o, ++blockIter)
   {
     // bad copy&paste code from DICOMITKSeriesGDCMReader, should be handled in a better way
     DICOMGDCMImageFrameList& gdcmFrameInfoList = *blockIter;
     assert(!gdcmFrameInfoList.empty());
 
     // reverse frames if necessary
     // update tilt information from absolute last sorting
     DICOMDatasetList datasetList = ToDICOMDatasetList( gdcmFrameInfoList );
     m_NormalDirectionConsistencySorter->SetInput( datasetList );
     m_NormalDirectionConsistencySorter->Sort();
     DICOMGDCMImageFrameList sortedGdcmInfoFrameList = FromDICOMDatasetList( m_NormalDirectionConsistencySorter->GetOutput(0) );
     const GantryTiltInformation& tiltInfo = m_NormalDirectionConsistencySorter->GetTiltInformation();
 
     // set frame list for current block
     DICOMImageFrameList frameList = ToDICOMImageFrameList( sortedGdcmInfoFrameList );
     assert(!frameList.empty());
 
     DICOMImageBlockDescriptor block;
     block.SetTagCache( this->GetTagCache() ); // important: this must be before SetImageFrameList(), because SetImageFrameList will trigger reading of lots of interesting tags!
     block.SetImageFrameList( frameList );
     block.SetTiltInformation( tiltInfo );
 
     block.SetFlag("3D+t", true);
     block.SetIntProperty("timesteps", true3DnTBlocksTimeStepCount[o]);
     MITK_DEBUG << "Found " << true3DnTBlocksTimeStepCount[o] << " timesteps";
 
     this->SetOutput( o, block );
   }
 
   return non3DnTBlocks;
 }
 
 bool
 mitk::ThreeDnTDICOMSeriesReader
 ::LoadImages()
 {
   bool success = true;
 
   unsigned int numberOfOutputs = this->GetNumberOfOutputs();
   for (unsigned int o = 0; o < numberOfOutputs; ++o)
   {
     DICOMImageBlockDescriptor& block = this->InternalGetOutput(o);
 
     if (block.GetFlag("3D+t", false))
     {
       success &= this->LoadMitkImageForOutput(o);
     }
     else
     {
       success &= DICOMITKSeriesGDCMReader::LoadMitkImageForOutput(o); // let superclass handle non-3D+t
     }
   }
 
   return success;
 }
 
 bool
 mitk::ThreeDnTDICOMSeriesReader
 ::LoadMitkImageForImageBlockDescriptor(DICOMImageBlockDescriptor& block) const
 {
   PushLocale();
   const DICOMImageFrameList& frames = block.GetImageFrameList();
   const GantryTiltInformation tiltInfo = block.GetTiltInformation();
   bool hasTilt = tiltInfo.IsRegularGantryTilt();
 
   int numberOfTimesteps = block.GetIntProperty("timesteps", 1);
 
   if (numberOfTimesteps == 1)
   {
     return DICOMITKSeriesGDCMReader::LoadMitkImageForImageBlockDescriptor(block);
   }
 
   int numberOfFramesPerTimestep = frames.size() / numberOfTimesteps;
   assert( int(double((double)frames.size() / (double)numberOfTimesteps ))
        == numberOfFramesPerTimestep ); // this should hold
 
   ITKDICOMSeriesReaderHelper::StringContainerList filenamesPerTimestep;
   for (int timeStep = 0; timeStep<numberOfTimesteps; ++timeStep)
   {
     // use numberOfFramesPerTimestep frames for a new item in filenamesPerTimestep
     ITKDICOMSeriesReaderHelper::StringContainer filenamesOfThisTimeStep;
     auto timeStepStart = frames.begin() + timeStep * numberOfFramesPerTimestep;
     auto timeStepEnd   = frames.begin() + (timeStep+1) * numberOfFramesPerTimestep;
     for (auto frameIter = timeStepStart;
         frameIter != timeStepEnd;
         ++frameIter)
     {
       filenamesOfThisTimeStep.push_back( (*frameIter)->Filename );
     }
     filenamesPerTimestep.push_back( filenamesOfThisTimeStep );
   }
 
   mitk::ITKDICOMSeriesReaderHelper helper;
   mitk::Image::Pointer mitkImage = helper.Load3DnT( filenamesPerTimestep, m_FixTiltByShearing && hasTilt, tiltInfo );
 
   block.SetMitkImage( mitkImage );
 
   PopLocale();
 
   return true;
 }
diff --git a/Modules/DICOMReader/test/mitkDICOMFileReaderTestHelper.h b/Modules/DICOMReader/test/mitkDICOMFileReaderTestHelper.h
index 84794ecde1..a1fe977ec4 100644
--- a/Modules/DICOMReader/test/mitkDICOMFileReaderTestHelper.h
+++ b/Modules/DICOMReader/test/mitkDICOMFileReaderTestHelper.h
@@ -1,169 +1,176 @@
 /*===================================================================
 
 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 mitkDICOMFileReaderTestHelper_h
 #define mitkDICOMFileReaderTestHelper_h
 
 #include "mitkDICOMFileReader.h"
 #include "mitkDICOMEnums.h"
 
 #include "mitkTestingMacros.h"
 
 namespace mitk
 {
 
 class DICOMFileReaderTestHelper
 {
   public:
 
 static StringList& GetInputFilenames()
 {
   static StringList inputs;
   return inputs;
 }
 
 static void SetTestInputFilenames(int argc, char* argv[])
 {
   mitk::StringList inputFiles;
 
   for (int a = 1; a < argc; ++a)
   {
     inputFiles.push_back( argv[a] );
   }
 
   GetInputFilenames() = inputFiles;
 }
 
 
 static void SetTestInputFilenames(const StringList& filenames)
 {
   GetInputFilenames() = filenames;
 }
 
 static void TestInputFilenames(DICOMFileReader* reader)
 {
   StringList inputFiles = GetInputFilenames();
   reader->SetInputFiles( inputFiles );
 
   const StringList& inputFilesReturned = reader->GetInputFiles();
   MITK_TEST_CONDITION( inputFilesReturned.size() == inputFiles.size(), "Input file list is received")
   MITK_TEST_CONDITION( reader->GetNumberOfOutputs() == 0, "No outputs without analysis")
 }
 
 static void TestOutputsContainInputs(DICOMFileReader* reader)
 {
   StringList inputFiles = GetInputFilenames();
   reader->SetInputFiles( inputFiles );
 
   reader->AnalyzeInputFiles();
 
   StringList allSortedInputsFiles;
 
   unsigned int numberOfOutputs = reader->GetNumberOfOutputs();
   for (unsigned int o = 0; o < numberOfOutputs; ++o)
   {
     const DICOMImageBlockDescriptor block = reader->GetOutput(o);
 
     const DICOMImageFrameList& outputFiles = block.GetImageFrameList();
     for(auto iter = outputFiles.cbegin();
         iter != outputFiles.cend();
         ++iter)
     {
       // check that output is part of input
       auto inputPositionOfCurrentOutput = std::find( inputFiles.cbegin(), inputFiles.cend(), (*iter)->Filename );
       if (inputPositionOfCurrentOutput !=  inputFiles.cend())
       {
         // check that output is only part of ONE output
         auto outputPositionOfCurrentOutput = std::find( allSortedInputsFiles.cbegin(), allSortedInputsFiles.cend(), (*iter)->Filename );
         if (outputPositionOfCurrentOutput == allSortedInputsFiles.cend())
         {
           // was not in list before
           allSortedInputsFiles.push_back( *inputPositionOfCurrentOutput );
         }
         else
         {
           reader->PrintOutputs(std::cout);
           MITK_TEST_CONDITION_REQUIRED(false, "File '" << (*iter)->Filename << "' appears in TWO outputs. Readers are expected to use each frame only once." )
         }
       }
       else
       {
         reader->PrintOutputs(std::cout);
         MITK_TEST_CONDITION_REQUIRED(false, "File '" << (*iter)->Filename << "' appears in output, but it was never part of the input list." )
       }
     }
   }
 
   MITK_TEST_CONDITION( allSortedInputsFiles.size() == inputFiles.size(), "Output list size (" << allSortedInputsFiles.size() << ") equals input list size (" << inputFiles.size() << ")" )
 
   try
   {
     const DICOMImageBlockDescriptor block = reader->GetOutput( inputFiles.size() );
     MITK_TEST_CONDITION(false, "Invalid indices for GetOutput() should throw exception")
   }
   catch( std::invalid_argument& )
   {
     MITK_TEST_CONDITION(true, "Invalid indices for GetOutput() should throw exception")
   }
 }
 
 static void TestMitkImagesAreLoaded( DICOMFileReader* reader,
                                      const std::unordered_map<const char*, mitk::DICOMTag>& requestedTags,
-                                     const std::unordered_map<const char*, const char*>& expectedProperties )
+                                     const std::unordered_map<std::string, std::string>& expectedProperties )
 {
   StringList inputFiles = GetInputFilenames();
   reader->SetInputFiles( inputFiles );
 
   reader->AnalyzeInputFiles();
   reader->LoadImages();
 
   unsigned int numberOfOutputs = reader->GetNumberOfOutputs();
   for (unsigned int o = 0; o < numberOfOutputs; ++o)
   {
     const DICOMImageBlockDescriptor block = reader->GetOutput(o);
 
     const DICOMImageFrameList& outputFiles = block.GetImageFrameList();
     const mitk::Image::Pointer mitkImage = block.GetMitkImage();
-    auto iter2 = expectedProperties.cbegin();
 
-    for ( auto iter = requestedTags.cbegin(); iter != requestedTags.cend(); ++iter, ++iter2 )
+    for ( auto iter = requestedTags.cbegin(); iter != requestedTags.cend(); ++iter)
     {
       mitk::BaseProperty* property = mitkImage->GetProperty( iter->first ).GetPointer();
       MITK_TEST_CONDITION( property != nullptr,
                            "Requested Tag is available as Property in Image" );
+      if (property)
+      {
+        MITK_INFO << iter->first << " / " << property->GetNameOfClass();
+        auto expectfinding = expectedProperties.find(iter->first);
 
-      MITK_INFO << iter->first << " / " << property->GetNameOfClass();
+        if (expectfinding != expectedProperties.end())
+        {
+          MITK_TEST_CONDITION(std::string(property->GetNameOfClass()) == expectfinding->second, "Property type is as expected");
+        }
+      }
     }
 
 
     MITK_DEBUG << "-------------------------------------------";
     MITK_DEBUG << "Output " << o << " at " << (void*) mitkImage.GetPointer();
     MITK_DEBUG << "  Number of files: " << outputFiles.size();
     MITK_DEBUG << "  Dimensions: " << mitkImage->GetDimension(0) << " " << mitkImage->GetDimension(1) << " " << mitkImage->GetDimension(2);
   }
 }
 
 static mitk::BaseProperty::Pointer DummyTagToPropertyFunctor( const mitk::StringLookupTable& )
 {
   return mitk::BaseProperty::Pointer();
 }
 
 
 }; // end test class
 
 } // namespace
 
 #endif
diff --git a/Modules/DICOMReader/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp b/Modules/DICOMReader/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
index fa761afcef..eca910dfd3 100644
--- a/Modules/DICOMReader/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
+++ b/Modules/DICOMReader/test/mitkDICOMITKSeriesGDCMReaderBasicsTest.cpp
@@ -1,134 +1,125 @@
 /*===================================================================
 
 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 "mitkDICOMITKSeriesGDCMReader.h"
 #include "mitkDICOMFileReaderTestHelper.h"
 #include "mitkDICOMFilenameSorter.h"
 #include "mitkDICOMTagBasedSorter.h"
 #include "mitkDICOMSortByTag.h"
 
 #include "mitkTestingMacros.h"
 
 #include <unordered_map>
 #include "mitkStringProperty.h"
 
 using mitk::DICOMTag;
 
 int mitkDICOMITKSeriesGDCMReaderBasicsTest(int argc, char* argv[])
 {
   MITK_TEST_BEGIN("mitkDICOMITKSeriesGDCMReaderBasicsTest");
 
   mitk::DICOMITKSeriesGDCMReader::Pointer gdcmReader = mitk::DICOMITKSeriesGDCMReader::New();
   MITK_TEST_CONDITION_REQUIRED(gdcmReader.IsNotNull(), "DICOMITKSeriesGDCMReader can be instantiated.");
 
   mitk::DICOMFileReaderTestHelper::SetTestInputFilenames( argc,argv );
 
-  std::unordered_map<const char*, const char*> expectedPropertyTypes;
+  std::unordered_map<std::string, std::string> expectedPropertyTypes;
   std::unordered_map<const char*, mitk::DICOMTag> additionalTags;
-  additionalTags.insert( std::make_pair( "Test1", DICOMTag( 0x0008, 0x005 ) ) );
-  expectedPropertyTypes.insert( std::make_pair( "Test1", "StringProperty" ) );
-
-  additionalTags.insert( std::make_pair( "Test2", DICOMTag( 0x0008, 0x008 ) ) );
-  expectedPropertyTypes.insert( std::make_pair( "Test2", "StringProperty" ) );
-
-  additionalTags.insert( std::make_pair( "Test3", DICOMTag( 0x0008, 0x0060 ) ) );
-  expectedPropertyTypes.insert( std::make_pair( "Test3", "StringProperty" ) );
-
-  additionalTags.insert( std::make_pair( "Test4", DICOMTag( 0x0008, 0x1070 ) ) );
-  expectedPropertyTypes.insert( std::make_pair( "Test4", "StringProperty" ) );
-
-  additionalTags.insert( std::make_pair( "Test5", DICOMTag( 0x0020, 0x1041 ) ) );
-  expectedPropertyTypes.insert( std::make_pair( "Test5", "StringLookupTableProperty" ) );
+  additionalTags.insert( std::make_pair( "Test1", DICOMTag( 0x0008, 0x0005 ) ) );
+  additionalTags.insert( std::make_pair( "Test2", DICOMTag( 0x0008, 0x0060 ) ) );
+  additionalTags.insert( std::make_pair( "Test3", DICOMTag( 0x0020, 0x1041 ) ) );
 
   gdcmReader->SetAdditionalTagsOfInterest( additionalTags );
 
   // check the Set/GetInput function
   mitk::DICOMFileReaderTestHelper::TestInputFilenames( gdcmReader );
 
   // check that output is a good reproduction of input (no duplicates, no new elements)
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
 
   // repeat test with filename based sorter in-between
   mitk::DICOMFilenameSorter::Pointer filenameSorter = mitk::DICOMFilenameSorter::New();
   gdcmReader->AddSortingElement( filenameSorter );
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
   // repeat test with some more realistic sorting
   gdcmReader = mitk::DICOMITKSeriesGDCMReader::New(); // this also tests destruction
   mitk::DICOMTagBasedSorter::Pointer tagSorter = mitk::DICOMTagBasedSorter::New();
 
   // all the things that split by tag in DicomSeriesReader
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0010) ); // Number of Rows
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0011) ); // Number of Columns
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0030) ); // Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x1164) ); // Imager Pixel Spacing
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0037), new mitk::DICOMTagBasedSorter::CutDecimalPlaces(5) ); // Image Orientation (Patient)
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x000e) ); // Series Instance UID
   tagSorter->AddDistinguishingTag( DICOMTag(0x0018, 0x0050) ); // Slice Thickness
   tagSorter->AddDistinguishingTag( DICOMTag(0x0028, 0x0008) ); // Number of Frames
   tagSorter->AddDistinguishingTag( DICOMTag(0x0020, 0x0052) ); // Frame of Reference UID
 
   // a sorter...
   mitk::DICOMSortCriterion::ConstPointer sorting =
     mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0013), // instance number
       mitk::DICOMSortByTag::New( DICOMTag(0x0020, 0x0012), // aqcuisition number
         mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0032), // aqcuisition time
           mitk::DICOMSortByTag::New( DICOMTag(0x0018, 0x1060), // trigger time
             mitk::DICOMSortByTag::New( DICOMTag(0x0008, 0x0018) // SOP instance UID (last resort, not really meaningful but decides clearly)
             ).GetPointer()
           ).GetPointer()
         ).GetPointer()
       ).GetPointer()
     ).GetPointer();
   tagSorter->SetSortCriterion( sorting );
 
   gdcmReader->AddSortingElement( tagSorter );
 
   gdcmReader->SetAdditionalTagsOfInterest( additionalTags );
 
 
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
   gdcmReader->PrintOutputs(std::cout, true);
 
   // really load images
   mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader, additionalTags, expectedPropertyTypes );
 
 
   //////////////////////////////////////////////////////////////////////////
   //
   // Load the images again with another TagLookupTableToPropertyFunctor
   //
   //////////////////////////////////////////////////////////////////////////
 
   gdcmReader->SetTagLookupTableToPropertyFunctor( []( const mitk::StringLookupTable& table )
   {
     return static_cast<mitk::BaseProperty::Pointer>( mitk::StringProperty::New( table.GetTableValue(0) ) );
   } );
 
-  expectedPropertyTypes["Test5"] = "StringLProperty";
+  expectedPropertyTypes.insert(std::make_pair("Test1", "StringProperty"));
+  expectedPropertyTypes.insert(std::make_pair("Test2", "StringProperty"));
+  expectedPropertyTypes.insert(std::make_pair("Test3", "StringProperty"));
 
   mitk::DICOMFileReaderTestHelper::TestOutputsContainInputs( gdcmReader );
 
   gdcmReader->PrintOutputs(std::cout, true);
 
   // really load images
   mitk::DICOMFileReaderTestHelper::TestMitkImagesAreLoaded( gdcmReader, additionalTags, expectedPropertyTypes );
 
 
   MITK_TEST_END();
 }