diff --git a/Applications/Mapper4V/source/mapR4VHelper.cpp b/Applications/Mapper4V/source/mapR4VHelper.cpp
index 9dd85bc..3cc8a37 100644
--- a/Applications/Mapper4V/source/mapR4VHelper.cpp
+++ b/Applications/Mapper4V/source/mapR4VHelper.cpp
@@ -1,152 +1,152 @@
 // -----------------------------------------------------------------------
 // MatchPoint - DKFZ translational registration framework
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See mapCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date    $Date$ (last change date)
 // @author  $Author$ (last changed by)
 // Subversion HeadURL: $HeadURL$
 */
 
 
 #include "mapR4VHelper.h"
 
 #include "vioitkCTXImageLoader.h"
 
 
 bool
   map::apps::mapR4V::isVirtuosFile(const map::core::String& filePath)
 {
   bool result = false;
 
   if (filePath.find(".ctx") != map::core::String::npos)
   {
     result = true;
   };
 
   if (filePath.find(".ctx.gz") != map::core::String::npos)
   {
     result = true;
   };
 
   return result;
 }
 
 map::apps::mapR4V::LoadingLogic::LoadingLogic(map::apps::mapR::ApplicationData& appData): _appData(appData), _legacyLogic(appData)
 {
 };
 
 void
   map::apps::mapR4V::LoadingLogic::
   loadRegistration()
 {
   _legacyLogic.loadRegistration();
 };
 
 void
   map::apps::mapR4V::LoadingLogic::
   loadInputImage()
 {
   if(isVirtuosFile(_appData._inputFileName))
   {
     map::io::GenericImageReader::GenericOutputImageType::Pointer loadedImage;
     unsigned int loadedDimensions;
     map::io::GenericImageReader::LoadedPixelType loadedPixelType;
     map::io::GenericImageReader::LoadedComponentType loadedComponentType;
 
     std::cout << std::endl << "read input file (Virtuos CTX)... ";
 
     vioitk::CTXImageLoader::Pointer loader = vioitk::CTXImageLoader::New();
     loader->setFileName(_appData._inputFileName);
     loader->importData();
 
     loadedImage = loader->getITKImage();
     loadedDimensions = 3;
-    loadedPixelType = ::itk::ImageIOBase::SCALAR;
+    loadedPixelType = ::itk::IOPixelEnum::SCALAR;
 
     if (loadedImage.IsNotNull())
     {
       if (loader->getPixelType() == "float")
       {
-        loadedComponentType = ::itk::ImageIOBase::FLOAT;
+        loadedComponentType = ::itk::IOComponentEnum::FLOAT;
       }
       else
       {
-        loadedComponentType = ::itk::ImageIOBase::SHORT;
+        loadedComponentType = ::itk::IOComponentEnum::SHORT;
       }
       std::cout << "done." << std::endl;
 
       if (_appData._detailedOutput)
       {
         std::cout << "Input image info:" << std::endl;
         loadedImage->Print(std::cout);
         std::cout << std::endl;
       }
     }
     else
     {
       mapDefaultExceptionStaticMacro(<< " Unable to load input image. File is not existing or has an unsupported format.");
     }
 
     _appData._spInputImage = loadedImage;
     _appData._loadedDimensions = loadedDimensions;
     _appData._loadedPixelType = loadedPixelType;
     _appData._loadedComponentType = loadedComponentType;
 
   }
   else
   {
     _legacyLogic.loadInputImage();
   }
 };
 
 void
   map::apps::mapR4V::LoadingLogic::
   loadReferenceImage()
 {
 
   if (!(_appData._refFileName.empty()))
   {
     if(isVirtuosFile(_appData._refFileName))
     {
       if (_appData._spReg->getTargetDimensions() != 3)
       {
         mapDefaultExceptionStaticMacro(<< "Template image dimension does not match registration target dimension. Virtuos CTX loading only for 3D images.");
       }
 
       map::io::GenericImageReader::GenericOutputImageType::Pointer loadedImage;
 
       std::cout << std::endl << "read template file (Virtuos CTX)... ";
 
       vioitk::CTXImageLoader::Pointer loader = vioitk::CTXImageLoader::New();
       loader->setFileName(_appData._inputFileName);
       loader->importData();
 
       loadedImage = loader->getITKImage();
 
       if (loadedImage.IsNull())
       {
         mapDefaultExceptionStaticMacro(<< " Unable to load input image. File is not existing or has an unsupported format.");
       }
 
       _appData._spRefImage = loadedImage;
 
     }
     else
     {
       _legacyLogic.loadReferenceImage();
     }
   }
 };
