diff --git a/Core/Code/DataManagement/mitkImageVtkReadAccessor.cpp b/Core/Code/DataManagement/mitkImageVtkReadAccessor.cpp
index c3f8c3af71..61c439bb3c 100644
--- a/Core/Code/DataManagement/mitkImageVtkReadAccessor.cpp
+++ b/Core/Code/DataManagement/mitkImageVtkReadAccessor.cpp
@@ -1,61 +1,61 @@
 /*===================================================================
 
 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 "mitkImageVtkReadAccessor.h"
 
 #include "mitkImage.h"
 
 #include <vtkImageData.h>
 
 const mitk::Image* mitk::ImageVtkReadAccessor::GetImage() const
 {
   return m_Image;
 }
 
 mitk::ImageVtkReadAccessor::ImageVtkReadAccessor(
     ImageConstPointer iP, const mitk::ImageDataItem* iDI,
     const vtkImageData* imageDataVtk)
-  : ImageAccessorBase(NULL, iDI)
+  : ImageAccessorBase(iP, iDI)
   , m_Image(iP.GetPointer())
   , m_ImageDataVtk(imageDataVtk)
 {
   m_Image->m_VtkReadersLock.Lock();
 
   m_Image->m_VtkReaders.push_back(this);
   //printf("m_VtkReaders.size(): %d\n", (int) m_Image->m_VtkReaders.size());
 
   m_Image->m_VtkReadersLock.Unlock();
 }
 
 mitk::ImageVtkReadAccessor::~ImageVtkReadAccessor()
 {
   m_Image->m_VtkReadersLock.Lock();
 
   std::vector<ImageAccessorBase*>::iterator it =
       std::find(m_Image->m_VtkReaders.begin(), m_Image->m_VtkReaders.end(), this);
   if (it != m_Image->m_VtkReaders.end())
   {
     m_Image->m_VtkReaders.erase(it);
   }
   //printf("m_VtkReaders.size(): %d\n", (int) m_Image->m_VtkReaders.size());
 
   m_Image->m_VtkReadersLock.Unlock();
 }
 
 const vtkImageData*mitk::ImageVtkReadAccessor::GetVtkImageData() const
 {
   return m_ImageDataVtk;
 }
diff --git a/Core/Code/Internal/mitkImageVtkLegacyIO.cpp b/Core/Code/Internal/mitkImageVtkLegacyIO.cpp
index 7867caf1b4..a24fd7ed91 100644
--- a/Core/Code/Internal/mitkImageVtkLegacyIO.cpp
+++ b/Core/Code/Internal/mitkImageVtkLegacyIO.cpp
@@ -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.
 
 ===================================================================*/
 
 #include "mitkImageVtkLegacyIO.h"
 
 #include "mitkImage.h"
 #include "mitkIOMimeTypes.h"
 #include "mitkImageVtkReadAccessor.h"
 
 #include <vtkStructuredPointsReader.h>
 #include <vtkStructuredPointsWriter.h>
 #include <vtkStructuredPoints.h>
 #include <vtkErrorCode.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
 ImageVtkLegacyIO::ImageVtkLegacyIO()
   : AbstractFileIO(Image::GetStaticNameOfClass(), IOMimeTypes::VTK_IMAGE_LEGACY_MIMETYPE(), "VTK Legacy Image")
 {
   this->RegisterService();
 }
 
 std::vector<BaseData::Pointer> ImageVtkLegacyIO::Read()
 {
   // The legay vtk reader cannot work with input streams
   const std::string fileName = this->GetLocalFileName();
   vtkSmartPointer<vtkStructuredPointsReader> reader = vtkSmartPointer<vtkStructuredPointsReader>::New();
   reader->SetFileName(fileName.c_str());
   reader->Update();
 
   if ( reader->GetOutput() != NULL )
   {
     mitk::Image::Pointer output = mitk::Image::New();
     output->Initialize(reader->GetOutput());
     output->SetVolume(reader->GetOutput()->GetScalarPointer());
     std::vector<BaseData::Pointer> result;
     result.push_back(output.GetPointer());
     return result;
   }
   else
   {
     mitkThrow() << "vtkStructuredPointsReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
   }
 }
 
 IFileIO::ConfidenceLevel ImageVtkLegacyIO::GetReaderConfidenceLevel() const
 {
   if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported) return Unsupported;
   vtkSmartPointer<vtkStructuredPointsReader> reader = vtkSmartPointer<vtkStructuredPointsReader>::New();
   reader->SetFileName(this->GetLocalFileName().c_str());
   if (reader->IsFileStructuredPoints())
   {
     return Supported;
   }
   return Unsupported;
 }
 
 void ImageVtkLegacyIO::Write()
 {
   ValidateOutputLocation();
 
   const Image* input = dynamic_cast<const Image*>(this->GetInput());
 
   vtkSmartPointer<vtkStructuredPointsWriter> writer = vtkSmartPointer<vtkStructuredPointsWriter>::New();
 
   // The legacy vtk image writer cannot write to streams
   LocalFile localFile(this);
   writer->SetFileName(localFile.GetFileName().c_str());
 
-  ImageVtkReadAccessor vtkReadAccessor(Image::ConstPointer(input), NULL, NULL);
+  ImageVtkReadAccessor vtkReadAccessor(Image::ConstPointer(input), NULL, input->GetVtkImageData());
   writer->SetInputData(const_cast<vtkImageData*>(vtkReadAccessor.GetVtkImageData()));
 
   if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
   {
     mitkThrow() << "vtkStructuredPointesWriter error: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
   }
 }
 
 IFileIO::ConfidenceLevel ImageVtkLegacyIO::GetWriterConfidenceLevel() const
 {
   if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported) return Unsupported;
   const Image* input = static_cast<const Image*>(this->GetInput());
   if (input->GetDimension() == 3) return Supported;
   else if (input->GetDimension() < 3) return PartiallySupported;
   return Unsupported;
 }
 
 ImageVtkLegacyIO* ImageVtkLegacyIO::IOClone() const
 {
   return new ImageVtkLegacyIO(*this);
 }
 
 }
