diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index b4f33cdb1e..8619c08be7 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,321 +1,322 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkStdDisplayActionEventHandler.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
+  IO/mitkVtkNifti2ImageReader.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/DisplayConfigMITKNoCrosshair.xml
 Interactions/DisplayConfigMITKRotation.xml
 Interactions/DisplayConfigMITKRotationUnCoupled.xml
 Interactions/DisplayConfigMITKSwivel.xml
 Interactions/DisplayConfigMITKLimited.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkIOMimeTypes.h b/Modules/Core/include/mitkIOMimeTypes.h
index 1d7b1d2e89..0a98c97650 100644
--- a/Modules/Core/include/mitkIOMimeTypes.h
+++ b/Modules/Core/include/mitkIOMimeTypes.h
@@ -1,96 +1,106 @@
 /*===================================================================
 
 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 MITKIOMIMETYPES_H
 #define MITKIOMIMETYPES_H
 
 #include "mitkCustomMimeType.h"
 
 #include <string>
 
 namespace mitk
 {
   /**
    * @ingroup IO
    * @brief The IOMimeTypes class
    */
   class MITKCORE_EXPORT IOMimeTypes
   {
   public:
     class MITKCORE_EXPORT DicomMimeType : public CustomMimeType
     {
     public:
       DicomMimeType();
       bool AppliesTo(const std::string &path) const override;
       DicomMimeType *Clone() const override;
     };
 
+    class MITKCORE_EXPORT Nifti2MimeType : public CustomMimeType
+    {
+    public:
+      Nifti2MimeType();
+      bool AppliesTo(const std::string &path) const override;
+      Nifti2MimeType *Clone() const override;
+    };
+
     static std::vector<CustomMimeType *> Get();
 
     static std::string DEFAULT_BASE_NAME(); // application/vnd.mitk
 
     static std::string CATEGORY_IMAGES();   // Images
     static std::string CATEGORY_SURFACES(); // Surfaces
 
     // ------------------------------ VTK formats ----------------------------------
 
     static CustomMimeType VTK_IMAGE_MIMETYPE();             // (mitk::Image) vti
     static CustomMimeType VTK_IMAGE_LEGACY_MIMETYPE();      // (mitk::Image) vtk
     static CustomMimeType VTK_PARALLEL_IMAGE_MIMETYPE();    // (mitk::Image) pvti
     static CustomMimeType VTK_POLYDATA_MIMETYPE();          // (mitk::Surface) vtp, vtk
     static CustomMimeType VTK_POLYDATA_LEGACY_MIMETYPE();   // (mitk::Surface) vtk
     static CustomMimeType VTK_PARALLEL_POLYDATA_MIMETYPE(); // (mitk::Surface) pvtp
     static CustomMimeType STEREOLITHOGRAPHY_MIMETYPE();     // (mitk::Surface) stl
     static CustomMimeType WAVEFRONT_OBJ_MIMETYPE();         // (mitk::Surface) obj
     static CustomMimeType STANFORD_PLY_MIMETYPE();          // (mitk::Surface) ply
 
     static std::string STEREOLITHOGRAPHY_NAME();     // DEFAULT_BASE_NAME.stl
     static std::string VTK_IMAGE_NAME();             // DEFAULT_BASE_NAME.vtk.image
     static std::string VTK_IMAGE_LEGACY_NAME();      // DEFAULT_BASE_NAME.vtk.image.legacy
     static std::string VTK_PARALLEL_IMAGE_NAME();    // DEFAULT_BASE_NAME.vtk.parallel.image
     static std::string VTK_POLYDATA_NAME();          // DEFAULT_BASE_NAME.vtk.polydata
     static std::string VTK_POLYDATA_LEGACY_NAME();   // DEFAULT_BASE_NAME.vtk.polydata.legacy
     static std::string VTK_PARALLEL_POLYDATA_NAME(); // DEFAULT_BASE_NAME.vtk.parallel.polydata
     static std::string WAVEFRONT_OBJ_NAME();         // DEFAULT_BASE_NAME.obj
     static std::string STANFORD_PLY_NAME();          // DEFAULT_BASE_NAME.ply
 
     // ------------------------- Image formats (ITK based) --------------------------
 
     static CustomMimeType NRRD_MIMETYPE(); // nrrd, nhdr
     static CustomMimeType NIFTI_MIMETYPE();
+    static Nifti2MimeType NIFTI2_MIMETYPE();
     static CustomMimeType RAW_MIMETYPE(); // raw
     static DicomMimeType DICOM_MIMETYPE();
 
     static std::string NRRD_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.nrrd
     static std::string NIFTI_MIMETYPE_NAME();
+    static std::string NIFTI2_MIMETYPE_NAME();
     static std::string RAW_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.raw
     static std::string DICOM_MIMETYPE_NAME();
 
     // ------------------------------ MITK formats ----------------------------------
 
     static CustomMimeType POINTSET_MIMETYPE();      // mps
     static CustomMimeType GEOMETRY_DATA_MIMETYPE(); // .mitkgeometry
 
     static std::string POINTSET_MIMETYPE_NAME(); // DEFAULT_BASE_NAME.pointset
 
   private:
     // purposely not implemented
     IOMimeTypes();
     IOMimeTypes(const IOMimeTypes &);
   };
 }
 
 #endif // MITKIOMIMETYPES_H