\ No newline at end of file
diff --git a/Code/IO/include/mapGenericImageReader.h b/Code/IO/include/mapGenericImageReader.h
index 9dca10f..0c4dbe8 100644
--- a/Code/IO/include/mapGenericImageReader.h
+++ b/Code/IO/include/mapGenericImageReader.h
@@ -1,160 +1,160 @@
 // -----------------------------------------------------------------------
 // MatchPoint - DKFZ translational registration framework
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See mapCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date    $Date$ (last change date)
 // @author  $Author$ (last changed by)
 // Subversion HeadURL: $HeadURL$
 */
 
 #ifndef __MAP_GENERIC_IMAGE_READER_H
 #define __MAP_GENERIC_IMAGE_READER_H
 
 #include "mapImageReader.h"
 #include "mapMAPIOExports.h"
 
 namespace map
 {
     namespace io
     {
         /** @class ImageReader
         * @brief Helper class manages the generic loading (unspecified dimension and pixel type) of 2D/3D images ...
         *
         * GenericImageReader uses the ImageReader class and dispatches the dimension and pixel type information from the specified image file.
         * GenericImageReader supports 2D and 3D images and the following pixel types:
         * - (unsigned) char
         * - (unsigned) short
         * - (unsigned) int
         * - (unsigned) long
         * - float
         * - double
         * .
         * Due to the fact that it builds upon the itk io infrastructure, all formats supported by ITK
         * can be read.
         * For further information regarding the usage see documentation of ImageReader.
         * @sa ImageReader
         * @ingroup Utils
         */
         class MAPIO_EXPORT GenericImageReader : public ::itk::Object
         {
         public:
             using Self = GenericImageReader;
             using Superclass = ::itk::Object;
             using Pointer = ::itk::SmartPointer<Self>;
             using ConstPointer = ::itk::SmartPointer<const Self>;
 
             itkTypeMacro(GenericImageReader, ::itk::Object);
             itkNewMacro(Self);
 
             using GenericOutputImageType = ::itk::DataObject;
 
-            using LoadedPixelType = ::itk::ImageIOBase::IOPixelType;
+            using LoadedPixelType = ::itk::IOPixelEnum;
 
-            using LoadedComponentType = ::itk::ImageIOBase::IOComponentType;
+            using LoadedComponentType = ::itk::IOComponentEnum;
 
             using MetaDataDictionaryArrayType = std::vector<itk::MetaDataDictionary>;
 
         private:
             /** Loaded Image.*/
             GenericOutputImageType::Pointer _spImage;
             /** The file name of the image. */
             core::String  _fileName;
             /** The upper limit for the searching of series files in the path.*/
             unsigned int _upperSeriesLimit;
             /** Indicates if the image data is up to date or should be read again.*/
             bool _upToDate;
             /** Defines if the specified image file is part of a series and the
             * whole series should be read into one image. Only relevant for 3D images.*/
             ImageSeriesReadStyle::Type _seriesReadStyle;
 
             unsigned int _loadedDimensions;
             LoadedPixelType _loadedPixelType;
             LoadedComponentType _loadedComponentType;
             core::String _loadedComponentTypeStr;
             core::String _loadedPixelTypeStr;
 
             MetaDataDictionaryArrayType _dictionaryArray;
 
             /** Loads the image. First identifies pixel type and dimension and then deligates according
              * to the pixel type.
              * @exception map::core::ExceptionObject If no ImageIO is found.
              * @exception map::core::ExceptionObject If dimension of the image is not supported. Only 2D/3D is supported.
              * @exception map::core::ExceptionObject If pixel type is not supported. Currently only scalar pixels are supported.
              */
             void load();
 
             /** Loads an scalar image.
               * @exception map::core::ExceptionObject If pixel component type is not supported.
               */
             template <unsigned int IDimension>
             void loadScalar();
 
             //template <unsigned int IDimension>
             //void loadRGB();
 
         public:
             /** Function to access the member variable _FileName. _FileName represents the filename of the
             * headerfile. The path must be included, the file extension may left away.
             * @return File name of the header file.*/
             const core::String&  getFileName() const;
 
             /** Function to access the member variable _FileName. _FileName represents the filename of the
             * headerfile. The path must be included, the file extension may left away.
             * @param [in] sFileName The file name of the header file.*/
             void setFileName(const core::String&  sFileName);
 
             /** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
             * the upper limit for the series file search.
             * @return The upper limit of the series search.*/
             unsigned int getUpperSeriesLimit() const;
 
             /** Function to access the member variable _upperSeriesLimit. _upperSeriesLimit represents
             * the upper limit for the series file search. Changing the series limit out dates the ImageReader.
             * @remark It is only relevant if series style is set to "Numeric".
             * @param [in] upperLimit The upper limit of the header file.*/
             void setUpperSeriesLimit(unsigned int upperLimit);
 
             /** Function to access the member variable _seriesReadStyle (see member description for more information).*/
             ImageSeriesReadStyle::Type getSeriesReadStyle() const;
 
             /** Function to access the member variable _seriesReadStyle (see member description for more information).
             * Changing the style out dates the ImageReader.*/
             void setSeriesReadStyle(ImageSeriesReadStyle::Type readStyle);
 
             /** Function loads the image if needed and returns the data.
             * @return Pointer to loaded image.
             * @exception map::core::ExceptionObject If no ImageIO is found.
             * @exception map::core::ExceptionObject If dimension of the image is not supported. Only 2D/3D is supported.
             * @exception map::core::ExceptionObject If pixel type is not supported. Currently only scalar pixels are supported.
             * @exception map::core::ExceptionObject If pixel component type is not supported.
             */
             GenericOutputImageType*  GetOutput(unsigned int& loadedDimensions, LoadedPixelType& loadedPixelType,
                 LoadedComponentType& loadedComponentType);
 
             /** Function returns the reference to the meta data dictionary(ies) of the latest file(s) loaded by this class.
              * Array may be empty if no MetaDictionary exists.*/
             const MetaDataDictionaryArrayType& getMetaDictionaryArray();
 
         protected:
             GenericImageReader();
 
             ~GenericImageReader() override;
         };
 
     }  // namespace io
 }  // namespace map
 
 #endif
