diff --git a/Modules/IpPicSupport/mitkPicFileReader.cpp b/Modules/IpPicSupport/mitkPicFileReader.cpp
index e841ad852d..3ba42ae077 100644
--- a/Modules/IpPicSupport/mitkPicFileReader.cpp
+++ b/Modules/IpPicSupport/mitkPicFileReader.cpp
@@ -1,373 +1,375 @@
 /*===================================================================
 
 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 "mitkPicFileReader.h"
 #include "mitkPicHelper.h"
 #include <itkImageFileReader.h>
+#include "mitkImageWriteAccessor.h"
 
 extern "C"
 {
   mitkIpPicDescriptor * MITKipPicGet( char *infile_name, mitkIpPicDescriptor *pic );
   mitkIpPicDescriptor * MITKipPicGetTags( char *infile_name, mitkIpPicDescriptor *pic );
 }
 
 void mitk::PicFileReader::GenerateOutputInformation()
 {
     Image::Pointer output = this->GetOutput();
 
     if ((output->IsInitialized()) && (this->GetMTime() <= m_ReadHeaderTime.GetMTime()))
         return;
 
     itkDebugMacro(<<"Reading file for GenerateOutputInformation()" << m_FileName);
 
     // Check to see if we can read the file given the name or prefix
     //
     if ( m_FileName == "" && m_FilePrefix == "" )
     {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
     }
 
     if( m_FileName != "")
     {
         mitkIpPicDescriptor* header=mitkIpPicGetHeader(const_cast<char *>(m_FileName.c_str()), NULL);
 
         if ( !header )
         {
             throw itk::ImageFileReaderException(__FILE__, __LINE__, "File could not be read.");
         }
 
         header=MITKipPicGetTags(const_cast<char *>(m_FileName.c_str()), header);
 
         int channels = 1;
 
         mitkIpPicTSV_t *tsv;
         if ( (tsv = mitkIpPicQueryTag( header, "SOURCE HEADER" )) != NULL)
         {
           if(tsv->n[0]>1e+06)
           {
             mitkIpPicTSV_t *tsvSH;
             tsvSH = mitkIpPicDelTag( header, "SOURCE HEADER" );
             mitkIpPicFreeTag(tsvSH);
           }
         }
         if ( (tsv = mitkIpPicQueryTag( header, "ICON80x80" )) != NULL)
         {
           mitkIpPicTSV_t *tsvSH;
           tsvSH = mitkIpPicDelTag( header, "ICON80x80" );
           mitkIpPicFreeTag(tsvSH);
         }
         if ( (tsv = mitkIpPicQueryTag( header, "VELOCITY" )) != NULL)
         {
           ++channels;
           mitkIpPicDelTag( header, "VELOCITY" );
         }
 
         if( header == NULL || header->bpe == 0)
         {
             itk::ImageFileReaderException e(__FILE__, __LINE__);
             std::ostringstream msg;
             msg << " Could not read file "
                 << m_FileName.c_str();
             e.SetDescription(msg.str().c_str());
             throw e;
             return;
         }
 
         // if pic image only 2D, the n[2] value is not initialized
         unsigned int slices = 1;
         if( header->dim == 2 )
             header->n[2] = slices;
 
         // First initialize the geometry of the output image by the pic-header
         SlicedGeometry3D::Pointer slicedGeometry = mitk::SlicedGeometry3D::New();
         PicHelper::InitializeEvenlySpaced(header, header->n[2], slicedGeometry);
 
         // if pic image only 3D, the n[3] value is not initialized
         unsigned int timesteps = 1;
         if( header->dim > 3 )
             timesteps = header->n[3];
 
         TimeSlicedGeometry::Pointer timeSliceGeometry = TimeSlicedGeometry::New();
         timeSliceGeometry->InitializeEvenlyTimed(slicedGeometry, timesteps);
         timeSliceGeometry->ImageGeometryOn();
 
         // Cast the pic descriptor to ImageDescriptor and initialize the output
 
         output->Initialize( CastToImageDescriptor(header));
         output->SetGeometry( timeSliceGeometry );
         mitkIpPicFree ( header );
     }
     else
     {
         int numberOfImages=0;
         m_StartFileIndex=0;
 
         mitkIpPicDescriptor* header=NULL;
 
         char fullName[1024];
 
         while(m_StartFileIndex<10)
         {
             sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+numberOfImages);
             FILE * f=fopen(fullName,"r");
             if(f==NULL)
             {
                 //already found an image?
                 if(numberOfImages>0)
                     break;
                 //no? let's increase start
                 ++m_StartFileIndex;
             }
             else
             {
                 fclose(f);
                 //only open the header of the first file found,
                 //@warning what to do when images do not have the same size??
                 if(header==NULL)
                 {
                     header=mitkIpPicGetHeader(fullName, NULL);
                     header=MITKipPicGetTags(fullName, header);
                 }
                 ++numberOfImages;
             }
         }
 
         printf("\n numberofimages %d\n",numberOfImages);
 
         if(numberOfImages==0)
         {
             itk::ImageFileReaderException e(__FILE__, __LINE__);
             std::ostringstream msg;
             msg << "no images found";
             e.SetDescription(msg.str().c_str());
             throw e;
             return;
         }
 
         //@FIXME: was ist, wenn die Bilder nicht alle gleich gross sind?
         if(numberOfImages>1)
         {
             printf("\n numberofimages %d > 1\n",numberOfImages);
             header->dim=3;
             header->n[2]=numberOfImages;
         }
 
         printf(" \ninitialisize output\n");
         output->Initialize( CastToImageDescriptor(header) );
         mitkIpPicFree ( header );
     }
 
     m_ReadHeaderTime.Modified();
 }
 
 void mitk::PicFileReader::ConvertHandedness(mitkIpPicDescriptor* pic)
 {
   //left to right handed conversion
   if(pic->dim>=3)
   {
       mitkIpPicDescriptor* slice=mitkIpPicCopyHeader(pic, NULL);
       slice->dim=2;
       size_t size=_mitkIpPicSize(slice);
       slice->data=malloc(size);
 
       size_t v, volumes = (pic->dim>3? pic->n[3] : 1);
       size_t volume_size = size*pic->n[2];
 
       for(v=0; v<volumes; ++v)
       {
         unsigned char *p_first=(unsigned char *)pic->data;
         unsigned char *p_last=(unsigned char *)pic->data;
         p_first+=v*volume_size;
         p_last+=size*(pic->n[2]-1)+v*volume_size;
 
         size_t i, smid=pic->n[2]/2;
         for(i=0; i<smid;++i,p_last-=size, p_first+=size)
         {
             memcpy(slice->data, p_last, size);
             memcpy(p_last, p_first, size);
             memcpy(p_first, slice->data, size);
         }
       }
       mitkIpPicFree(slice);
   }
 }
 
 void mitk::PicFileReader::GenerateData()
 {
     Image::Pointer output = this->GetOutput();
 
     // Check to see if we can read the file given the name or prefix
     //
     if ( m_FileName == "" && m_FilePrefix == "" )
     {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "One of FileName or FilePrefix must be non-empty");
     }
 
     if( m_FileName != "")
     {
         mitkIpPicDescriptor* outputPic = mitkIpPicNew();
-        outputPic = CastToIpPicDescriptor(output, outputPic);
+        mitk::ImageWriteAccessor imageAccess(output);
+        outputPic = CastToIpPicDescriptor(output, &imageAccess, outputPic);
         mitkIpPicDescriptor* pic=MITKipPicGet(const_cast<char *>(m_FileName.c_str()),
                                               outputPic);
         // comes upside-down (in MITK coordinates) from PIC file
         ConvertHandedness(pic);
 
         mitkIpPicTSV_t *tsv;
         if ( (tsv = mitkIpPicQueryTag( pic, "SOURCE HEADER" )) != NULL)
         {
           if(tsv->n[0]>1e+06)
           {
             mitkIpPicTSV_t *tsvSH;
             tsvSH = mitkIpPicDelTag( pic, "SOURCE HEADER" );
             mitkIpPicFreeTag(tsvSH);
           }
         }
         if ( (tsv = mitkIpPicQueryTag( pic, "ICON80x80" )) != NULL)
         {
           mitkIpPicTSV_t *tsvSH;
           tsvSH = mitkIpPicDelTag( pic, "ICON80x80" );
           mitkIpPicFreeTag(tsvSH);
         }
         if ( (tsv = mitkIpPicQueryTag( pic, "VELOCITY" )) != NULL)
         {
           mitkIpPicDescriptor* header = mitkIpPicCopyHeader(pic, NULL);
           header->data = tsv->value;
           ConvertHandedness(header);
           output->SetChannel(header->data, 1);
           header->data = NULL;
           mitkIpPicFree(header);
           mitkIpPicDelTag( pic, "VELOCITY" );
         }
 
         //slice-wise reading
         //currently much too slow.
         //else
         //{
         //  int sstart, smax;
         //  int tstart, tmax;
 
         //  sstart=output->GetRequestedRegion().GetIndex(2);
         //  smax=sstart+output->GetRequestedRegion().GetSize(2);
 
         //  tstart=output->GetRequestedRegion().GetIndex(3);
         //  tmax=tstart+output->GetRequestedRegion().GetSize(3);
 
         //  int s,t;
         //  for(s=sstart; s<smax; ++s)
         //  {
         //    for(t=tstart; t<tmax; ++t)
         //    {
         //      mitkIpPicDescriptor* pic=mitkIpPicGetSlice(const_cast<char *>(m_FileName.c_str()), NULL, t*smax+s+1);
         //      output->SetPicSlice(pic,s,t);
         //    }
         //  }
         //}
     }
     else
     {
         int position;
         mitkIpPicDescriptor*  pic=NULL;
 
         int zDim=(output->GetDimension()>2?output->GetDimensions()[2]:1);
         printf("\n zdim is %u \n",zDim);
 
         for (position = 0; position < zDim; ++position)
         {
             char fullName[1024];
 
             sprintf(fullName, m_FilePattern.c_str(), m_FilePrefix.c_str(), m_StartFileIndex+position);
 
             pic=MITKipPicGet(fullName, pic);
             if(pic==NULL)
             {
                 itkDebugMacro("Pic file '" << fullName << "' does not exist.");
             }
             /* FIXME else
             if(output->SetPicSlice(pic, position)==false)
             {
                 itkDebugMacro("Image '" << fullName << "' could not be added to Image.");
             }*/
        }
        if(pic!=NULL)
          mitkIpPicFree(pic);
     }
 }
 
 void mitk::PicFileReader::EnlargeOutputRequestedRegion(itk::DataObject *output)
 {
   output->SetRequestedRegionToLargestPossibleRegion();
 }
 
 bool mitk::PicFileReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
 {
   // First check the extension
   if(  filename == "" )
   {
       //MITK_INFO<<"No filename specified."<<std::endl;
     return false;
   }
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   bool extensionFound = false;
   std::string::size_type PICPos = filename.rfind(".pic");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".PIC");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".pic.gz");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 7))
     {
     extensionFound = true;
     }
 
   PICPos = filename.rfind(".seq");
   if ((PICPos != std::string::npos)
       && (PICPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
 
 mitk::PicFileReader::PicFileReader()
     : m_FileName(""), m_FilePrefix(""), m_FilePattern("")
 {
 }
 
 mitk::PicFileReader::~PicFileReader()
 {
 }
diff --git a/Modules/IpPicSupport/mitkPicFileWriter.cpp b/Modules/IpPicSupport/mitkPicFileWriter.cpp
index 46f1e98602..79969fb638 100644
--- a/Modules/IpPicSupport/mitkPicFileWriter.cpp
+++ b/Modules/IpPicSupport/mitkPicFileWriter.cpp
@@ -1,305 +1,306 @@
 /*===================================================================
 
 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 "mitkPicFileWriter.h"
 #include "mitkPicFileReader.h"
 
 extern "C"
 {
 size_t _mitkIpPicFWrite( const void *ptr, size_t size, size_t nitems, mitkIpPicFile_t stream);
 }
 
 mitk::PicFileWriter::PicFileWriter()
 {
   this->SetNumberOfRequiredInputs( 1 );
 }
 
 mitk::PicFileWriter::~PicFileWriter()
 {
 }
 
 void mitk::PicFileWriter::GenerateData()
 {
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   std::ofstream testfilehandle( m_FileName.c_str(), std::ios::out);
   if (!testfilehandle.good())
   {
     testfilehandle.close();
     itkExceptionMacro(<<"File location '" << m_FileName << "' not writeable");
   }
   else
   {
     testfilehandle.close();
   }
 
   Image::Pointer input = const_cast<Image*>(this->GetInput());
 
   if ( input.IsNull() )
   {
     itkExceptionMacro(<< "Nothing to write: Input is NULL." );
   }
 
   if( input->GetNumberOfChannels() > 1)
   {
     std::cout << "Multiple channel. Cannot write. Will throw...";
     itkExceptionMacro(<< "The PicFileWriter does not support multiple channel data. Nothing will be written." );
   }
 
   mitkIpPicDescriptor * picImage = mitkIpPicNew();
-  picImage = CastToIpPicDescriptor(input, picImage);
+  mitk::ImageWriteAccessor imageAccess(input);
+  picImage = CastToIpPicDescriptor(input, &imageAccess, picImage);
 
   SlicedGeometry3D* slicedGeometry = input->GetSlicedGeometry();
   if (slicedGeometry != NULL)
   {
     //set tag "REAL PIXEL SIZE"
     const Vector3D & spacing = slicedGeometry->GetSpacing();
     mitkIpPicTSV_t *pixelSizeTag;
     pixelSizeTag = mitkIpPicQueryTag( picImage, "REAL PIXEL SIZE" );
     if (!pixelSizeTag)
     {
       pixelSizeTag = (mitkIpPicTSV_t *) malloc( sizeof(mitkIpPicTSV_t) );
       pixelSizeTag->type = mitkIpPicFloat;
       pixelSizeTag->bpe = 32;
       strcpy(pixelSizeTag->tag, "REAL PIXEL SIZE");
       pixelSizeTag->dim = 1;
       pixelSizeTag->n[0] = 3;
       pixelSizeTag->value = malloc( sizeof(float) * 3 );
       mitkIpPicAddTag (picImage, pixelSizeTag);
     }
     ((float*)pixelSizeTag->value)[0] = spacing[0];
     ((float*)pixelSizeTag->value)[1] = spacing[1];
     ((float*)pixelSizeTag->value)[2] = spacing[2];
     //set tag "ISG"
     //ISG == offset/origin           transformation matrix(matrix)                                                              spancings
     //ISG == offset0 offset1 offset2 spalte0_0 spalte0_1 spalte0_2 spalte1_0 spalte1_1 spalte1_2 spalte2_0 spalte2_1 spalte2_2 spacing0 spacing1 spacing2
     mitkIpPicTSV_t *geometryTag;
     geometryTag = mitkIpPicQueryTag( picImage, "ISG" );
     if (!geometryTag)
     {
       geometryTag = (mitkIpPicTSV_t *) malloc( sizeof(mitkIpPicTSV_t) );
       geometryTag->type = mitkIpPicFloat;
       geometryTag->bpe = 32;
       strcpy(geometryTag->tag, "ISG");
       geometryTag->dim = 2;
       geometryTag->n[0] = 3;
       geometryTag->n[1] = 4;
       geometryTag->value = malloc( sizeof(float) * 3 * 4 );
       mitkIpPicAddTag (picImage, geometryTag);
     }
     const AffineTransform3D::OffsetType& offset = slicedGeometry->GetIndexToWorldTransform()->GetOffset();
     ((float*)geometryTag->value)[0] = offset[0];
     ((float*)geometryTag->value)[1] = offset[1];
     ((float*)geometryTag->value)[2] = offset[2];
 
     const AffineTransform3D::MatrixType& matrix = slicedGeometry->GetIndexToWorldTransform()->GetMatrix();
     const AffineTransform3D::MatrixType::ValueType* row0 = matrix[0];
     const AffineTransform3D::MatrixType::ValueType* row1 = matrix[1];
     const AffineTransform3D::MatrixType::ValueType* row2 = matrix[2];
 
     Vector3D v;
 
     FillVector3D(v, row0[0], row1[0], row2[0]);
     v.Normalize();
     ((float*)geometryTag->value)[3] = v[0];
     ((float*)geometryTag->value)[4] = v[1];
     ((float*)geometryTag->value)[5] = v[2];
 
     FillVector3D(v, row0[1], row1[1], row2[1]);
     v.Normalize();
     ((float*)geometryTag->value)[6] = v[0];
     ((float*)geometryTag->value)[7] = v[1];
     ((float*)geometryTag->value)[8] = v[2];
 
     ((float*)geometryTag->value)[9] = spacing[0];
     ((float*)geometryTag->value)[10] = spacing[1];
     ((float*)geometryTag->value)[11] = spacing[2];
   }
   PicFileReader::ConvertHandedness(picImage);  // flip upside-down in MITK coordinates
 
   // Following line added to detect write errors. If saving .pic files from the plugin is broken again,
   // please report a bug, don't just remove this line!
   int ret = MITKIpPicPut((char*)(m_FileName.c_str()), picImage);
 
   if (ret != 0)
   {
     PicFileReader::ConvertHandedness(picImage); // flip back from upside-down state
     throw std::ios_base::failure("Error during .pic file writing in "__FILE__);
   }
 
   PicFileReader::ConvertHandedness(picImage); // flip back from upside-down state
 }
 
 void mitk::PicFileWriter::SetInputImage( Image* image )
 {
   this->ProcessObject::SetNthInput( 0, image );
 }
 
 const mitk::Image* mitk::PicFileWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     MITK_ERROR << "No input image present.";
     return NULL;
   }
   else
   {
     return static_cast< const Image * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 int mitk::PicFileWriter::MITKIpPicPut( char *outfile_name, mitkIpPicDescriptor *pic )
 {
   FILE* outfile;
 
   mitkIpUInt4_t len;
   mitkIpUInt4_t tags_len;
 
   if( pic->info->write_protect )
   {
     fprintf( stderr, "mitkIpPicPut: sorry, can't write (missing tags !!!)\n" );
     //return( -1 );
   }
 
   if( mitkIpPicEncryptionType(pic) != ' ' )
   {
     fprintf( stderr, "mitkIpPicPut: warning: was encrypted !!!\n" );
   }
 
   if( outfile_name == NULL )
     outfile = stdout;
   else if( strcmp(outfile_name, "stdout") == 0 )
     outfile = stdout;
   else
   {
     mitkIpPicRemoveFile( outfile_name );
     // Removed due to linker problems when compiling
     // an mitk chili plugin using msvc: there appear
     // unresolved external symbol errors to function
     // _ipPicGetWriteCompression()
     /*
     if( mitkIpPicGetWriteCompression() )
     {
       char buff[1024];
 
       sprintf( buff, "%s.gz", outfile_name );
       outfile = (FILE*) mitkIpPicFOpen( buff, "wb" ); // cast to prevent warning.
     }
     else
     */
     outfile = fopen( outfile_name, "wb" );
   }
 
 
   if( outfile == NULL )
   {
     fprintf( stderr, "mitkIpPicPut: sorry, error opening outfile\n" );
     return( -1 );
   }
 
   tags_len = _mitkIpPicTagsSize( pic->info->tags_head );
 
   len = tags_len +        3 * sizeof(mitkIpUInt4_t)
       + pic->dim * sizeof(mitkIpUInt4_t);
 
   /* write oufile */
   if( mitkIpPicEncryptionType(pic) == ' ' )
     mitkIpPicFWrite( mitkIpPicVERSION, 1, sizeof(mitkIpPicTag_t), outfile );
   else
     mitkIpPicFWrite( pic->info->version, 1, sizeof(mitkIpPicTag_t), outfile );
 
   mitkIpPicFWriteLE( &len, sizeof(mitkIpUInt4_t), 1, outfile );
 
   mitkIpPicFWriteLE( &(pic->type), sizeof(mitkIpUInt4_t), 1, outfile );
   mitkIpPicFWriteLE( &(pic->bpe), sizeof(mitkIpUInt4_t), 1, outfile );
   mitkIpPicFWriteLE( &(pic->dim), sizeof(mitkIpUInt4_t), 1, outfile );
 
   mitkIpPicFWriteLE( pic->n, sizeof(mitkIpUInt4_t), pic->dim, outfile );
 
   _mitkIpPicWriteTags( pic->info->tags_head, outfile, mitkIpPicEncryptionType(pic) );
    // Removed due to linker problems when compiling
    // an mitk chili plugin using msvc: there appear
    // unresolved external symbol errors to function
    // _ipPicGetWriteCompression()
   /*
   if( mitkIpPicGetWriteCompression() )
     pic->info->pixel_start_in_file = mitkIpPicFTell( outfile );
   else
   */
   pic->info->pixel_start_in_file = ftell( outfile );
 
   if( pic->data )
   {
     size_t number_of_elements = _mitkIpPicElements(pic);
     size_t bytes_per_element = pic->bpe / 8;
     size_t number_of_bytes = number_of_elements * bytes_per_element;
     size_t block_size = 1024*1024; /* Use 1 MB blocks. Make sure that block size is smaller than 2^31 */
     size_t number_of_blocks = number_of_bytes / block_size;
     size_t remaining_bytes = number_of_bytes % block_size;
     size_t bytes_written = 0;
     size_t block_nr = 0;
     mitkIpUInt1_t* data = (mitkIpUInt1_t*) pic->data;
 
     assert( data != NULL );
 
     if( pic->type == mitkIpPicNonUniform )
     {
       for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr )
         bytes_written += mitkIpPicFWrite( data + ( block_nr * block_size ), 1, block_size, outfile );
       bytes_written += mitkIpPicFWrite( data + ( number_of_blocks * block_size ), 1, remaining_bytes, outfile );
     }
     else
     {
       for ( block_nr = 0 ; block_nr < number_of_blocks ; ++block_nr )
         bytes_written += mitkIpPicFWriteLE( data + ( block_nr * block_size ), 1, block_size, outfile );
       bytes_written += mitkIpPicFWriteLE( data + ( number_of_blocks * block_size ), 1, remaining_bytes, outfile );
     }
 
     if ( bytes_written != number_of_bytes )
     {
       fprintf( stderr, "Error while writing (ferror indicates %u), only %u bytes were written! Eof indicator is %u.\n", ferror(outfile), ( (unsigned int) ( bytes_written ) ), feof(outfile) );
       fclose( outfile );
       return( -1 );
     }
   }
 
   if( outfile != stdout )
   {
     // Removed due to linker problems when compiling
     // an mitk chili plugin using msvc: there appear
     // unresolved external symbol errors to function
     // _ipPicGetWriteCompression()
     /*
     if( mitkIpPicGetWriteCompression() )
       mitkIpPicFClose( outfile );
     else
     */
     fclose( outfile );
   }
 
   return( 0 );
 }
 
 std::vector<std::string> mitk::PicFileWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".pic");
   return possibleFileExtensions;
 }