diff --git a/Modules/Core/src/IO/mitkIOMimeTypes.cpp b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
index db8b8b4bee..7817fdcda6 100644
--- a/Modules/Core/src/IO/mitkIOMimeTypes.cpp
+++ b/Modules/Core/src/IO/mitkIOMimeTypes.cpp
@@ -1,356 +1,389 @@
 /*===================================================================
 
 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 "mitkIOMimeTypes.h"
 
 #include "mitkCustomMimeType.h"
 #include "mitkLogMacros.h"
 
 #include "itkGDCMImageIO.h"
 #include "itkMetaDataObject.h"
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
+#include <itkNiftiImageIO.h>
+#include <vtkNIFTIImageReader.h>
+#include <vtkSmartPointer.h>
 
 namespace mitk
 {
   IOMimeTypes::DicomMimeType::DicomMimeType() : CustomMimeType(DICOM_MIMETYPE_NAME())
   {
     this->AddExtension("gdcm");
     this->AddExtension("dcm");
     this->AddExtension("DCM");
     this->AddExtension("dc3");
     this->AddExtension("DC3");
     this->AddExtension("ima");
     this->AddExtension("img");
 
     this->SetCategory(CATEGORY_IMAGES());
     this->SetComment("DICOM");
   }
 
   bool IOMimeTypes::DicomMimeType::AppliesTo(const std::string &path) const
   {
     // check whether directory or file
     // if directory try to find first file within it instead
     bool pathIsDirectory = itksys::SystemTools::FileIsDirectory(path);
 
     std::string filepath = path;
 
     if (pathIsDirectory)
     {
       itksys::Directory input;
       input.Load(path.c_str());
 
       std::vector<std::string> files;
       for (unsigned long idx = 0; idx<input.GetNumberOfFiles(); idx++)
       {
         if (!itksys::SystemTools::FileIsDirectory(input.GetFile(idx)))
         {
           std::string fullpath = path + "/" + std::string(input.GetFile(idx));
           files.push_back(fullpath.c_str());
         }
       }
       filepath = files.front();
     }
 
     // Ask the GDCM ImageIO class directly
     itk::GDCMImageIO::Pointer gdcmIO = itk::GDCMImageIO::New();
     gdcmIO->SetFileName(filepath);
     try {
       gdcmIO->ReadImageInformation();
     }
     catch (const itk::ExceptionObject & /*err*/) {
       return false;
     }
 
     //DICOMRT modalities have specific reader, don't read with normal DICOM readers
     std::string modality;
     itk::MetaDataDictionary& dict = gdcmIO->GetMetaDataDictionary();
     itk::ExposeMetaData<std::string>(dict, "0008|0060", modality);
     MITK_INFO << "DICOM Modality is " << modality;
     if (modality == "RTSTRUCT" || modality == "RTDOSE" || modality == "RTPLAN") {
       return false;
     }
     else {
       return gdcmIO->CanReadFile(filepath.c_str());
     }
   }
 
   IOMimeTypes::DicomMimeType *IOMimeTypes::DicomMimeType::Clone() const { return new DicomMimeType(*this); }
