diff --git a/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp b/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
index 84930f7962..c5871d1a1a 100644
--- a/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
+++ b/Modules/IOExt/Internal/mitkIOExtObjectFactory.cpp
@@ -1,184 +1,184 @@
 /*===================================================================
 
 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 "mitkIOExtObjectFactory.h"
 
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkParRecFileIOFactory.h"
 //#include "mitkObjFileIOFactory.h"
 #include "mitkStlVolumeTimeSeriesIOFactory.h"
 #include "mitkVtkVolumeTimeSeriesIOFactory.h"
 
 #include "mitkUnstructuredGridVtkWriter.h"
 #include "mitkUnstructuredGridVtkWriterFactory.h"
 
-#include "mitkVtkSmartVolumeMapper3D.h"
+#include "mitkVolumeMapperVtkSmart3D.h"
 #include "mitkMesh.h"
 #include "mitkMeshMapper2D.h"
 #include "mitkMeshVtkMapper3D.h"
 #include "mitkUnstructuredGridMapper2D.h"
 #include "mitkUnstructuredGridVtkMapper3D.h"
 #include "mitkVtkGLMapperWrapper.h"
 
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 
 mitk::IOExtObjectFactory::IOExtObjectFactory()
   : CoreObjectFactoryBase(),
     m_ParRecFileIOFactory(ParRecFileIOFactory::New().GetPointer())
     //, m_ObjFileIOFactory(ObjFileIOFactory::New().GetPointer())
     ,
     m_StlVolumeTimeSeriesIOFactory(StlVolumeTimeSeriesIOFactory::New().GetPointer()),
     m_VtkVolumeTimeSeriesIOFactory(VtkVolumeTimeSeriesIOFactory::New().GetPointer()),
     m_UnstructuredGridVtkWriterFactory(UnstructuredGridVtkWriterFactory::New().GetPointer())
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "IOExtObjectFactory c'tor" << std::endl;
 
     itk::ObjectFactoryBase::RegisterFactory(m_ParRecFileIOFactory);
     itk::ObjectFactoryBase::RegisterFactory(m_StlVolumeTimeSeriesIOFactory);
     itk::ObjectFactoryBase::RegisterFactory(m_VtkVolumeTimeSeriesIOFactory);
 
     itk::ObjectFactoryBase::RegisterFactory(m_UnstructuredGridVtkWriterFactory);
 
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkUnstructuredGridWriter>::New().GetPointer());
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkXMLUnstructuredGridWriter>::New().GetPointer());
     m_FileWriters.push_back(mitk::UnstructuredGridVtkWriter<vtkXMLPUnstructuredGridWriter>::New().GetPointer());
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::IOExtObjectFactory::~IOExtObjectFactory()
 {
   itk::ObjectFactoryBase::UnRegisterFactory(m_ParRecFileIOFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_StlVolumeTimeSeriesIOFactory);
   itk::ObjectFactoryBase::UnRegisterFactory(m_VtkVolumeTimeSeriesIOFactory);
 
   itk::ObjectFactoryBase::UnRegisterFactory(m_UnstructuredGridVtkWriterFactory);
 }
 
 mitk::Mapper::Pointer mitk::IOExtObjectFactory::CreateMapper(mitk::DataNode *node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = nullptr;
   mitk::BaseData *data = node->GetData();
 
   if (id == mitk::BaseRenderer::Standard2D)
   {
     if ((dynamic_cast<Mesh *>(data) != nullptr))
     {
       newMapper = mitk::MeshMapper2D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<UnstructuredGrid *>(data) != nullptr))
     {
       newMapper = mitk::VtkGLMapperWrapper::New(mitk::UnstructuredGridMapper2D::New().GetPointer());
       newMapper->SetDataNode(node);
     }
   }
   else if (id == mitk::BaseRenderer::Standard3D)
   {
     if ((dynamic_cast<Image *>(data) != nullptr))
     {
-      newMapper = mitk::VtkSmartVolumeMapper3D::New();
+      newMapper = mitk::VolumeMapperVtkSmart3D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<Mesh *>(data) != nullptr))
     {
       newMapper = mitk::MeshVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
     else if ((dynamic_cast<UnstructuredGrid *>(data) != nullptr))
     {
       newMapper = mitk::UnstructuredGridVtkMapper3D::New();
       newMapper->SetDataNode(node);
     }
   }
   return newMapper;
 }
 
 void mitk::IOExtObjectFactory::SetDefaultProperties(mitk::DataNode *node)
 {
   if (node == nullptr)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(node->GetData());
   if (image.IsNotNull() && image->IsInitialized())
   {
-    mitk::VtkSmartVolumeMapper3D::SetDefaultProperties(node);
+    mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(node);
   }
 
   if (dynamic_cast<mitk::UnstructuredGrid *>(node->GetData()))
   {
     mitk::UnstructuredGridVtkMapper3D::SetDefaultProperties(node);
   }
 }
 
 const char *mitk::IOExtObjectFactory::GetFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_FileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::IOExtObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::IOExtObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::IOExtObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtu", "VTK Unstructured Grid"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "VTK Unstructured Grid"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pvtu", "VTK Unstructured Grid"));
 
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pvtu", "VTK Parallel XML Unstructured Grid"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtu", "VTK XML Unstructured Grid"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "VTK Legacy Unstructured Grid"));
 }
 
 const char *mitk::IOExtObjectFactory::GetSaveFileExtensions()
 {
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 }
 
 struct RegisterIOExtObjectFactory
 {
   RegisterIOExtObjectFactory() : m_Factory(mitk::IOExtObjectFactory::New())
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory(m_Factory);
   }
 
   ~RegisterIOExtObjectFactory() { mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory(m_Factory); }
   mitk::IOExtObjectFactory::Pointer m_Factory;
 };
 
 static RegisterIOExtObjectFactory registerIOExtObjectFactory;
diff --git a/Modules/MapperExt/files.cmake b/Modules/MapperExt/files.cmake
index a46dc9a6dc..3ec5ef80f6 100644
--- a/Modules/MapperExt/files.cmake
+++ b/Modules/MapperExt/files.cmake
@@ -1,20 +1,20 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkEnhancedPointSetVtkMapper3D.cpp
   mitkGPUVolumeMapper3D.cpp
   mitkMeshMapper2D.cpp
   mitkMeshVtkMapper3D.cpp
   mitkSplineVtkMapper3D.cpp
   mitkUnstructuredGridMapper2D.cpp
   mitkUnstructuredGridVtkMapper3D.cpp
   mitkVectorImageMapper2D.cpp
-  mitkVtkSmartVolumeMapper3D.cpp
+  mitkVolumeMapperVtkSmart3D.cpp
 
   vtkMaskedGlyph2D.cpp
   vtkMaskedGlyph3D.cpp
   vtkMitkGPUVolumeRayCastMapper.cpp
   vtkUnstructuredGridMapper.cpp
 
   vtkPointSetSlicer.cxx
 )
diff --git a/Modules/MapperExt/include/mitkVtkSmartVolumeMapper3D.h b/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
similarity index 83%
rename from Modules/MapperExt/include/mitkVtkSmartVolumeMapper3D.h
rename to Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
index c42bf2fcae..3ba04dccbd 100644
--- a/Modules/MapperExt/include/mitkVtkSmartVolumeMapper3D.h
+++ b/Modules/MapperExt/include/mitkVolumeMapperVtkSmart3D.h
@@ -1,74 +1,74 @@
 /*===================================================================
 
 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 MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED
 #define MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED
 
 // MITK
 #include "MitkMapperExtExports.h"
 #include "mitkBaseRenderer.h"
 #include "mitkCommon.h"
 #include "mitkImage.h"
 #include "mitkVtkMapper.h"
 
 // VTK
 #include <vtkImageChangeInformation.h>
 #include <vtkSmartPointer.h>
 #include <vtkVersionMacros.h>
 #include <vtkVolumeProperty.h>
 #include <vtkSmartVolumeMapper.h>
 #include <vtkImageData.h>
 
 namespace mitk
 {
 
   //##Documentation
   //## @brief Vtk-based mapper for VolumeData
   //##
   //## @ingroup Mapper
-  class MITKMAPPEREXT_EXPORT VtkSmartVolumeMapper3D : public VtkMapper
+  class MITKMAPPEREXT_EXPORT VolumeMapperVtkSmart3D : public VtkMapper
   {
   public:
-    mitkClassMacro(VtkSmartVolumeMapper3D, VtkMapper);
+    mitkClassMacro(VolumeMapperVtkSmart3D, VtkMapper);
 
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
     virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
 
     virtual void ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer) override;
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
     virtual void MitkRenderVolumetricGeometry(mitk::BaseRenderer *renderer) override;
 
   protected:
-    VtkSmartVolumeMapper3D();
-    virtual ~VtkSmartVolumeMapper3D();
+    VolumeMapperVtkSmart3D();
+    virtual ~VolumeMapperVtkSmart3D();
 
     virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
     void createMapper(vtkImageData*);
     void createVolume();
     void createVolumeProperty();
     vtkImageData* GetInputImage();
 
-    vtkSmartPointer<vtkVolume> m_Volume = nullptr;
-    vtkSmartPointer<vtkSmartVolumeMapper> m_Mapper = nullptr;
-    vtkSmartPointer<vtkVolumeProperty> m_VolumeProperty = nullptr;
+    vtkSmartPointer<vtkVolume> m_Volume;
+    vtkSmartPointer<vtkSmartVolumeMapper> m_SmartVolumeMapper;
+    vtkSmartPointer<vtkVolumeProperty> m_VolumeProperty;
   };
 
 } // namespace mitk
 
 #endif /* MITKVTKSMARTVOLUMEMAPPER_H_HEADER_INCLUDED */