diff --git a/Code/IO/source/mapGenericImageReader.cpp b/Code/IO/source/mapGenericImageReader.cpp
index b7b0ba7..53361bf 100644
--- a/Code/IO/source/mapGenericImageReader.cpp
+++ b/Code/IO/source/mapGenericImageReader.cpp
@@ -1,384 +1,384 @@
 // -----------------------------------------------------------------------
 // MatchPoint - DKFZ translational registration framework
 //
 // Copyright (c) German Cancer Research Center (DKFZ),
 // Software development for Integrated Diagnostics and Therapy (SIDT).
 // ALL RIGHTS RESERVED.
 // See mapCopyright.txt or
 // http://www.dkfz.de/en/sidt/projects/MatchPoint/copyright.html
 //
 // This software is distributed WITHOUT ANY WARRANTY; without even
 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.  See the above copyright notices for more information.
 //
 //------------------------------------------------------------------------
 /*!
 // @file
 // @version $Revision$ (last changed revision)
 // @date    $Date$ (last change date)
 // @author  $Author$ (last changed by)
 // Subversion HeadURL: $HeadURL$
 */
 
 #include "mapGenericImageReader.h"
 
 namespace map
 {
 	namespace io
 	{
 
 		////////////////////////////////////////////////////////////////////////
 		/// Implementation of map::GenericImageReader ////////////////////////////////
 		////////////////////////////////////////////////////////////////////////
 
 
 		void
 		GenericImageReader::
 		load()
 		{
 			_spImage = nullptr;
 
 			::map::core::String probeFileName = this->_fileName;
 
 			if (this->_seriesReadStyle == ImageSeriesReadStyle::Numeric)
 			{
 				using NamesType = ::itk::NumericSeriesFileNames;
 
 				NamesType::Pointer names = NamesType::New();
 
 				names->SetStartIndex(1);
 				names->SetEndIndex(1);
 				names->SetSeriesFormat(this->_fileName.c_str());
 
 				probeFileName = names->GetFileNames()[0];
 			}
 
 			::itk::ImageIOBase::Pointer imageIO =
 				::itk::ImageIOFactory::CreateImageIO(probeFileName.c_str(),
 						::itk::ImageIOFactory::ReadMode);
 
 			if (imageIO == nullptr)
 			{
 				mapDefaultExceptionMacro( <<
 										  "No ImageIO found for given file. Please check if the file exists and has a supported format. File:"
 										  << probeFileName);
 				return;
 			}
 
 			// Now that we found the appropriate ImageIO class, ask it to
 			// read the meta data from the image file.
 			imageIO->SetFileName(probeFileName.c_str());
 			imageIO->ReadImageInformation();
 
 			this->_loadedComponentType = imageIO->GetComponentType();
 			this->_loadedPixelType = imageIO->GetPixelType();
 
-			if (this->_loadedPixelType == ::itk::ImageIOBase::RGB && imageIO->GetNumberOfComponents() == 1)
+			if (this->_loadedPixelType == ::itk::IOPixelEnum::RGB && imageIO->GetNumberOfComponents() == 1)
 			{
 				//if only one channel per pixel handle as scalar as long as RGB etc. is not supported
-				this->_loadedPixelType = ::itk::ImageIOBase::SCALAR;
+				this->_loadedPixelType = ::itk::IOPixelEnum::SCALAR;
 			}
 
 			this->_loadedComponentTypeStr = imageIO->GetComponentTypeAsString(this->_loadedComponentType);
 			this->_loadedPixelTypeStr = imageIO->GetPixelTypeAsString(this->_loadedPixelType);
 			this->_loadedDimensions = imageIO->GetNumberOfDimensions();
 
 			if (this->_seriesReadStyle == ImageSeriesReadStyle::Numeric &&
 				this->_loadedDimensions == 2)
 			{
 				this->_loadedDimensions = 3; //it is a stack of 2D images -> 3D
 			}
 
 			if (this->_loadedDimensions < 2 || this->_loadedDimensions > 3)
 			{
 				mapDefaultExceptionMacro( <<
 										  "The file uses a number of dimensions that is not supported in this application. PixelType: " <<
 										  this->_loadedPixelTypeStr << "; ComponentType: " << this->_loadedComponentTypeStr <<
 										  "; Number of dimension: " << this->_loadedDimensions);
 			}
 
 			switch (_loadedPixelType)
 			{
-				case ::itk::ImageIOBase::SCALAR:
+				case ::itk::IOPixelEnum::SCALAR:
 				{
 					if (this->_loadedDimensions == 2)
 					{
 						loadScalar<2>();
 					}
 					else
 					{
 						loadScalar<3>();
 					}
 
 					break;
 				}
 
 				default:
 				{
 					mapDefaultExceptionMacro( <<
 											  "The file uses a pixel type that is not supported in this application. PixelType: " <<
 											  this->_loadedPixelTypeStr << "; ComponentType: " << this->_loadedComponentTypeStr <<
 											  "; Number of pixel channels: " << imageIO->GetNumberOfComponents() <<
 											  "; Number of image dimensions: " << this->_loadedDimensions);
 				}
 			}
 
 			_upToDate = true;
 		};
 
 
 		template <unsigned int IDimension>
 		void
 		GenericImageReader::
 		loadScalar()
 		{
 			// Use the pixel type to instantiate the appropriate reader
 			switch (this->_loadedComponentType)
 			{
-				case ::itk::ImageIOBase::UCHAR:
+				case ::itk::IOComponentEnum::UCHAR:
 				{
 					this->_spImage = readImage<unsigned char, unsigned char, IDimension>(_fileName, _seriesReadStyle,
 									 false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::CHAR:
+				case ::itk::IOComponentEnum::CHAR:
 				{
 					this->_spImage = readImage<char, char, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::USHORT:
+				case ::itk::IOComponentEnum::USHORT:
 				{
 					this->_spImage = readImage<unsigned short, unsigned short, IDimension>(_fileName, _seriesReadStyle,
 									 false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::SHORT:
+				case ::itk::IOComponentEnum::SHORT:
 				{
 					this->_spImage = readImage<short, short, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::UINT:
+				case ::itk::IOComponentEnum::UINT:
 				{
 					this->_spImage = readImage<unsigned int, unsigned int, IDimension>(_fileName, _seriesReadStyle,
 									 false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::INT:
+				case ::itk::IOComponentEnum::INT:
 				{
 					this->_spImage = readImage<int, int, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::ULONG:
+				case ::itk::IOComponentEnum::ULONG:
 				{
 					this->_spImage = readImage<unsigned long, unsigned long, IDimension>(_fileName, _seriesReadStyle,
 									 false, 0, 0, _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::LONG:
+				case ::itk::IOComponentEnum::LONG:
 				{
 					this->_spImage = readImage<long, long, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::FLOAT:
+				case ::itk::IOComponentEnum::FLOAT:
 				{
 					this->_spImage = readImage<float, float, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
-				case ::itk::ImageIOBase::DOUBLE:
+				case ::itk::IOComponentEnum::DOUBLE:
 				{
 					this->_spImage = readImage<double, double, IDimension>(_fileName, _seriesReadStyle, false, 0, 0,
 									 _upperSeriesLimit, &_dictionaryArray);
 					break;
 				}
 
 				default:
 				{
 					mapDefaultExceptionMacro( <<
 											  "The file uses a pixel component type that is not supported in this application. PixelType: " <<
 											  this->_loadedPixelTypeStr << "; ComponentType: " << this->_loadedComponentTypeStr <<
 											  "; Number of dimension: " << this->_loadedDimensions);
 				}
 			}
 		};
 
 		//template <unsigned int IDimension>
 		//void
 		//  GenericImageReader::
 		//  loadRGB()
 		//{
 		//  assert(false);
 		//  mapDefaultExceptionStaticMacro(<<"RGB support is yet not implemented.");
 		//  switch( this->_loadedComponentType )
 		//  {
-		//  case ::itk::ImageIOBase::UCHAR:
+		//  case ::itk::IOComponentEnum::UCHAR:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<unsigned char>, ::itk::RGBPixel<unsigned char>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::CHAR:
+		//  case ::itk::IOComponentEnum::CHAR:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<char>, ::itk::RGBPixel<char>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::USHORT:
+		//  case ::itk::IOComponentEnum::USHORT:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<unsigned short>, ::itk::RGBPixel<unsigned short>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::SHORT:
+		//  case ::itk::IOComponentEnum::SHORT:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<short>, ::itk::RGBPixel<short>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::UINT:
+		//  case ::itk::IOComponentEnum::UINT:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<unsigned int>, ::itk::RGBPixel<unsigned int>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::INT:
+		//  case ::itk::IOComponentEnum::INT:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<int>, ::itk::RGBPixel<int>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::ULONG:
+		//  case ::itk::IOComponentEnum::ULONG:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<unsigned long>, ::itk::RGBPixel<unsigned long>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::LONG:
+		//  case ::itk::IOComponentEnum::LONG:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<long>, ::itk::RGBPixel<long>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::FLOAT:
+		//  case ::itk::IOComponentEnum::FLOAT:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<float>, ::itk::RGBPixel<float>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
-		//  case ::itk::ImageIOBase::DOUBLE:
+		//  case ::itk::IOComponentEnum::DOUBLE:
 		//    {
 		//      this->_spImage = readImageA< ::itk::RGBPixel<double>, ::itk::RGBPixel<double>, IDimension>(_fileName,_seriesReadStyle);
 		//      break;
 		//    }
 		//  default:
 		//    {
 		//      mapDefaultExceptionMacro(<<"The file uses a pixel component type that is not supported in this application. PixelType: "<<this->_loadedPixelTypeStr<<"; ComponentType: "<<this->_loadedComponentTypeStr<<"; Number of dimension: "<<this->_loadedDimensions);
 		//    }
 		//  }
 		//};
 
 		const core::String&
 		GenericImageReader::
 		getFileName() const
 		{
 			return _fileName;
 		};
 
 
 		void
 		GenericImageReader::
 		setFileName(const core::String& fileName)
 		{
 			if (fileName != _fileName)
 			{
 				_upToDate = false;
 				_fileName = fileName;
 			}
 		}
 
 
 		unsigned int
 		GenericImageReader::
 		getUpperSeriesLimit() const
 		{
 			return _upperSeriesLimit;
 		};
 
 
 		void
 		GenericImageReader::
 		setUpperSeriesLimit(const unsigned int upperLimit)
 		{
 			if (upperLimit != _upperSeriesLimit)
 			{
 				_upToDate = false;
 				_upperSeriesLimit = upperLimit;
 			};
 		};
 
 
 		ImageSeriesReadStyle::Type
 		GenericImageReader::
 		getSeriesReadStyle() const
 		{
 			return _seriesReadStyle;
 		};
 
 
 		void
 		GenericImageReader::
 		setSeriesReadStyle(ImageSeriesReadStyle::Type readStyle)
 		{
 			if (readStyle != _seriesReadStyle)
 			{
 				_upToDate = false;
 				_seriesReadStyle = readStyle;
 			};
 		};
 
 
 		GenericImageReader::GenericOutputImageType*
 		GenericImageReader::
 		GetOutput(unsigned int& loadedDimensions, LoadedPixelType& loadedPixelType,
 				  LoadedComponentType& loadedComponentType)
 		{
 			if (!_upToDate)
 			{
 				load();
 				loadedPixelType = _loadedPixelType;
 				loadedComponentType = _loadedComponentType;
 				loadedDimensions = _loadedDimensions;
 			};
 
 			return _spImage;
 		};
 
 
 
 		GenericImageReader::
 		GenericImageReader()
 		{
 			_fileName = "";
 			_upperSeriesLimit = 255;
 			_upToDate = false;
 			_seriesReadStyle = ImageSeriesReadStyle::Default;
 		};
 
 
 		GenericImageReader::
 		~GenericImageReader()
 		= default;
 
 		const GenericImageReader::MetaDataDictionaryArrayType&
 		GenericImageReader::
 		getMetaDictionaryArray()
 		{
 			return _dictionaryArray;
 		};
 
 	}  // namespace io
 }  // namespace map