+
   std::vector<CustomMimeType *> IOMimeTypes::Get()
   {
     std::vector<CustomMimeType *> mimeTypes;
 
     // order matters here (descending rank for mime types)
 
     mimeTypes.push_back(NRRD_MIMETYPE().Clone());
     mimeTypes.push_back(NIFTI_MIMETYPE().Clone());
+    mimeTypes.push_back(NIFTI2_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_IMAGE_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_IMAGE_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(DICOM_MIMETYPE().Clone());
 
     mimeTypes.push_back(VTK_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_PARALLEL_POLYDATA_MIMETYPE().Clone());
     mimeTypes.push_back(VTK_POLYDATA_LEGACY_MIMETYPE().Clone());
 
     mimeTypes.push_back(STEREOLITHOGRAPHY_MIMETYPE().Clone());
     mimeTypes.push_back(WAVEFRONT_OBJ_MIMETYPE().Clone());
     mimeTypes.push_back(STANFORD_PLY_MIMETYPE().Clone());
 
     mimeTypes.push_back(RAW_MIMETYPE().Clone());
     mimeTypes.push_back(POINTSET_MIMETYPE().Clone());
     return mimeTypes;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_NAME());
     mimeType.AddExtension("vti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_IMAGE_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_IMAGE_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Legacy Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_IMAGE_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_IMAGE_NAME());
     mimeType.AddExtension("pvti");
     mimeType.SetCategory(CATEGORY_IMAGES());
     mimeType.SetComment("VTK Parallel Image");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_NAME());
     mimeType.AddExtension("vtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_POLYDATA_LEGACY_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_POLYDATA_LEGACY_NAME());
     mimeType.AddExtension("vtk");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Legacy PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::VTK_PARALLEL_POLYDATA_MIMETYPE()
   {
     CustomMimeType mimeType(VTK_PARALLEL_POLYDATA_NAME());
     mimeType.AddExtension("pvtp");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("VTK Parallel PolyData");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STEREOLITHOGRAPHY_MIMETYPE()
   {
     CustomMimeType mimeType(STEREOLITHOGRAPHY_NAME());
     mimeType.AddExtension("stl");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stereolithography");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::WAVEFRONT_OBJ_MIMETYPE()
   {
     CustomMimeType mimeType(WAVEFRONT_OBJ_NAME());
     mimeType.AddExtension("obj");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Wavefront OBJ");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::STANFORD_PLY_MIMETYPE()
   {
     CustomMimeType mimeType(STANFORD_PLY_NAME());
     mimeType.AddExtension("ply");
     mimeType.SetCategory(CATEGORY_SURFACES());
     mimeType.SetComment("Stanford PLY");
     return mimeType;
   }
 
   std::string IOMimeTypes::STEREOLITHOGRAPHY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".stl";
     return name;
   }
 
   std::string IOMimeTypes::WAVEFRONT_OBJ_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".obj";
     return name;
   }
 
   std::string IOMimeTypes::STANFORD_PLY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".ply";
     return name;
   }
 
   std::string IOMimeTypes::DEFAULT_BASE_NAME()
   {
     static std::string name = "application/vnd.mitk";
     return name;
   }
 
   std::string IOMimeTypes::CATEGORY_IMAGES()
   {
     static std::string cat = "Images";
     return cat;
   }
 
   std::string IOMimeTypes::CATEGORY_SURFACES()
   {
     static std::string cat = "Surfaces";
     return cat;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_IMAGE_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.image.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_IMAGE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.image";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata";
     return name;
   }
 
   std::string IOMimeTypes::VTK_POLYDATA_LEGACY_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.polydata.legacy";
     return name;
   }
 
   std::string IOMimeTypes::VTK_PARALLEL_POLYDATA_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".vtk.parallel.polydata";
     return name;
   }
 
   CustomMimeType IOMimeTypes::NRRD_MIMETYPE()
   {
     CustomMimeType mimeType(NRRD_MIMETYPE_NAME());
     mimeType.AddExtension("nrrd");
     mimeType.AddExtension("nhdr");
     mimeType.SetCategory("Images");
     mimeType.SetComment("NRRD");
     return mimeType;
   }
 
   CustomMimeType IOMimeTypes::NIFTI_MIMETYPE()
   {
     CustomMimeType mimeType(NIFTI_MIMETYPE_NAME());
     mimeType.AddExtension("nii");
     mimeType.AddExtension("nii.gz");
     mimeType.AddExtension("hdr");
     mimeType.AddExtension("hdr.gz");
     mimeType.AddExtension("img");
     mimeType.AddExtension("img.gz");
     mimeType.AddExtension("nia");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Nifti");
     return mimeType;
   }
 