diff --git a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
index 014e390b20..78defa2e6b 100644
--- a/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkCylindricToCartesianFilter.cpp
@@ -1,497 +1,498 @@
 /*===================================================================
 
 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 "mitkCylindricToCartesianFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 
 #include "mitkLegacyAdaptors.h"
 #include <ipPic/mitkIpPicTypeMultiplex.h>
 
 template <class T>
 void _transform(mitkIpPicDescriptor *pic, mitkIpPicDescriptor *dest, float _outsideValue, float *fr, float *fphi, float *fz, short *rt, unsigned int *phit, unsigned int *zt, mitkIpPicDescriptor *coneCutOff_pic)  //...t=truncated
 {
   T outsideValue = static_cast<T>(_outsideValue);
   register float f, ft, f0, f1, f2, f3;
 
   mitkIpInt2_t ox_size;
   mitkIpInt2_t nx_size, ny_size, nz_size;
   int oxy_size, nxy_size;
 
   T* orig, *dp, *dest_start;
 
   mitkIpInt2_t* coneCutOff=(mitkIpInt2_t*)coneCutOff_pic->data;
 
   orig=(T*)pic->data;
   ox_size=pic->n[0];
   oxy_size=ox_size*pic->n[1];
 
   nx_size=dest->n[0];
   ny_size=dest->n[1];
   nxy_size=nx_size*ny_size;
   nz_size=dest->n[2];
 
   /*nx_size=360;
   ny_size=360;
   nxy_size=nx_size*ny_size;
   nz_size=256;*/
 
   dest_start=dp=((T*)dest->data)+nxy_size*(nz_size-1);
 
   mitkIpInt2_t y;
   //  int size=_mitkIpPicElements(pic);
 
   register mitkIpInt2_t x,z;
   for(y=0;y<ny_size;++y)
   {
     mitkIpInt2_t x_start;
     register mitkIpInt2_t x_end;
     int r0plusphi0=*rt;
     if(r0plusphi0>=0)
     {
       x_start=0; x_end=nx_size;
     }
     else
     {
       x_start=-r0plusphi0; x_end=nx_size+r0plusphi0;
 
       for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
         for(x=0;x<x_start;++x,++dp)
           *dp=outsideValue;
       dp+=nxy_size*nz_size; dp+=x_end;
       for(z=0;z<nz_size;++z,dp+=-nxy_size-x_start)
         for(x=x_end;x<nx_size;++x,++dp)
           *dp=outsideValue;
       dp+=nxy_size*nz_size; dp-=x_end;
 
       fr+=x_start;
       fphi+=x_start;
       rt+=x_start;
       phit+=x_start;
       dp+=x_start;
       coneCutOff+=x_start;
     }
 
     for(x=x_start;x<x_end;++x, ++fr, ++fphi, ++rt, ++phit, ++dp, ++coneCutOff)
     {
       f=*fr;
       f3=*fphi;
       f0=1-f;
       f1=1-f3;
       f2=f0*f3;
       f0*=f1;
       f1*=f;
       f3*=f;
 
       r0plusphi0=*rt+*phit;
 
       mitkIpInt2_t z_start;
 
       z_start=*coneCutOff;
 
       T *op;
       register unsigned int step;
       unsigned int *ztp;
 
       op=orig+*rt+*phit;
 
       float *fzp;
 
       for(z=0;z<z_start;++z, dp-=nxy_size)
         *dp=outsideValue;
 
       ztp=zt+z_start;
       fzp=fz+z_start;
 
       for(z=z_start;z<nz_size;++z, dp-=nxy_size)
       {
         step=*(ztp++);
 
         register T *opt=op;
         opt+=step;
         f =*opt*f0;  ++opt;
         f+=*opt*f1;  opt+=oxy_size; --opt;
         f+=*opt*f2;  ++opt;
         f+=*opt*f3;  opt-=oxy_size; --opt;
 
         opt+=ox_size;
         ft =*opt*f0;  ++opt;
         ft+=*opt*f1;  opt+=oxy_size; --opt;
         ft+=*opt*f2;  ++opt;
         ft+=*opt*f3;
 
         *dp=(T)((1-*fzp)*f+*fzp*ft+0.5);
       }
 
       dp+=nxy_size*nz_size;
     }
     fr+=nx_size-x_end;
     fphi+=nx_size-x_end;
     rt+=nx_size-x_end;
     phit+=nx_size-x_end;
     dp+=nx_size-x_end;
     coneCutOff+=nx_size-x_end;
   }
 }
 
 void mitk::CylindricToCartesianFilter::buildTransformShortCuts(int orig_xsize, int orig_ysize, int orig_zsize, int new_xsize, mitkIpPicDescriptor * &rt_pic, mitkIpPicDescriptor * &phit_pic, mitkIpPicDescriptor * &fr_pic, mitkIpPicDescriptor * &fphi_pic, unsigned int * &zt, float * &fz)
 {
   --orig_zsize;
 
   rt_pic=mitkIpPicNew();
   rt_pic->type=mitkIpPicInt;
   rt_pic->bpe=16;
   rt_pic->dim=2;
   rt_pic->n[0]=rt_pic->n[1]=new_xsize;
   rt_pic->data=malloc(_mitkIpPicSize(rt_pic));
 
   phit_pic=mitkIpPicNew();
   phit_pic->type=mitkIpPicUInt;
   phit_pic->bpe=32;
   phit_pic->dim=2;
   phit_pic->n[0]=phit_pic->n[1]=new_xsize;
   phit_pic->data=malloc(_mitkIpPicSize(phit_pic));
 
   fr_pic=mitkIpPicNew();
   fr_pic->type=mitkIpPicFloat;
   fr_pic->bpe=32;
   fr_pic->dim=2;
   fr_pic->n[0]=fr_pic->n[1]=new_xsize;
   fr_pic->data=malloc(_mitkIpPicSize(fr_pic));
 
   fphi_pic=mitkIpPicNew();
   fphi_pic->type=mitkIpPicFloat;
   fphi_pic->bpe=32;
   fphi_pic->dim=2;
   fphi_pic->n[0]=fphi_pic->n[1]=new_xsize;
   fphi_pic->data=malloc(_mitkIpPicSize(fphi_pic));
 
   mitkIpInt2_t  *rtp=(mitkIpInt2_t*)rt_pic->data, *rt_xzero, rt, phit;
   mitkIpUInt4_t  *phitp=(mitkIpUInt4_t*)phit_pic->data;
   mitkIpFloat4_t *fr=(mitkIpFloat4_t *)fr_pic->data;
   mitkIpFloat4_t *fphi=(mitkIpFloat4_t *)fphi_pic->data;
 
   mitkIpFloat4_t r, phi, scale=(double)orig_xsize/(double)new_xsize;
 
   int x,y,xy0,xy0_orig, oxy_size, new_zsize;
   oxy_size=orig_xsize*orig_ysize;
   xy0=(int)(((double)new_xsize)/2+0.5);
   xy0_orig=(int)(((double)orig_xsize)/2+0.5);
 
   new_zsize=(int)(orig_ysize/scale);
   // \bug y compared to x
   for(y=0;y<new_xsize;++y)
   {
     rt_xzero=rtp; *rtp=0;
     for(x=0;x<new_xsize;++x,++fr,++fphi,++rtp, ++phitp)
     {
       int xq=x-xy0, yq=y-xy0;
 
       r=sqrt( (double) (xq*xq+yq*yq));
 
       //      float rtest=-(xy0-sqrt(xy0*xy0-yq*yq))-0.5;
       rt=(mitkIpInt2_t)(-(xy0-sqrt((double) (xy0*xy0-yq*yq)))-0.5);/*in rt steht der Index des Endes der zu �berspringenden Punkte=>anfangen bei -rt+1!*/
       //      if((x>=-rt) && (x<new_xsize+rt))
       {
         if(y!=xy0)
           r=r*(y>xy0?1.0:-1.0)*scale+xy0_orig;
         else
           r=r*(x>xy0?-1.0:1.0)*scale+xy0_orig;
         rt=(mitkIpInt2_t)r;
         int xtmp=x;
         if(x>xy0)
           xtmp=new_xsize-x;
         if(rt<0)
         {
           r=rt=0;
           if(xtmp>-*rt_xzero)
             *rt_xzero=-xtmp;
           *fr=0;
         }
         else
           if(rt>orig_xsize-1)
           {
             r=rt=orig_xsize-1;
             if(xtmp>-*rt_xzero)
               *rt_xzero=-xtmp;
             *fr=0;
           }
           else
             *fr=r-rt;
         if(*fr<0)
           *fr=0;
       }
       //      else
       //        *fr=0;
 
       phi=orig_zsize-(yq==0?1:-atan((float)xq/yq)/M_PI+0.5)*orig_zsize;
       phit=(mitkIpUInt4_t)phi;
       *fphi=phi-phit;
 
       *rtp=rt;
       *phitp=phit*oxy_size;
     }
   }
 
   zt=(unsigned int *)malloc(sizeof(unsigned int)*new_zsize);
   fz=(float *)malloc(sizeof(float)*new_zsize);
 
   float *fzp=fz;
   unsigned int *ztp=zt;
 
   int z;
   float z_step=orig_ysize/(orig_ysize*((float)new_xsize)/orig_xsize);
   for(z=0;z<new_zsize;++z,++fzp,++ztp)
   {
     *fzp=z*z_step;
     *ztp=(unsigned int)*fzp;
     *fzp-=*ztp;
     *ztp*=orig_xsize;
   }
 }
 
 void mitk::CylindricToCartesianFilter::buildConeCutOffShortCut(int orig_xsize, int orig_ysize, mitkIpPicDescriptor *rt_pic, mitkIpPicDescriptor *fr_pic, float a, float b, mitkIpPicDescriptor * &coneCutOff_pic)
 {
   coneCutOff_pic=mitkIpPicNew();
   coneCutOff_pic->type=mitkIpPicInt;
   coneCutOff_pic->bpe=16;
   coneCutOff_pic->dim=2;
   coneCutOff_pic->n[0]=coneCutOff_pic->n[1]=rt_pic->n[0];
   coneCutOff_pic->data=malloc(_mitkIpPicSize(coneCutOff_pic));
 
   int i, size=_mitkIpPicElements(rt_pic);
   mitkIpInt2_t *rt, *ccop, ohx_size, nz_size;
   mitkIpFloat4_t *fr;
 
   a*=(float)rt_pic->n[0]/orig_xsize;
   b*=(float)rt_pic->n[0]/orig_xsize;
 
   ohx_size=orig_xsize/2;
   nz_size=orig_ysize*rt_pic->n[0]/orig_xsize;
 
   rt=(mitkIpInt2_t *)rt_pic->data; fr=(mitkIpFloat4_t*)fr_pic->data; ccop=(mitkIpInt2_t *)coneCutOff_pic->data;
 
   for(i=0; i<size; ++i, ++rt, ++ccop)
   {
     register mitkIpInt2_t cco;
     if(*rt<=ohx_size)
       cco=(mitkIpInt2_t)(a*(*rt+*fr)+b);
     else
       cco=(mitkIpInt2_t)(a*(orig_xsize-(*rt+*fr))+b);
     if(cco<0)
       cco=0;
     if(cco>=nz_size)
       cco=nz_size;
     *ccop=cco;
   }
 }
 
 void mitk::CylindricToCartesianFilter::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
   if ((output->IsInitialized()) && (output->GetPipelineMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   mitk::Image::ConstPointer input = this->GetInput();
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   unsigned int i, *tmpDimensions=new unsigned int[std::max(3u,input->GetDimension())];
 
   tmpDimensions[0]=m_TargetXSize;
   if(tmpDimensions[0]==0)
     tmpDimensions[0] = input->GetDimension(0);
 
   float scale=((float)tmpDimensions[0])/input->GetDimension(0);
 
   tmpDimensions[1] = tmpDimensions[0];
   tmpDimensions[2] = (unsigned int)(scale*input->GetDimension(1));
 
   for(i=3;i<input->GetDimension();++i)
     tmpDimensions[i]=input->GetDimension(i);
 
   output->Initialize(input->GetPixelType(),
     input->GetDimension(),
     tmpDimensions,
     input->GetNumberOfChannels());
 
   // initialize the spacing of the output
   Vector3D spacing = input->GetSlicedGeometry()->GetSpacing();
   if(input->GetDimension()>=2)
     spacing[2]=spacing[1];
   else
     spacing[2] = 1.0;
   spacing[1] = spacing[0];
   spacing *= 1.0/scale;
   output->GetSlicedGeometry()->SetSpacing(spacing);
 
   mitk::Point3iProperty::Pointer pointProp;
   pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
   if (pointProp.IsNotNull() )
   {
     itk::Point<int, 3> tp = pointProp->GetValue();
     tp[2] = (int)(tmpDimensions[2]-tp[1] * scale-1);
     tp[0] = tmpDimensions[0]/2;
     tp[1] = tmpDimensions[0]/2;
     mitk::Point3iProperty::Pointer pointProp = mitk::Point3iProperty::New(tp);
     output->SetProperty("ORIGIN", pointProp);
   }
   delete [] tmpDimensions;
 
   //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
   //set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
   //@fixme!!! will not work for not evenly timed data!
   output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
   output->GetTimeSlicedGeometry()->InitializeEvenlyTimed(output->GetSlicedGeometry(), output->GetTimeSlicedGeometry()->GetTimeSteps());
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::CylindricToCartesianFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
   timeSelector->SetInput(input);
 
   mitkIpPicDescriptor* pic_transformed=NULL;
   pic_transformed = mitkIpPicNew();
   pic_transformed->dim=3;
   pic_transformed->bpe  = output->GetPixelType().GetBpe();
   //pic_transformed->type = output->GetPixelType().GetType();
   pic_transformed->n[0] = output->GetDimension(0);
   pic_transformed->n[1] = output->GetDimension(1);
   pic_transformed->n[2] = output->GetDimension(2);
   pic_transformed->data=malloc(_mitkIpPicSize(pic_transformed));
 
   int nstart, nmax;
   int tstart, tmax;
 
   tstart=output->GetRequestedRegion().GetIndex(3);
   nstart=output->GetRequestedRegion().GetIndex(4);
 
   tmax=tstart+output->GetRequestedRegion().GetSize(3);
   nmax=nstart+output->GetRequestedRegion().GetSize(4);
 
   if(zt==NULL)
   {
     timeSelector->SetChannelNr(nstart);
     timeSelector->SetTimeNr(tstart);
 
     buildTransformShortCuts(input->GetDimension(0),input->GetDimension(1), input->GetDimension(2), output->GetDimension(0), rt_pic, phit_pic, fr_pic, fphi_pic, zt, fz);
 
     // query the line limiting the sector
     a=b=0;
     mitk::FloatProperty::Pointer prop;
 
     prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE SLOPE").GetPointer());
     if (prop.IsNotNull() )
       a = prop->GetValue();
     prop = dynamic_cast<mitk::FloatProperty*>(input->GetProperty("SECTOR LIMITING LINE OFFSET").GetPointer());
     if (prop.IsNotNull() )
       b = prop->GetValue();
 
     buildConeCutOffShortCut(input->GetDimension(0),input->GetDimension(1), rt_pic, fr_pic, a, b, coneCutOff_pic);
     //    mitkIpPicPut("C:\\temp\\rt_90.pic",rt_pic);
     //mitkIpPicPut("C:\\temp\\coneCutOff.pic", coneCutOff_pic);
   }
 
   int n,t;
   for(n=nstart;n<nmax;++n)//output->GetNumberOfChannels();++n)
   {
     timeSelector->SetChannelNr(n);
 
     for(t=tstart;t<tmax;++t)
     {
       timeSelector->SetTimeNr(t);
 
       timeSelector->Update();
 
       // Cast to pic descriptor for the timeSelector image
       mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
-      CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic );
+      mitk::ImageWriteAccessor imageAccess(timeSelector->GetOutput());
+      CastToIpPicDescriptor( timeSelector->GetOutput(), &imageAccess, timeSelectorPic );
 
       _mitkIpPicFreeTags(pic_transformed->info->tags_head);
       pic_transformed->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
 
       if(input->GetDimension(2)>1)
       {
         mitkIpPicTypeMultiplex9(_transform, timeSelectorPic , pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
         //  mitkIpPicPut("1trf.pic",pic_transformed);
       }
       else
       {
         mitkIpPicDescriptor *doubleSlice = mitkIpPicCopyHeader( timeSelectorPic , NULL);
         doubleSlice->dim=3;
         doubleSlice->n[2]=2;
         doubleSlice->data=malloc(_mitkIpPicSize(doubleSlice));
         memcpy(doubleSlice->data, timeSelectorPic->data, _mitkIpPicSize(doubleSlice)/2);
         mitkIpPicTypeMultiplex9(_transform, doubleSlice, pic_transformed, m_OutsideValue, (float*)fr_pic->data, (float*)fphi_pic->data, fz, (short *)rt_pic->data, (unsigned int *)phit_pic->data, zt, coneCutOff_pic);
         mitkIpPicFree(doubleSlice);
       }
       output->SetVolume(pic_transformed->data, t, n);
     }
   }
   //mitkIpPicPut("outzzzzzzzz.pic",pic_transformed);
   mitkIpPicFree(pic_transformed);
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 mitk::CylindricToCartesianFilter::CylindricToCartesianFilter()
 : m_OutsideValue(0.0), m_TargetXSize(0)
 {
   rt_pic = NULL; phit_pic = NULL; fr_pic = NULL; fphi_pic = NULL; coneCutOff_pic = NULL;
   zt = NULL; fz = NULL;
   a=b=0.0;
 }
 
 mitk::CylindricToCartesianFilter::~CylindricToCartesianFilter()
 {
   if(rt_pic!=NULL)  mitkIpPicFree(rt_pic);
   if(phit_pic!=NULL)  mitkIpPicFree(phit_pic);
   if(fr_pic!=NULL)  mitkIpPicFree(fr_pic);
   if(fphi_pic!=NULL)  mitkIpPicFree(fphi_pic);
   if(coneCutOff_pic!=NULL)  mitkIpPicFree(coneCutOff_pic);
   if(zt != NULL)  free(zt);
   if(fz != NULL)  free (fz);
 }
 
 void mitk::CylindricToCartesianFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::ImageToImageFilter::InputImagePointer input =
     const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
   mitk::Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(0, 0);
   requestedRegion.SetIndex(1, 0);
   requestedRegion.SetIndex(2, 0);
   requestedRegion.SetSize(0, input->GetDimension(0));
   requestedRegion.SetSize(1, input->GetDimension(1));
   requestedRegion.SetSize(2, input->GetDimension(2));
 
   input->SetRequestedRegion( & requestedRegion );
 }
diff --git a/Modules/MitkExt/Algorithms/mitkDopplerToStrainRateFilter.cpp b/Modules/MitkExt/Algorithms/mitkDopplerToStrainRateFilter.cpp
index 361995c59d..05be5f7a25 100644
--- a/Modules/MitkExt/Algorithms/mitkDopplerToStrainRateFilter.cpp
+++ b/Modules/MitkExt/Algorithms/mitkDopplerToStrainRateFilter.cpp
@@ -1,384 +1,386 @@
 /*===================================================================
 
 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 "mitkDopplerToStrainRateFilter.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkProperties.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkLegacyAdaptors.h"
 
 #include <iostream>
 #include <string>
 #include <ipFunc/mitkIpFunc.h>
 
 
 void mitk::DopplerToStrainRateFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if ((output->IsInitialized()) && (this->GetMTime() <= m_TimeOfHeaderInitialization.GetMTime()))
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   unsigned int i;
   unsigned int *tmpDimensions = new unsigned int[input->GetDimension()];
 
   for(i=0;i<input->GetDimension();++i)
     tmpDimensions[i]=input->GetDimension(i);
 
   //@todo maybe we should shift the following somehow in ImageToImageFilter
   output->Initialize(input->GetPixelType(),
     input->GetDimension(),
     tmpDimensions,
     input->GetNumberOfChannels());
 
   output->GetSlicedGeometry()->SetSpacing(input->GetSlicedGeometry()->GetSpacing());
 
   //output->GetSlicedGeometry()->SetGeometry2D(mitk::Image::BuildStandardPlaneGeometry2D(output->GetSlicedGeometry(), tmpDimensions).GetPointer(), 0);
   //output->GetSlicedGeometry()->SetEvenlySpaced();
   //set the timebounds - after SetGeometry2D, so that the already created PlaneGeometry will also receive this timebounds.
   output->GetSlicedGeometry()->SetTimeBounds(input->GetSlicedGeometry()->GetTimeBounds());
 
   output->SetPropertyList(input->GetPropertyList()->Clone());
 
 
   delete [] tmpDimensions;
 
   m_TimeOfHeaderInitialization.Modified();
 }
 
 void mitk::DopplerToStrainRateFilter::GenerateData()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
 
   mitk::Point3iProperty::Pointer pointProp;
   pointProp = dynamic_cast<mitk::Point3iProperty*>(input->GetProperty("ORIGIN").GetPointer());
   if (pointProp.IsNotNull() )
   {
     m_Origin = pointProp->GetValue();
   }
 
   MITK_INFO << "compute Strain Rate Image .... " << std::endl
            << "  origin[0]=" << m_Origin[0] << " origin[1]=" << m_Origin[1] << " origin[2]=" << m_Origin[2] << std::endl
            << "  distance=" << m_Distance << std::endl
            << "  NoStrainIntervall=" << m_NoStrainInterval << std::endl;
 
   const Vector3D & spacing = input->GetSlicedGeometry()->GetSpacing();
   //  MITK_INFO << "   in: xres=" << spacing[0] << " yres=" << spacing[1] << " zres=" << spacing[2] << std::endl;
 
 
   mitk::ImageTimeSelector::Pointer timeSelector=mitk::ImageTimeSelector::New();
   timeSelector->SetInput(input);
 
   mitkIpPicDescriptor* picStrainRate;
   picStrainRate = mitkIpPicNew();
   picStrainRate->dim=3;
   picStrainRate->bpe  = output->GetPixelType().GetBpe();
   //picStrainRate->type = output->GetPixelType().GetType();
   picStrainRate->n[0] = output->GetDimension(0);
   picStrainRate->n[1] = output->GetDimension(1);
   picStrainRate->n[2] = output->GetDimension(2);
   picStrainRate->data=malloc(_mitkIpPicSize(picStrainRate));
 
 
   int xDim = picStrainRate->n[0];
   int yDim = picStrainRate->n[1];
   int zDim = picStrainRate->n[2];
   long slice_size = xDim*yDim;
   long vol_size = slice_size*zDim;
 
 
   mitkIpPicDescriptor *picDoppler;
 
   int x,y,z;//,time;        // loop-counter
   int strainRate;            // the computed Strain Rate
   int v1,v2;                // velocity and Point p1 and p2
 
   float alpha;                // the beam-angle, angle betwen current point and beam-point
   float dx=0, dy=0;                // projection of this->distance to x- and y-axis
   int x1;          // a square, where the velocity v1 lies in
   int y1;          // the points are used for interpolation
 
 
   int minStrainRate=128, maxStrainRate=128;
 
   int n, nmax;
   int t, tmax;
 
   t = output->GetRequestedRegion().GetIndex(3);
   n = output->GetRequestedRegion().GetIndex(4);
   MITK_INFO << "t = " <<t << " n = " << n << std::endl;
 
   tmax = t + output->GetRequestedRegion().GetSize(3);
   nmax = n + output->GetRequestedRegion().GetSize(4);
   MITK_INFO << "tmax = "<< tmax << " nmax = " << nmax << std::endl;
 
   if (m_Distance<1) m_Distance=1;
 
   for(;n<nmax;n++)//output->GetNumberOfChannels();++n)
   {
     timeSelector->SetChannelNr(n);
     MITK_INFO << "computing chanel n = " << n << std::endl;
 
     for(t=0;t<tmax;t++)
     {
       MITK_INFO << "computing time slot t = " << t << std::endl;
       timeSelector->SetTimeNr(t);
       timeSelector->Update();
 
       // Cast to pic descriptor for the timeSelector image
       mitkIpPicDescriptor* timeSelectorPic = mitkIpPicNew();
-      CastToIpPicDescriptor( timeSelector->GetOutput(), timeSelectorPic );
+      ImageWriteAccessor imageAccess(timeSelector->GetOutput());
+      CastToIpPicDescriptor( timeSelector->GetOutput(), &imageAccess, timeSelectorPic );
 
       _mitkIpPicFreeTags(picStrainRate->info->tags_head);
       picStrainRate->info->tags_head = _mitkIpPicCloneTags(timeSelectorPic->info->tags_head);
 
 //#define       WRITE_ANGLE_PIC
 #ifdef WRITE_ANGLE_PIC
       mitkIpPicDescriptor *anglePic;
       mitkIpBool_t isAnglePicWritten = mitkIpFalse;
 
       anglePic = mitkIpPicNew();
       anglePic->type = mitkIpPicInt;
       anglePic->bpe = 8;
       anglePic->dim = 2;
       anglePic->n[0] = xDim;
       anglePic->n[1] = yDim;
       anglePic->data = (mitkIpInt1_t *)calloc(xDim*yDim,sizeof(mitkIpInt1_t));
 #endif
 
       picDoppler = timeSelectorPic;
       picDoppler = mitkIpFuncGausF( picDoppler, 5,2 , mitkIpFuncBorderOld )  ;
 
 
 
       for (z=0 ; z<zDim ; z++) {
 
 
         for (y=1; y<yDim; y++) {
 
           if (y<m_Origin[1]) continue;  // cannot compute StrainRate above Transducer-Position
 
           for (x=0; x<xDim; x++) {
 
             if ((m_Origin[0] - x)==0) {  // winkelhalbierende
 
               int yDistanceInUnits = (int)( m_Distance/spacing[1]);
               int yTmp = ( (y-yDistanceInUnits)<0 )  ? 0 : (y-yDistanceInUnits);
               v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + yTmp*xDim + x] ;
               v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
 
             } else {
 
               // compute angle to transducer position
               // m_Origin is given in units, not in mm
               alpha = atan( (float) (m_Origin[0] - x)  / (float) (m_Origin[1] - y) );
 
               // m_Distance is given in mm
               dx = -sin(alpha) * m_Distance;
               dy = -cos(alpha) * m_Distance;
 
 
               // convert to units
               dx = dx/spacing[0];
               dy = dy/spacing[1];
 
               //#define WEIGTHED
 #ifdef WEIGTHED
               weightX = dx - floor(dx);
               weightY = dy - floor(dy);
 
               dxFloor = (int) floor(dx);
               dyFloor = (int) floor(dy);
 
               x1 = x + dxFloor;          // lower left
               y1 = y + dyFloor;
 
               x2 = x + (dxFloor+1);      // lower right
               y2 = y + dyFloor;
 
               x3 = x + (dxFloor+1);      // upper right
               y3 = y + (dyFloor+1);
 
               x4 = x + dxFloor;          // upper left
               y4 = y + (dyFloor+1);
 
               vTmp1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
               vTmp2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y2*xDim + x2];
               vTmp3 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y3*xDim + x3];
               vTmp4 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y4*xDim + x4];
 
               v1 = (int) ((1-weightX)*(1-weightY)*vTmp1 + weightX*(1-weightY)*vTmp2 + weightX*weightY*vTmp3 + (1-weightX)*weightY*vTmp4);
               v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
 #else
               x1 = (int)(x + dx);
               y1 = (int)(y + dy);
               if (y1<0) y1=0;
 
 #endif
               v1 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
               v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y*xDim + x] ;
             }
 
             if (v1==128) {  // schaue in Gegenrichtung, falls keine SRI hier berechenbar
               x1 = (int)(x - dx);
               y1 = (int)(y - dy);
               if (y1>yDim) y1=yDim;
               //swap v1 and v2, otherwise StrainRate is calculate in false direction
               v1 = v2;
               v2 = ((mitkIpUInt1_t *)picDoppler->data)[z*slice_size + y1*xDim + x1];
             }
 
             if (   (v1==0 ) || (v2==0)  ||  // wenn keine Geschwindigkeit vorhanden
               // oder wenn nur ganz kleine Geschwindigkeit vorhanden
               (v1>=(128-m_NoStrainInterval) && v1<=(128+m_NoStrainInterval)) ||
               (v2>=(128-m_NoStrainInterval) && v2<=(128+m_NoStrainInterval))) {
 
                 strainRate = 128;  // this means no deformation
                 // this is neccessay due to the Cyl2Cart filter
 
               } else {
                 strainRate = (int)( (v1 - v2)/2 + 128 );
                 if (strainRate==128) strainRate=129;
               }
 
               if (strainRate < minStrainRate && strainRate > 0 )
                 minStrainRate = strainRate;
 
               if (strainRate > maxStrainRate)
                 maxStrainRate = strainRate;
 
               if (strainRate<0 ) {
                 //strainRate = -strainRate;
                 MITK_INFO << " error: neg. strainRate ... exit() " << std::endl
                          << " x=" << x << " y=" << y << " z=" << z << std::endl
                          << " v1=" << v1 << " v2=" << v2 << " dist=" << m_Distance << std::endl
                          << " sr=" << strainRate  << std::endl;
                 exit(0);
               }
 
 
               ((mitkIpUInt1_t *)picStrainRate->data)[t*vol_size + z*slice_size + y*xDim + x]=strainRate;
 
               // cout << "z: " << z << " y: " << y << " x: " << x << " strainrate: " << strainRate << endl;
 
 #ifdef WRITE_ANGLE_PIC
               //            if (!isAnglePicWritten)
               //          ((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( (alpha/1.6)*128);
               if (!isAnglePicWritten)
                 ((mitkIpInt1_t *)anglePic->data)[y*xDim + x] = (int) ( dx);
 
 #endif
 
           }  // x
 
         } // y
 
         //isAnglePicWritten = mitkIpTrue;
 
       } // z
 
       //isStrainComputed = mitkIpTrue;
       std::string filenameD;
       filenameD ="doppler.pic";
       mitkIpPicPut(const_cast<char *>(filenameD.c_str()),picDoppler);
 
 #define WRITE_STRAIN_PIC
 #ifdef WRITE_STRAIN_PIC
       char tmpfilename[100];
       sprintf(tmpfilename,"strain%d.pic",t);;
       mitkIpPicPut(tmpfilename,picStrainRate);
 #endif
 
 
 #ifdef WRITE_ANGLE_PIC
       std::string filename2;
       filename2="angle.pic";
       mitkIpPicPut(const_cast<char *>(filename2.c_str()),anglePic);
 #endif
       ((mitkIpUInt1_t *)picStrainRate->data)[0]=0;
       ((mitkIpUInt1_t *)picStrainRate->data)[1]=255;
 
       output->SetVolume(picStrainRate->data, t, n);
     }
   }
 
   mitkIpPicFree(picStrainRate);
 
 #define WRITE_STRAIN_PIC
 #ifdef WRITE_STRAIN_PIC
       // Get the StrainRate ipPic descriptor
       picStrainRate = mitkIpPicNew();
-      CastToIpPicDescriptor( output, picStrainRate );
+      ImageWriteAccessor imageAccess(output);
+      CastToIpPicDescriptor( output, &imageAccess, picStrainRate );
 
       std::string filename;
       filename ="strain.pic";
       mitkIpPicPut(const_cast<char *>(filename.c_str()),picStrainRate);
 #endif
 
   MITK_INFO << "Strain Rate Image computed.... " << std::endl
            << "  minStrainRate: " << minStrainRate << std::endl
            << "  maxStrainRate: " << maxStrainRate << std::endl;
 }
 
 mitk::DopplerToStrainRateFilter::DopplerToStrainRateFilter()
 : m_Distance(10), m_NoStrainInterval(2)
 {
 
   m_Origin[0] = 0;
   m_Origin[1] = 0;
   m_Origin[2] = 0;
 
 }
 
 float mitk::DopplerToStrainRateFilter::GetLimit()
 {  return (128/m_Distance);
 }
 
 
 mitk::DopplerToStrainRateFilter::~DopplerToStrainRateFilter()
 {
 
 }
 
 void mitk::DopplerToStrainRateFilter::GenerateInputRequestedRegion()
 {
   Superclass::GenerateInputRequestedRegion();
 
   mitk::ImageToImageFilter::InputImagePointer input =
     const_cast< mitk::ImageToImageFilter::InputImageType * > ( this->GetInput() );
   mitk::Image::Pointer output = this->GetOutput();
 
   Image::RegionType requestedRegion;
   requestedRegion = output->GetRequestedRegion();
   requestedRegion.SetIndex(0, 0);
   requestedRegion.SetIndex(1, 0);
   requestedRegion.SetIndex(2, 0);
   //requestedRegion.SetIndex(3, 0);
   //requestedRegion.SetIndex(4, 0);
   requestedRegion.SetSize(0, input->GetDimension(0));
   requestedRegion.SetSize(1, input->GetDimension(1));
   requestedRegion.SetSize(2, input->GetDimension(2));
   //requestedRegion.SetSize(3, output->GetDimension(3));
   //requestedRegion.SetSize(4, output->GetNumberOfChannels());
 
   input->SetRequestedRegion( & requestedRegion );
 }