diff --git a/Modules/OpenCL/mitkOclImage.cpp b/Modules/OpenCL/mitkOclImage.cpp
index dd1a8d4e12..7ad3b08c65 100644
--- a/Modules/OpenCL/mitkOclImage.cpp
+++ b/Modules/OpenCL/mitkOclImage.cpp
@@ -1,354 +1,355 @@
 /*===================================================================
 
 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 "mitkOclImage.h"
 #include "mitkImageDataItem.h"
 #include "mitkCommon.h"
 #include "mitkLogMacros.h"
 
 #include "mitkOclUtils.h"
 
-
+#include <mitkImageReadAccessor.h>
 #include <fstream>
 
 mitk::OclImage::OclImage() : m_gpuImage(NULL), m_context(NULL), m_bufferSize(0), m_gpuModified(false), m_cpuModified(false),
   m_Image(NULL), m_dim(0), m_Dims(NULL), m_BpE(1), m_formatSupported(false)
 {
 }
 
 mitk::OclImage::~OclImage()
 {
   MITK_INFO << "OclImage Destructor";
 
   //release GMEM Image buffer
   if (m_gpuImage) clReleaseMemObject(m_gpuImage);
 }
 
 
 cl_mem mitk::OclImage::CreateGPUImage(unsigned int _wi, unsigned int _he, unsigned int _de,
                                       unsigned int _bpp)
 {
   MITK_INFO << "CreateGPUImage call with: BPP=" << _bpp;
 
   this->m_Dims = new unsigned int[MAX_DIMS];
 
   m_Dims[0] = _wi;
   m_Dims[1] = _he;
   m_Dims[2] = _de;
 
   for (unsigned int i=3; i<MAX_DIMS; i++)
     m_Dims[i] = 1;
 
   m_bufferSize = _wi * _he * _de;
 
   m_BpE = _bpp;
 
   mitk::ServiceReference ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   cl_context gpuContext = resources->GetContext();
 
   int clErr;
   m_gpuImage = clCreateBuffer( gpuContext, CL_MEM_READ_WRITE, m_bufferSize * m_BpE, NULL, &clErr);
 
   CHECK_OCL_ERR(clErr);
 
   return m_gpuImage;
 }
 
 void mitk::OclImage::InitializeByMitkImage(mitk::Image::Pointer _image)
 {
   this->m_Image = _image;
   this->m_cpuModified = true;
   this->m_gpuModified = false;
 
   this->m_gpuImage = NULL;
 
   // compute the size of the GMEM buffer
   this->m_dim = this->m_Image->GetDimension();
   this->m_Dims = this->m_Image->GetDimensions();
   MITK_INFO << "Image: " << this->m_Dims[0] <<"x"<< this->m_Dims[1] <<"x"<< this->m_Dims[2];
 
   // get the dimensions
   this->m_bufferSize = 1;
   for (unsigned int i=0; i<this->m_dim; i++)
   {
     this->m_bufferSize *= this->m_Dims[i];
   }
 
   // multiply by sizeof(PixelType)
   this->m_BpE  = ( this->m_Image->GetPixelType().GetBpe() / 8);
 }
 
 bool mitk::OclImage::IsModified(int _type)
 {
   if (_type) return m_cpuModified;
   else return m_gpuModified;
 }
 
 void mitk::OclImage::Modified(int _type)
 {
   // defines... GPU: 0, CPU: 1
   m_cpuModified = _type;
   m_gpuModified = !_type;
 }
 
 int mitk::OclImage::TransferDataToGPU(cl_command_queue gpuComQueue)
 {
   cl_int clErr = 0;
 
   // check whether an image present
   if (!m_Image->IsInitialized()){
     MITK_ERROR("ocl.Image") << "(mitk) Image not initialized!\n";
     return -1;
   }
 
   // there is a need for copy only if RAM-Data newer then GMEM data
   if (m_cpuModified)
   {
     //check the buffer
     if(m_gpuImage == NULL)
     {
       clErr = this->AllocateGPUImage();
     }
 
     if (m_Image->IsInitialized() &&
         (clErr == CL_SUCCESS))
     {
       const size_t origin[3] = {0, 0, 0};
       const size_t region[3] = {m_Dims[0], m_Dims[1], m_Dims[2]};
 
       if( this->m_formatSupported )
       {
-        clErr = clEnqueueWriteImage( gpuComQueue, m_gpuImage, CL_TRUE, origin, region, 0, 0, m_Image->GetData(), 0, NULL, NULL);
+        mitk::ImageReadAccessor accessor(m_Image);
+        clErr = clEnqueueWriteImage( gpuComQueue, m_gpuImage, CL_TRUE, origin, region, 0, 0, accessor.GetData(), 0, NULL, NULL);
       }
       else
       {
         MITK_ERROR << "Selected image format currently not supported...";
       }
 
       CHECK_OCL_ERR(clErr);
     }
     m_gpuModified = true;
   }
 
   return clErr;
 }
 
 cl_int mitk::OclImage::AllocateGPUImage()
 {
   cl_int clErr = 0;
 
   mitk::ServiceReference ref = GetModuleContext()->GetServiceReference<OclResourceService>();
   OclResourceService* resources = GetModuleContext()->GetService<OclResourceService>(ref);
 
   cl_context gpuContext = resources->GetContext();
 
   // initialize both proposed and supported format variables to same value
   this->m_proposedFormat = this->ConvertPixelTypeToOCLFormat();
   this->m_supportedFormat = this->m_proposedFormat;
 
   // test the current format for HW support
   this->m_formatSupported = resources->GetIsFormatSupported( &(this->m_supportedFormat) );
 
   // create an transfer kernel object in case the proposed format is not supported
   if( !(this->m_formatSupported) )
   {
     MITK_ERROR << "Original format not supported on the installed graphics card.";
     return -1;
   }
 
   // create new buffer
   if( this->m_dim > 2)
   {
     //Create a 3D Image
     m_gpuImage = clCreateImage3D(gpuContext, CL_MEM_READ_ONLY, &m_supportedFormat, *(m_Dims), *(m_Dims+1), *(m_Dims+2), 0, 0, NULL, &clErr);
   }
   else
   {
     //Create a 2D Image
     m_gpuImage = clCreateImage2D(gpuContext, CL_MEM_READ_ONLY, &m_supportedFormat,  *(m_Dims), *(m_Dims+1), 0, NULL, &clErr);
   }
   CHECK_OCL_ERR(clErr);
 
   return clErr;
 }
 
 cl_mem mitk::OclImage::GetGPUImage(cl_command_queue gpuComQueue)
 {
   // clGetMemObjectInfo()
   cl_mem_object_type memInfo;
   cl_int clErr = 0;
 
   // query image object info only if already initialized
   if( this->m_gpuImage )
   {
     clErr = clGetMemObjectInfo(this->m_gpuImage, CL_MEM_TYPE, sizeof(cl_mem_object_type), &memInfo, NULL );
     CHECK_OCL_ERR(clErr);
   }
 
   MITK_INFO << "Querying info for object, recieving: " << memInfo;
 
   // test if m_gpuImage CL_MEM_IMAGE_2/3D
   // if not, copy buffer to image
   if (memInfo == CL_MEM_OBJECT_BUFFER)
   {
     MITK_WARN << " Passed oclImage is a buffer-object, creating image";
 
     //hold a copy of the buffer gmem pointer
     cl_mem tempBuffer = this->m_gpuImage;
 
     const size_t origin[3] = {0, 0, 0};
     size_t region[3] = {this->m_Dims[0], this->m_Dims[1], 1};
 
     clErr = this->AllocateGPUImage();
 
     this->m_dim = 3;
 
     //copy last data to the image data
     clErr = clEnqueueCopyBufferToImage( gpuComQueue, tempBuffer, m_gpuImage, 0, origin, region, 0, NULL, NULL);
     CHECK_OCL_ERR(clErr);
 
     //release pointer
     clReleaseMemObject(tempBuffer);
 
   }
   return m_gpuImage;
 
 }
 
 void mitk::OclImage::SetPixelType(const cl_image_format *_image)
 {
   this->m_proposedFormat.image_channel_data_type = _image->image_channel_data_type;
   this->m_proposedFormat.image_channel_order = _image->image_channel_order;
 }
 
 void* mitk::OclImage::TransferDataToCPU(cl_command_queue gpuComQueue)
 {
   cl_int clErr = 0;
 
   // if image created on GPU, needs to create mitk::Image
   if( m_Image.IsNull() ){
     MITK_INFO << "Image not initialized, creating new one.";
     m_Image = mitk::Image::New();
   }
 
   // check buffersize/image size
   char* data = new char[m_bufferSize * m_BpE];
 
   // debug info
   oclPrintMemObjectInfo( m_gpuImage );
 
   clErr = clEnqueueReadBuffer( gpuComQueue, m_gpuImage, CL_FALSE, 0, m_bufferSize * m_BpE, data ,0, NULL, NULL);
   CHECK_OCL_ERR(clErr);
 
   clFlush( gpuComQueue );
   // the cpu data is same as gpu
   this->m_gpuModified = false;
 
   return (void*) data;
 
 }
 
 cl_image_format mitk::OclImage::ConvertPixelTypeToOCLFormat()
 {
   cl_image_format texFormat;
   //single channel Gray-Valued Images
   texFormat.image_channel_order = CL_R;
 
   MITK_INFO << "Class own value: " << this->m_BpE;
 
   switch ( this->m_BpE )
   {
   case 1:
     texFormat.image_channel_data_type = CL_UNSIGNED_INT8;
     MITK_INFO<< "PixelType: UCHAR => CLFormat: [CL_UNORM_INT8, CL_R]";
     break;
   case 2:
     texFormat.image_channel_data_type = CL_SIGNED_INT16;
     // texFormat.image_channel_order = CL_R;
     MITK_INFO<< "PixelType: SHORT => CLFormat: [CL_SIGNED_INT16, CL_R]";
     break;
   case 4:
     texFormat.image_channel_data_type = CL_FLOAT;
     MITK_INFO<< "Choosing CL_FLOAT";
     break;
   default:
     texFormat.image_channel_data_type = CL_UNORM_INT8;
     texFormat.image_channel_order = CL_RG;
     MITK_INFO<< "Choosing (default) short: 2-Channel UCHAR";
     break;
   }
 
   return texFormat;
 }
 
 int mitk::OclImage::GetDimension(int idx) const
 {
   if (this->m_dim > idx)
   {
     return m_Dims[idx];
   }
   else
   {
     MITK_WARN << "Trying to access non-existing dimension.";
     return 1;
   }
 }
 
 void mitk::OclImage::SetDimensions(unsigned int* Dims)
 {
   m_Dims = Dims;
 }
 
 void mitk::OclImage::SetDimension(unsigned short dim)
 {
   m_dim = dim;
 }
 
 float mitk::OclImage::GetSpacing(int idx)
 {
   if (this->m_dim > idx)
   {
     const float* imSpacing = m_Image->GetSlicedGeometry()->GetFloatSpacing();
 
     return imSpacing[idx];
   }
   else
   {
     MITK_WARN << "Trying to access non-existing dimension.";
     return 1;
   }
 }
 
 void mitk::OclImage::InitializeMITKImage()
 {
   this->m_Image = mitk::Image::New();
 }
 
 void mitk::OclImage::GetOffset(float* _imOffset) const
 {
 
   itk::Vector<float, 3> result2;
   result2.Fill(0.0f);
 
   result2 = this->m_Image->GetGeometry()->GetIndexToWorldTransform()->GetOffset();
 
   _imOffset[0] = result2[0];
   _imOffset[1] = result2[1];
   _imOffset[2] = result2[2];
 
 }