diff --git a/Core/Code/Internal/mitkImageVtkXmlIO.cpp b/Core/Code/Internal/mitkImageVtkXmlIO.cpp
index cb8c35da10..881f70b890 100644
--- a/Core/Code/Internal/mitkImageVtkXmlIO.cpp
+++ b/Core/Code/Internal/mitkImageVtkXmlIO.cpp
@@ -1,142 +1,142 @@
 /*===================================================================
 
 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 "mitkImageVtkXmlIO.h"
 
 #include "mitkImage.h"
 #include "mitkIOMimeTypes.h"
 #include "mitkImageVtkReadAccessor.h"
 
 #include <vtkXMLImageDataReader.h>
 #include <vtkXMLImageDataWriter.h>
 #include <vtkImageData.h>
 #include <vtkErrorCode.h>
 #include <vtkSmartPointer.h>
 
 namespace mitk {
 
 class VtkXMLImageDataReader : public ::vtkXMLImageDataReader
 {
 public:
   static VtkXMLImageDataReader *New() { return new VtkXMLImageDataReader(); }
   vtkTypeMacro(VtkXMLImageDataReader,vtkXMLImageDataReader)
 
   void SetStream(std::istream* is) { this->Stream = is; }
   std::istream* GetStream() const { return this->Stream; }
 };
 
 class VtkXMLImageDataWriter : public ::vtkXMLImageDataWriter
 {
 public:
   static VtkXMLImageDataWriter *New() { return new VtkXMLImageDataWriter(); }
   vtkTypeMacro(VtkXMLImageDataWriter,vtkXMLImageDataWriter)
 
   void SetStream(std::ostream* os) { this->Stream = os; }
   std::ostream* GetStream() const { return this->Stream; }
 };
 
 ImageVtkXmlIO::ImageVtkXmlIO()
   : AbstractFileIO(Image::GetStaticNameOfClass(), IOMimeTypes::VTK_IMAGE_MIMETYPE(), "VTK XML Image")
 {
   this->RegisterService();
 }
 
 std::vector<BaseData::Pointer> ImageVtkXmlIO::Read()
 {
   vtkSmartPointer<VtkXMLImageDataReader> reader = vtkSmartPointer<VtkXMLImageDataReader>::New();
   if (this->GetInputStream())
   {
     reader->SetStream(this->GetInputStream());
   }
   else
   {
     reader->SetFileName(this->GetInputLocation().c_str());
   }
   reader->Update();
 
   if (reader->GetOutput() != NULL)
   {
     mitk::Image::Pointer output = mitk::Image::New();
     output->Initialize(reader->GetOutput());
     output->SetVolume(reader->GetOutput()->GetScalarPointer());
     std::vector<BaseData::Pointer> result;
     result.push_back(output.GetPointer());
     return result;
   }
   else
   {
     mitkThrow() << "vtkXMLImageDataReader error: " << vtkErrorCode::GetStringFromErrorCode(reader->GetErrorCode());
   }
 }
 
 IFileIO::ConfidenceLevel ImageVtkXmlIO::GetReaderConfidenceLevel() const
 {
   if (AbstractFileIO::GetReaderConfidenceLevel() == Unsupported) return Unsupported;
   if (this->GetInputStream() == NULL)
   {
     // check if the xml vtk reader can handle the file
     vtkSmartPointer<VtkXMLImageDataReader> xmlReader = vtkSmartPointer<VtkXMLImageDataReader>::New();
     if (xmlReader->CanReadFile(this->GetInputLocation().c_str()) != 0)
     {
       return Supported;
     }
     return Unsupported;
   }
   // in case of an input stream, VTK does not seem to have methods for
   // validating it
   return Supported;
 }
 
 void ImageVtkXmlIO::Write()
 {
   ValidateOutputLocation();
 
   const Image* input = dynamic_cast<const Image*>(this->GetInput());
 
   vtkSmartPointer<VtkXMLImageDataWriter> writer = vtkSmartPointer<VtkXMLImageDataWriter>::New();
   if (this->GetOutputStream())
   {
     writer->SetStream(this->GetOutputStream());
   }
   else
   {
     writer->SetFileName(this->GetOutputLocation().c_str());
   }
 
-  ImageVtkReadAccessor vtkReadAccessor(Image::ConstPointer(input), NULL, NULL);
+  ImageVtkReadAccessor vtkReadAccessor(Image::ConstPointer(input), NULL, input->GetVtkImageData());
   writer->SetInputData(const_cast<vtkImageData*>(vtkReadAccessor.GetVtkImageData()));
 
   if (writer->Write() == 0 || writer->GetErrorCode() != 0 )
   {
     mitkThrow() << "vtkXMLImageDataWriter error: " << vtkErrorCode::GetStringFromErrorCode(writer->GetErrorCode());
   }
 }
 
 IFileIO::ConfidenceLevel ImageVtkXmlIO::GetWriterConfidenceLevel() const
 {
   if (AbstractFileIO::GetWriterConfidenceLevel() == Unsupported) return Unsupported;
   const Image* input = static_cast<const Image*>(this->GetInput());
   if (input->GetDimension() == 3) return Supported;
   else if (input->GetDimension() < 3) return PartiallySupported;
   return Unsupported;
 }
 
 ImageVtkXmlIO* ImageVtkXmlIO::IOClone() const
 {
   return new ImageVtkXmlIO(*this);
 }
 
 }