+  IOMimeTypes::Nifti2MimeType::Nifti2MimeType() : CustomMimeType(NIFTI2_MIMETYPE_NAME())
+  {
+    this->AddExtension("nii");
+    this->AddExtension("nii.gz");
+    this->SetCategory("Images");
+    this->SetComment("Nifti-2");
+  }
+
+  IOMimeTypes::Nifti2MimeType *IOMimeTypes::Nifti2MimeType::Clone() const { return new Nifti2MimeType(*this); }
+
+  bool IOMimeTypes::Nifti2MimeType::AppliesTo(const std::string &path) const
+  {
+    itk::NiftiImageIO::Pointer io2 = itk::NiftiImageIO::New();
+    vtkSmartPointer<vtkNIFTIImageReader> reader = vtkSmartPointer<vtkNIFTIImageReader>::New();
+
+    if (reader->CanReadFile(path.c_str()) && !io2->CanReadFile(path.c_str()))
+      return true;
+    return false;
+  }
+
+  IOMimeTypes::Nifti2MimeType IOMimeTypes::NIFTI2_MIMETYPE() { return Nifti2MimeType(); }
+
   CustomMimeType IOMimeTypes::RAW_MIMETYPE()
   {
     CustomMimeType mimeType(RAW_MIMETYPE_NAME());
     mimeType.AddExtension("raw");
     mimeType.SetCategory("Images");
     mimeType.SetComment("Raw data");
     return mimeType;
   }
 
   IOMimeTypes::DicomMimeType IOMimeTypes::DICOM_MIMETYPE() { return DicomMimeType(); }
   std::string IOMimeTypes::NRRD_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nrrd";
     return name;
   }
 
   std::string IOMimeTypes::NIFTI_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.nifti";
     return name;
   }
 
+  std::string IOMimeTypes::NIFTI2_MIMETYPE_NAME()
+  {
+    static std::string name = DEFAULT_BASE_NAME() + ".image.nifti2";
+    return name;
+  }
+
   std::string IOMimeTypes::RAW_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.raw";
     return name;
   }
 
   std::string IOMimeTypes::DICOM_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".image.dicom";
     return name;
   }
 
   CustomMimeType IOMimeTypes::POINTSET_MIMETYPE()
   {
     CustomMimeType mimeType(POINTSET_MIMETYPE_NAME());
     mimeType.AddExtension("mps");
     mimeType.SetCategory("Point Sets");
     mimeType.SetComment("MITK Point Set");
     return mimeType;
   }
 
   std::string IOMimeTypes::POINTSET_MIMETYPE_NAME()
   {
     static std::string name = DEFAULT_BASE_NAME() + ".pointset";
     return name;
   }
 
   CustomMimeType IOMimeTypes::GEOMETRY_DATA_MIMETYPE()
   {
     mitk::CustomMimeType mimeType(DEFAULT_BASE_NAME() + ".geometrydata");
     mimeType.AddExtension("mitkgeometry");
     mimeType.SetCategory("Geometries");
     mimeType.SetComment("GeometryData object");
     return mimeType;
   }
 }