diff --git a/Modules/MapperExt/src/mitkVtkSmartVolumeMapper3D.cpp b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
similarity index 56%
rename from Modules/MapperExt/src/mitkVtkSmartVolumeMapper3D.cpp
rename to Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
index c2eeb05ed8..e695f89283 100644
--- a/Modules/MapperExt/src/mitkVtkSmartVolumeMapper3D.cpp
+++ b/Modules/MapperExt/src/mitkVolumeMapperVtkSmart3D.cpp
@@ -1,97 +1,93 @@
 /*===================================================================
 
 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 "mitkVtkSmartVolumeMapper3D.h"
+#include "mitkVolumeMapperVtkSmart3D.h"
 
-void mitk::VtkSmartVolumeMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
+void mitk::VolumeMapperVtkSmart3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
-
+  m_SmartVolumeMapper = vtkSmartPointer<vtkSmartVolumeMapper>::New();
 }
 
-vtkProp* mitk::VtkSmartVolumeMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
+vtkProp* mitk::VolumeMapperVtkSmart3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
-  if (!m_Volume)
+  if (!m_Volume->GetMapper())
   {
     createVolume();
   }
 
   return m_Volume;
 }
 
-void mitk::VtkSmartVolumeMapper3D::ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)
+void mitk::VolumeMapperVtkSmart3D::ApplyProperties(vtkActor *actor, mitk::BaseRenderer *renderer)
 {
 
 }
 
-void mitk::VtkSmartVolumeMapper3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
+void mitk::VolumeMapperVtkSmart3D::SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer, bool overwrite)
 {
 
 }
 
-void mitk::VtkSmartVolumeMapper3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer *renderer)
+void mitk::VolumeMapperVtkSmart3D::MitkRenderVolumetricGeometry(mitk::BaseRenderer *renderer)
 {
 
 }
 
-vtkImageData* mitk::VtkSmartVolumeMapper3D::GetInputImage()
+vtkImageData* mitk::VolumeMapperVtkSmart3D::GetInputImage()
 {
   mitk::Image *input = const_cast<mitk::Image *>(static_cast<const mitk::Image *>(this->GetDataNode()->GetData()));
   return input->GetVtkImageData(this->GetTimestep());
 }
 
-void mitk::VtkSmartVolumeMapper3D::createMapper(vtkImageData* imageData)
+void mitk::VolumeMapperVtkSmart3D::createMapper(vtkImageData* imageData)
 {
-  vtkSmartPointer<vtkSmartVolumeMapper> m_Mapper =
-    vtkSmartPointer<vtkSmartVolumeMapper>::New();
-  m_Mapper->SetBlendModeToComposite(); // composite first
-  m_Mapper->SetInputData(imageData);
+  m_SmartVolumeMapper->SetBlendModeToComposite(); // composite first
+  m_SmartVolumeMapper->SetInputData(imageData);
 }
 
-void mitk::VtkSmartVolumeMapper3D::createVolume()
+void mitk::VolumeMapperVtkSmart3D::createVolume()
 {
-  if (!m_Mapper)
+  if (!m_SmartVolumeMapper->GetInput())
   {
     createMapper(GetInputImage());
   }
-  if (!m_VolumeProperty)
-  {
+
+  if (1)
     createVolumeProperty();
-  }
 
-  m_Volume = vtkSmartPointer<vtkVolume>::New();
   m_Volume->VisibilityOff();
-  m_Volume->SetMapper(m_Mapper);
+  m_Volume->SetMapper(m_SmartVolumeMapper);
   m_Volume->SetProperty(m_VolumeProperty);
 }
 
-void mitk::VtkSmartVolumeMapper3D::createVolumeProperty()
+void mitk::VolumeMapperVtkSmart3D::createVolumeProperty()
 {
-  m_VolumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
   m_VolumeProperty->ShadeOff();
   m_VolumeProperty->SetInterpolationType(VTK_LINEAR_INTERPOLATION);
 }
 
-mitk::VtkSmartVolumeMapper3D::VtkSmartVolumeMapper3D()
+mitk::VolumeMapperVtkSmart3D::VolumeMapperVtkSmart3D()
 {
- 
+  m_VolumeProperty = vtkSmartPointer<vtkVolumeProperty>::New();
+  m_Volume = vtkSmartPointer<vtkVolume>::New();
 }
 
-mitk::VtkSmartVolumeMapper3D::~VtkSmartVolumeMapper3D()
+mitk::VolumeMapperVtkSmart3D::~VolumeMapperVtkSmart3D()
 {
 
 }