diff --git a/Modules/Core/src/IO/mitkVtkNifti2ImageReader.cpp b/Modules/Core/src/IO/mitkVtkNifti2ImageReader.cpp
new file mode 100644
index 0000000000..e915ddd1ac
--- /dev/null
+++ b/Modules/Core/src/IO/mitkVtkNifti2ImageReader.cpp
@@ -0,0 +1,215 @@
+/*===================================================================
+
+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 "mitkVtkNifti2ImageReader.h"
+#include <mitkCustomMimeType.h>
+#include <mitkIOMimeTypes.h>
+#include <mitkLocaleSwitch.h>
+#include <vtkNIFTIImageHeader.h>
+#include <mitkITKImageImport.h>
+#include <mitkImageCast.h>
+
+
+namespace mitk
+{
+  VtkNifti2ImageReader::VtkNifti2ImageReader(const VtkNifti2ImageReader& other)
+    : mitk::AbstractFileReader(other)
+  {
+  }
+
+  VtkNifti2ImageReader::VtkNifti2ImageReader()
+    : mitk::AbstractFileReader( CustomMimeType( mitk::IOMimeTypes::NIFTI2_MIMETYPE() ), mitk::IOMimeTypes::NIFTI2_MIMETYPE_NAME() )
+  {
+    m_ServiceReg = this->RegisterService();
+  }
+
+  VtkNifti2ImageReader::~VtkNifti2ImageReader()
+  {
+  }
+
+  template <class TPixel>
+  typename itk::Image<TPixel, 3>::Pointer VtkNifti2ImageReader::GetItkImage3D(vtkSmartPointer<vtkNIFTIImageReader> reader)
+  {
+    auto vtk_image = reader->GetOutput();
+    auto header = reader->GetNIFTIHeader();
+    auto dim = header->GetDim(0);
+    auto matrix = reader->GetQFormMatrix();
+    if (matrix == nullptr)
+      matrix = reader->GetSFormMatrix();
+    itk::Matrix<double, 3, 3> direction; direction.SetIdentity();
+    itk::Matrix<double, 3, 3> ras_lps; ras_lps.SetIdentity();
+    ras_lps[0][0] = -1;
+    ras_lps[1][1] = -1;
+    if (matrix != nullptr)
+    {
+      for (int r=0; r<dim; r++)
+          for (int c=0; c<dim; c++)
+              direction[r][c] = matrix->GetElement(r, c);
+    }
+    direction = direction*ras_lps;
+
+    itk::Vector< double, 3 > spacing; spacing.Fill(1.0);
+    vtk_image->GetSpacing(spacing.GetDataPointer());
+
+    itk::Point< double, 3 > origin; origin.Fill(0.0);
+    vtk_image->GetOrigin(origin.GetDataPointer());
+
+    itk::ImageRegion< 3 > region;
+    for (int i=0; i<3; ++i)
+      if (i<dim)
+        region.SetSize(i, header->GetDim(i+1));
+      else
+        region.SetSize(i, 1);
+
+    typename itk::Image<TPixel, 3>::Pointer itk_img = itk::Image<TPixel, 3>::New();
+    itk_img->SetSpacing( spacing );
+    itk_img->SetOrigin( origin );
+    itk_img->SetDirection( direction );
+    itk_img->SetRegions( region );
+    itk_img->Allocate();
+    itk_img->FillBuffer(0);
+
+    for (int z=0; z<header->GetDim(3); z++)
+      for (int y=0; y<header->GetDim(2); y++)
+        for (int x=0; x<header->GetDim(1); x++)
+        {
+          double val = vtk_image->GetScalarComponentAsDouble(x, y, z, 0);
+          itk::Index<3> idx;
+          idx[0] = x;
+          idx[1] = y;
+          idx[2] = z;
+          itk_img->SetPixel(idx, static_cast<TPixel>(val));
+        }
+
+    return itk_img;
+  }
+
+  template <class TPixel>
+  typename itk::Image<TPixel, 4>::Pointer VtkNifti2ImageReader::GetItkImage4D(vtkSmartPointer<vtkNIFTIImageReader> reader)
+  {
+    auto vtk_image = reader->GetOutput();
+    auto header = reader->GetNIFTIHeader();
+    auto dim = header->GetDim(0);
+    auto matrix = reader->GetQFormMatrix();
+    if (matrix == nullptr)
+      matrix = reader->GetSFormMatrix();
+    itk::Matrix<double, 4, 4> direction; direction.SetIdentity();
+    itk::Matrix<double, 4, 4> ras_lps; ras_lps.SetIdentity();
+    ras_lps[0][0] = -1;
+    ras_lps[1][1] = -1;
+    if (matrix != nullptr)
+    {
+      for (int r=0; r<dim; r++)
+          for (int c=0; c<dim; c++)
+              direction[r][c] = matrix->GetElement(r, c);
+    }
+    direction = direction*ras_lps;
+
+    itk::Vector< double, 4 > spacing; spacing.Fill(1.0);
+    vtk_image->GetSpacing(spacing.GetDataPointer());
+
+    itk::Point< double, 4 > origin; origin.Fill(0.0);
+    vtk_image->GetOrigin(origin.GetDataPointer());
+
+    itk::ImageRegion< 4 > region;
+    for (int i=0; i<4; ++i)
+      if (i<dim)
+        region.SetSize(i, header->GetDim(i+1));
+      else
+        region.SetSize(i, 1);
+
+    typename itk::Image<TPixel, 4>::Pointer itk_img = itk::Image<TPixel, 4>::New();
+    itk_img->SetSpacing( spacing );
+    itk_img->SetOrigin( origin );
+    itk_img->SetDirection( direction );
+    itk_img->SetRegions( region );
+    itk_img->Allocate();
+    itk_img->FillBuffer(0);
+
+    for (int g=0; g<header->GetDim(4); g++)
+      for (int z=0; z<header->GetDim(3); z++)
+        for (int y=0; y<header->GetDim(2); y++)
+          for (int x=0; x<header->GetDim(1); x++)
+          {
+            double val = vtk_image->GetScalarComponentAsDouble(x, y, z, g);
+            itk::Index<4> idx;
+            idx[0] = x;
+            idx[1] = y;
+            idx[2] = z;
+            idx[3] = g;
+            itk_img->SetPixel(idx, static_cast<TPixel>(val));
+          }
+
+    return itk_img;
+  }
+
+  std::vector<itk::SmartPointer<BaseData> > VtkNifti2ImageReader::Read()
+  {
+    std::vector<itk::SmartPointer<mitk::BaseData> > result;
+    std::string location = GetInputLocation();
+
+    if ( location == "")
+    {
+      mitkThrow() << "Sorry, the filename is empty!";
+    }
+    else
+    {
+      vtkSmartPointer<vtkNIFTIImageReader> reader = vtkSmartPointer<vtkNIFTIImageReader>::New();
+      reader->SetFileName(location.c_str());
+      reader->SetTimeAsVector(true);
+      reader->Update();
+
+      if (reader->GetOutput() != nullptr)
+      {
+        auto header = reader->GetNIFTIHeader();
+        auto dim = header->GetDim(0);
+        mitk::Image::Pointer mitk_img = mitk::Image::New();
+
+        switch(dim)
+        {
+        case 3:
+        {
+          auto itk_image = GetItkImage3D<unsigned char>(reader);
+          mitk::CastToMitkImage(itk_image, mitk_img);
+          mitk_img->SetVolume(itk_image->GetBufferPointer());
+          break;
+        }
+        case 4:
+        {
+          auto itk_image = GetItkImage4D<unsigned char>(reader);
+          mitk::CastToMitkImage(itk_image, mitk_img);
+          mitk_img->SetVolume(itk_image->GetBufferPointer());
+          break;
+        }
+        default:
+          mitkThrow() << "Image dimension " << dim << " not supported for nifti-2 image format!";
+        }
+
+        result.push_back(mitk_img.GetPointer());
+      }
+      else {
+        mitkThrow() << "File could not be read as nifti-2 image!";
+      }
+    }
+    return result;
+  }
+
+} //namespace MITK
+
+mitk::VtkNifti2ImageReader* mitk::VtkNifti2ImageReader::Clone() const
+{
+  return new VtkNifti2ImageReader(*this);
+}
diff --git a/Modules/Core/src/IO/mitkVtkNifti2ImageReader.h b/Modules/Core/src/IO/mitkVtkNifti2ImageReader.h
new file mode 100644
index 0000000000..9f87808785
--- /dev/null
+++ b/Modules/Core/src/IO/mitkVtkNifti2ImageReader.h
@@ -0,0 +1,62 @@
+/*===================================================================
+
+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 __mitkNrrdVtkNifti2ImageReader_h
+#define __mitkNrrdVtkNifti2ImageReader_h
+
+#include <mitkAbstractFileReader.h>
+#include <mitkBaseData.h>
+#include <mitkMimeType.h>
+#include <itkImage.h>
+#include <mitkImage.h>
+#include <vtkNIFTIImageReader.h>
+#include <vtkSmartPointer.h>
+
+namespace mitk
+{
+
+  /** \brief
+  */
+
+  class VtkNifti2ImageReader : public mitk::AbstractFileReader
+  {
+  public:
+
+    VtkNifti2ImageReader(const VtkNifti2ImageReader& other);
+    VtkNifti2ImageReader();
+    ~VtkNifti2ImageReader() override;
+
+    using AbstractFileReader::Read;
+    std::vector<itk::SmartPointer<BaseData> > Read() override;
+
+  protected:
+
+
+  private:
+    VtkNifti2ImageReader* Clone() const override;
+
+    template <class TPixel>
+    typename itk::Image<TPixel, 4>::Pointer GetItkImage4D(vtkSmartPointer<vtkNIFTIImageReader> reader);
+
+    template <class TPixel>
+    typename itk::Image<TPixel, 3>::Pointer GetItkImage3D(vtkSmartPointer<vtkNIFTIImageReader> reader);
+
+    us::ServiceRegistration<mitk::IFileReader> m_ServiceReg;
+  };
+
+} //namespace MITK
+
+#endif // __mitkNrrdVtkNifti2ImageReader_h
diff --git a/Modules/Core/src/mitkCoreActivator.cpp b/Modules/Core/src/mitkCoreActivator.cpp
index 12f59e65fd..d3e75b73f4 100644
--- a/Modules/Core/src/mitkCoreActivator.cpp
+++ b/Modules/Core/src/mitkCoreActivator.cpp
@@ -1,325 +1,328 @@
 /*===================================================================
 
 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 "mitkCoreActivator.h"
 
 // File IO
 #include <mitkGeometryDataReaderService.h>
 #include <mitkGeometryDataWriterService.h>
 #include <mitkIOMimeTypes.h>
 #include <mitkIOUtil.h>
 #include <mitkImageVtkLegacyIO.h>
 #include <mitkImageVtkXmlIO.h>
 #include <mitkItkImageIO.h>
+#include <mitkVtkNifti2ImageReader.h>
 #include <mitkMimeTypeProvider.h>
 #include <mitkPointSetReaderService.h>
 #include <mitkPointSetWriterService.h>
 #include <mitkRawImageFileReader.h>
 #include <mitkSurfaceStlIO.h>
 #include <mitkSurfaceVtkLegacyIO.h>
 #include <mitkSurfaceVtkXmlIO.h>
 
 #include "mitkLegacyFileWriterService.h"
 #include <mitkFileWriter.h>
 
 #include <itkGDCMImageIO.h>
 #include <itkNiftiImageIO.h>
 
 // Micro Services
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleEvent.h>
 #include <usModuleInitialization.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usModuleSettings.h>
 #include <usServiceTracker.h>
 
 // ITK "injects" static initialization code for IO factories
 // via the itkImageIOFactoryRegisterManager.h header (which
 // is generated in the application library build directory).
 // To ensure that the code is called *before* the CppMicroServices
 // static initialization code (which triggers the Activator::Start
 // method), we include the ITK header here.
 #include <itkImageIOFactoryRegisterManager.h>
 
 void HandleMicroServicesMessages(us::MsgType type, const char *msg)
 {
   switch (type)
   {
     case us::DebugMsg:
       MITK_DEBUG << msg;
       break;
     case us::InfoMsg:
       MITK_INFO << msg;
       break;
     case us::WarningMsg:
       MITK_WARN << msg;
       break;
     case us::ErrorMsg:
       MITK_ERROR << msg;
       break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string &programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for (int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 class FixedNiftiImageIO : public itk::NiftiImageIO
 {
 public:
   /** Standard class typedefs. */
   typedef FixedNiftiImageIO Self;
   typedef itk::NiftiImageIO Superclass;
   typedef itk::SmartPointer<Self> Pointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self)
 
     /** Run-time type information (and related methods). */
     itkTypeMacro(FixedNiftiImageIO, Superclass)
 
       bool SupportsDimension(unsigned long dim) override
   {
     return dim > 1 && dim < 5;
   }
 };
 
 void MitkCoreActivator::Load(us::ModuleContext *context)
 {
   // Handle messages from CppMicroServices
   us::installMsgHandler(HandleMicroServicesMessages);
 
   this->m_Context = context;
 
   // Add the current application directory to the auto-load paths.
   // This is useful for third-party executables.
   std::string programPath = mitk::IOUtil::GetProgramPath();
   if (programPath.empty())
   {
     MITK_WARN << "Could not get the program path.";
   }
   else
   {
     AddMitkAutoLoadPaths(programPath);
   }
 
   // m_RenderingManager = mitk::RenderingManager::New();
   // context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
   m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
   context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
   m_PropertyAliases.reset(new mitk::PropertyAliases);
   context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
   m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
   context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
   m_PropertyExtensions.reset(new mitk::PropertyExtensions);
   context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
   m_PropertyFilters.reset(new mitk::PropertyFilters);
   context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
   m_PropertyPersistence.reset(new mitk::PropertyPersistence);
   context->RegisterService<mitk::IPropertyPersistence>(m_PropertyPersistence.get());
 
   m_PropertyRelations.reset(new mitk::PropertyRelations);
   context->RegisterService<mitk::IPropertyRelations>(m_PropertyRelations.get());
 
   m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
   m_MimeTypeProvider->Start();
   m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
 
   this->RegisterDefaultMimeTypes();
   this->RegisterItkReaderWriter();
   this->RegisterVtkReaderWriter();
 
   // Add custom Reader / Writer Services
   m_FileReaders.push_back(new mitk::PointSetReaderService());
   m_FileWriters.push_back(new mitk::PointSetWriterService());
   m_FileReaders.push_back(new mitk::GeometryDataReaderService());
   m_FileWriters.push_back(new mitk::GeometryDataWriterService());
   m_FileReaders.push_back(new mitk::RawImageFileReaderService());
 
   /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
 
   this->RegisterLegacyWriter();
 }
 
 void MitkCoreActivator::Unload(us::ModuleContext *)
 {
   for (auto &elem : m_FileReaders)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileWriters)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileIOs)
   {
     delete elem;
   }
 
   for (auto &elem : m_LegacyWriters)
   {
     delete elem;
   }
 
   // The mitk::ModuleContext* argument of the Unload() method
   // will always be 0 for the Mitk library. It makes no sense
   // to use it at this stage anyway, since all libraries which
   // know about the module system have already been unloaded.
 
   // we need to close the internal service tracker of the
   // MimeTypeProvider class here. Otherwise it
   // would hold on to the ModuleContext longer than it is
   // actually valid.
   m_MimeTypeProviderReg.Unregister();
   m_MimeTypeProvider->Stop();
 
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = m_DefaultMimeTypes.begin(),
                                                            iterEnd = m_DefaultMimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     delete *mimeTypeIter;
   }
 }
 
 void MitkCoreActivator::RegisterDefaultMimeTypes()
 {
   // Register some default mime-types
 
   std::vector<mitk::CustomMimeType *> mimeTypes = mitk::IOMimeTypes::Get();
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = mimeTypes.begin(), iterEnd = mimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     m_DefaultMimeTypes.push_back(*mimeTypeIter);
     m_Context->RegisterService(m_DefaultMimeTypes.back());
   }
 }
 
 void MitkCoreActivator::RegisterItkReaderWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
 
   for (auto &allobject : allobjects)
   {
     auto *io = dynamic_cast<itk::ImageIOBase *>(allobject.GetPointer());
 
     // NiftiImageIO does not provide a correct "SupportsDimension()" methods
     // and the supported read/write extensions are not ordered correctly
     if (dynamic_cast<itk::NiftiImageIO *>(io))
       continue;
 
     // Use a custom mime-type for GDCMImageIO below
     if (dynamic_cast<itk::GDCMImageIO *>(allobject.GetPointer()))
     {
       // MITK provides its own DICOM reader (which internally uses GDCMImageIO).
       continue;
     }
 
     if (io)
     {
       m_FileIOs.push_back(new mitk::ItkImageIO(io));
     }
     else
     {
       MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: " << (allobject)->GetNameOfClass();
     }
   }
 
   FixedNiftiImageIO::Pointer itkNiftiIO = FixedNiftiImageIO::New();
   mitk::ItkImageIO *niftiIO = new mitk::ItkImageIO(mitk::IOMimeTypes::NIFTI_MIMETYPE(), itkNiftiIO.GetPointer(), 0);
   m_FileIOs.push_back(niftiIO);
 }
 
 void MitkCoreActivator::RegisterVtkReaderWriter()
 {
+  m_FileReaders.push_back(new mitk::VtkNifti2ImageReader());
+
   m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
   m_FileIOs.push_back(new mitk::SurfaceStlIO());
   m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
 
   m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
   m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
 }
 
 void MitkCoreActivator::RegisterLegacyWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
 
   for (auto i = allobjects.begin(); i != allobjects.end(); ++i)
   {
     mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter *>(i->GetPointer());
     if (io)
     {
       std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Writer";
       mitk::IFileWriter *writer = new mitk::LegacyFileWriterService(io, description);
       m_LegacyWriters.push_back(writer);
     }
     else
     {
       MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: " << (*i)->GetNameOfClass() << std::endl;
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE