diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index 04d5b52d08..03bdd61eea 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,457 +1,457 @@
 /*===================================================================
 
 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 "mitkImageWriter.h"
 
 #include "mitkItkPictureWrite.h"
 #include "mitkImage.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageReadAccessor.h"
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 
 mitk::ImageWriter::ImageWriter()
 {
   this->SetNumberOfRequiredInputs( 1 );
   m_MimeType = "";
   SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetFileName(const char* fileName)
 {
   if ( fileName && ( fileName == this->m_FileName ) )
   {
     return;
   }
   if ( fileName )
   {
     this->m_FileName = fileName;
     this->m_FileNameWithoutExtension = this->m_FileName;
     this->m_Extension.clear();
     std::size_t pos = this->m_FileName.find_last_of("/\\");
     if (pos != std::string::npos)
     {
       std::size_t ppos = this->m_FileName.find_first_of('.', pos);
       if (ppos != std::string::npos)
       {
         this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
         this->m_Extension = this->m_FileName.substr(ppos);
       }
     }
   }
   else
   {
     this->m_FileName.clear();
     this->m_FileNameWithoutExtension.clear();
     this->m_Extension.clear();
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetFileName(const std::string & fileName)
 {
   this->SetFileName( fileName.c_str() );
 }
 
 void mitk::ImageWriter::SetExtension(const char* extension)
 {
   if ( extension && ( extension == this->m_Extension ) )
   {
     return;
   }
   if ( extension )
   {
     this->m_Extension = extension;
     this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   }
   else
   {
     this->m_Extension.clear();
     this->m_FileName = this->m_FileNameWithoutExtension;
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetExtension(const std::string & extension)
 {
   this->SetFileName( extension.c_str() );
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
   this->m_Extension = ".mhd";
   this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   this->Modified();
 }
 
 #include <vtkConfigure.h>
 #include <vtkImageData.h>
 #include <vtkXMLImageDataWriter.h>
 static void writeVti(const char * filename, mitk::Image* image, int t=0)
 {
   vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
   vtkwriter->SetFileName( filename );
   vtkwriter->SetInput(image->GetVtkImageData(t));
   vtkwriter->Write();
   vtkwriter->Delete();
 }
 
 #include <itkRGBAPixel.h>
 
 void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
 {
   MITK_INFO << "Writing image: " << fileName << std::endl;
   // Pictures and picture series like .png are written via a different mechanism then volume images.
   // So, they are still multiplexed and thus not support vector images.
-  if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos)
+  if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos || fileName.find(".jpg") != std::string::npos || fileName.find(".bmp") != std::string::npos)
   {
     try
     {
       // switch processing of single/multi-component images
       if( image->GetPixelType(0).GetNumberOfComponents() == 1)
       {
         AccessByItk_1( image, _mitkItkPictureWrite, fileName );
       }
       else
       {
         AccessFixedPixelTypeByItk_1( image, _mitkItkPictureWriteComposite, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ , fileName);
       }
     }
     catch(itk::ExceptionObject &e)
     {
       std::cerr << "Caught " << e.what() << std::endl;
     }
     catch(std::exception &e)
     {
       std::cerr << "Caught std::exception " << e.what() << std::endl;
     }
 
     return;
   }
 
   // Implementation of writer using itkImageIO directly. This skips the use
   // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
   unsigned int dimension = image->GetDimension();
   unsigned int* dimensions = image->GetDimensions();
   mitk::PixelType pixelType = image->GetPixelType();
   mitk::Vector3D spacing = image->GetGeometry()->GetSpacing();
   mitk::Point3D origin = image->GetGeometry()->GetOrigin();
 
   itk::ImageIOBase::Pointer imageIO = itk::ImageIOFactory::CreateImageIO( fileName.c_str(),
     itk::ImageIOFactory::WriteMode );
 
   if(imageIO.IsNull())
   {
     itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
   }
 
   // Set the necessary information for imageIO
   imageIO->SetNumberOfDimensions(dimension);
   imageIO->SetPixelType( pixelType.GetPixelType() );
   imageIO->SetComponentType( pixelType.GetComponentType() < PixelComponentUserType ?
                              static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                              itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
   imageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
 
   itk::ImageIORegion ioRegion( dimension );
 
   for(unsigned int i=0; i<dimension; i++)
   {
     imageIO->SetDimensions(i,dimensions[i]);
     imageIO->SetSpacing(i,spacing[i]);
     imageIO->SetOrigin(i,origin[i]);
 
     mitk::Vector3D direction;
     direction.SetVnlVector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
     vnl_vector< double > axisDirection(dimension);
     for(unsigned int j=0; j<dimension; j++)
     {
       axisDirection[j] = direction[j]/spacing[i];
     }
     imageIO->SetDirection( i, axisDirection );
 
     ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i) );
     ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i) );
   }
 
   //use compression if available
   imageIO->UseCompressionOn();
 
   imageIO->SetIORegion(ioRegion);
   imageIO->SetFileName(fileName);
 
   ImageReadAccessor imageAccess(image);
   imageIO->Write(imageAccess.GetData());
 }
 
 void mitk::ImageWriter::GenerateData()
 {
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   FILE* tempFile = fopen(m_FileName.c_str(),"w");
   if (tempFile==NULL)
   {
     itkExceptionMacro(<<"File location not writeable");
     return;
   }
   fclose(tempFile);
   remove(m_FileName.c_str());
 
   // Creating clone of input image, since i might change the geometry
   mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput())->Clone();
 
   // Check if geometry information will be lost
   if (input->GetDimension() == 2)
   {
      if (!input->GetGeometry()->Is2DConvertable())
      {
         MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
 
         // set matrix to identity
         mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
         affTrans->SetIdentity();
         mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
         mitk::Point3D origin = input->GetGeometry()->GetOrigin();
         input->GetGeometry()->SetIndexToWorldTransform(affTrans);
         input->GetGeometry()->SetSpacing(spacing);
         input->GetGeometry()->SetOrigin(origin);
      }
   }
 
   bool vti = (m_Extension.find(".vti") != std::string::npos);
 
   // If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
   if ( m_Extension.find(".pic") == std::string::npos
        && m_Extension.find(".nrrd") == std::string::npos
        && m_Extension.find(".nii") == std::string::npos
        && m_Extension.find(".nii.gz") == std::string::npos
        )
   {
     if(input->GetDimension() > 3)
     {
       int t, timesteps;
 
       timesteps = input->GetDimension(3);
       ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
       timeSelector->SetInput(input);
       mitk::Image::Pointer image = timeSelector->GetOutput();
       for(t = 0; t < timesteps; ++t)
       {
         std::ostringstream filename;
         timeSelector->SetTimeNr(t);
         timeSelector->Update();
         if(input->GetTimeSlicedGeometry()->IsValidTime(t))
         {
           const mitk::TimeBounds& timebounds = input->GetTimeSlicedGeometry()->GetGeometry3D(t)->GetTimeBounds();
           filename <<  m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
         }
         else
         {
           itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of image " << filename << ".");
           filename <<  m_FileNameWithoutExtension << "_T" << t << m_Extension;
         }
         if ( vti )
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(image, filename.str());
         }
       }
     }
     else if ( vti )
     {
       writeVti(m_FileName.c_str(), input);
     }
     else
     {
       WriteByITK(input, m_FileName);
     }
   }
   else
   {
     // use the PicFileWriter for the .pic data type
     if( m_Extension.find(".pic") != std::string::npos )
     {
 /*    PicFileWriter::Pointer picWriter = PicFileWriter::New();
     size_t found;
     found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
     if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
     {
       //if Extension not in Filename
       std::ostringstream filename;
       filename <<  m_FileName.c_str() << m_Extension;
       picWriter->SetFileName( filename.str().c_str() );
     }
     else
     {
       picWriter->SetFileName( m_FileName.c_str() );
     }
     picWriter->SetInputImage( input );
     picWriter->Write();
 */    }
 
     // use the ITK .nrrd Image writer
     if( m_Extension.find(".nrrd") != std::string::npos
         || m_Extension.find(".nii") != std::string::npos
         || m_Extension.find(".nii.gz") != std::string::npos
         )
     {
         WriteByITK(input, this->m_FileName);
     }
   }
   m_MimeType = "application/MITK.Pic";
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 }
 
 bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     return this->CanWriteBaseDataType(input->GetData());
   }
   return false;
 }
 
 void mitk::ImageWriter::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
 }
 
 std::string mitk::ImageWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".pic");
   possibleFileExtensions.push_back(".pic.gz");
   possibleFileExtensions.push_back(".bmp");
   possibleFileExtensions.push_back(".dcm");
   possibleFileExtensions.push_back(".DCM");
   possibleFileExtensions.push_back(".dicom");
   possibleFileExtensions.push_back(".DICOM");
   possibleFileExtensions.push_back(".gipl");
   possibleFileExtensions.push_back(".gipl.gz");
   possibleFileExtensions.push_back(".mha");
   possibleFileExtensions.push_back(".nii");
   possibleFileExtensions.push_back(".nii.gz");
   possibleFileExtensions.push_back(".nrrd");
   possibleFileExtensions.push_back(".nhdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".PNG");
   possibleFileExtensions.push_back(".spr");
   possibleFileExtensions.push_back(".mhd");
   possibleFileExtensions.push_back(".vtk");
   possibleFileExtensions.push_back(".vti");
   possibleFileExtensions.push_back(".hdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".tif");
   possibleFileExtensions.push_back(".jpg");
   return possibleFileExtensions;
 }
 
 std::string mitk::ImageWriter::GetFileExtension()
 {
   return m_Extension;
 }
 
 void mitk::ImageWriter::SetInput( mitk::Image* image )
 {
   this->ProcessObject::SetNthInput( 0, image );
 }
 
 const mitk::Image* mitk::ImageWriter::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const mitk::Image * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 const char* mitk::ImageWriter::GetDefaultFilename()
 {
   return "Image.nrrd";
 }
 
 const char* mitk::ImageWriter::GetFileDialogPattern()
 {
   return "Image (*.bmp *.dcm *.DCM *.dicom *.DICOM *.gipl *.gipl.gz *.mha "
       "*.nii *.nii.gz *.nrrd *.nhdr *.png *.PNG *.spr *.mhd *.vtk *.vti *.hdr *.png "
       "*.tif *.jpg)";
 }
 
 const char *mitk::ImageWriter::GetDefaultExtension()
 {
   return ".nrrd";
 }
 
 bool mitk::ImageWriter::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return dynamic_cast<mitk::Image*>( data.GetPointer() );
 }
 
 void mitk::ImageWriter::DoWrite(BaseData::Pointer data)
 {
   if (this->CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::Image *>(data.GetPointer()));
     this->Update();
   }
 }
diff --git a/Core/Code/Testing/mitkImageWriterTest.cpp b/Core/Code/Testing/mitkImageWriterTest.cpp
index 52cef87147..d30f1c9f24 100644
--- a/Core/Code/Testing/mitkImageWriterTest.cpp
+++ b/Core/Code/Testing/mitkImageWriterTest.cpp
@@ -1,253 +1,287 @@
 /*===================================================================
 
 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 "mitkImageWriter.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkTestingMacros.h"
 #include "mitkItkImageFileReader.h"
 #include "mitkException.h"
 
 #include <mitkExtractSliceFilter.h>
 #include "mitkIOUtil.h"
 
 #include <iostream>
 #include <fstream>
 
 #ifdef WIN32
 #include "process.h"
 #else
 #include <unistd.h>
 #endif
 
 std::string AppendExtension(const std::string &filename, const char *extension)
 {
   std::string new_filename = filename;
 
   new_filename += extension;
   return new_filename;
 }
 
-bool CompareImageMetaData( mitk::Image::Pointer image, mitk::Image::Pointer reference)
+bool CompareImageMetaData( mitk::Image::Pointer image, mitk::Image::Pointer reference, bool checkPixelType = true )
 {
   // switch to AreIdentical() methods as soon as Bug 11925 (Basic comparison operators) is fixed
 
   if( image->GetDimension() != reference->GetDimension() )
   {
     MITK_ERROR << "The image dimension differs: IN (" << image->GetDimension() << ") REF(" << reference->GetDimension() << ")";
     return false;
   }
 
   // pixel type
-  if( image->GetPixelType() != reference->GetPixelType()
-      && image->GetPixelType().GetBitsPerComponent() != reference->GetPixelType().GetBitsPerComponent() )
+  if( checkPixelType &&
+      ( image->GetPixelType() != reference->GetPixelType()
+      && image->GetPixelType().GetBitsPerComponent() != reference->GetPixelType().GetBitsPerComponent() ) )
   {
-    MITK_ERROR << "Pixeltype differs ";
+    MITK_ERROR << "Pixeltype differs ( image=" << image->GetPixelType().GetPixelTypeAsString() << "[" << image->GetPixelType().GetBitsPerComponent() << "]" << " reference=" << reference->GetPixelType().GetPixelTypeAsString() << "[" << reference->GetPixelType().GetBitsPerComponent() << "]" << " )";
     return false;
   }
 
   return true;
 }
 
 
+/*
+Test writing picture formats like *.bmp, *.png, *.tiff or *.jpg
+NOTE: Saving as picture format must ignore PixelType comparison - not all bits per components are supported (see specification of the format)
+*/
+void TestPictureWriting(mitk::Image* image, const std::string& filename, const std::string& extension)
+{
+   mitk::ImageWriter::Pointer myImageWriter = mitk::ImageWriter::New();
+   myImageWriter->SetFileName(AppendExtension(filename, extension.c_str()) );
+   myImageWriter->SetFilePrefix("pref");
+   myImageWriter->SetFilePattern("pattern");
+   myImageWriter->SetInput(image);
+
+
+   mitk::Image::Pointer singleSliceImage = NULL;
+  if( image->GetDimension() == 3 )
+  {
+    mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
+    extractFilter->SetInput( image );
+    extractFilter->SetWorldGeometry( image->GetSlicedGeometry()->GetGeometry2D(0) );
+
+    extractFilter->Update();
+    singleSliceImage = extractFilter->GetOutput();
+
+    // test 3D writing in format supporting only 2D
+    myImageWriter->Update();
+
+    // test images
+    unsigned int foundImagesCount = 0;
+
+    //if the image only contains one sinlge slice the itkImageSeriesWriter won't add a number like filename.XX.extension
+    if(image->GetDimension(2) == 1)
+    {
+      std::stringstream series_filenames;
+        series_filenames << filename << extension;
+        mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( series_filenames.str() );
+        if( compareImage.IsNotNull() )
+        {
+          foundImagesCount++;
+          MITK_TEST_CONDITION(CompareImageMetaData( singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. "); //ignore bits per component
+        }
+        remove( series_filenames.str().c_str() );
+    }
+    else //test the whole slice stack
+    {
+      for( unsigned int i=0; i< image->GetDimension(2); i++)
+      {
+        std::stringstream series_filenames;
+        series_filenames << filename << "." << i+1 << extension;
+        mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( series_filenames.str() );
+        if( compareImage.IsNotNull() )
+        {
+          foundImagesCount++;
+          MITK_TEST_CONDITION(CompareImageMetaData( singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. "); //ignore bits per component
+        }
+        remove( series_filenames.str().c_str() );
+      }
+    }
+    MITK_TEST_CONDITION( foundImagesCount == image->GetDimension(2), "All 2D-Slices of a 3D image were stored correctly.");
+  }
+  else if( image->GetDimension() == 2 )
+  {
+    singleSliceImage = image;
+  }
+
+  // test 2D writing
+  if( singleSliceImage.IsNotNull() )
+  {
+    try
+    {
+      myImageWriter->SetInput( singleSliceImage );
+      myImageWriter->Update();
+
+      mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( AppendExtension(filename, extension.c_str()).c_str());
+      MITK_TEST_CONDITION_REQUIRED( compareImage.IsNotNull(), "Image stored was succesfully loaded again");
+
+      MITK_TEST_CONDITION_REQUIRED( CompareImageMetaData(singleSliceImage, compareImage, false ), "Image meta data unchanged after writing and loading again. ");//ignore bits per component
+      remove(AppendExtension(filename, extension.c_str()).c_str());
+    }
+    catch(itk::ExceptionObject &e)
+    {
+      MITK_TEST_FAILED_MSG(<< "Exception during file writing for ." << extension << ": " << e.what() );
+    }
+
+  }
+
+}
+
 /**
 *  test for "ImageWriter".
 *
 *  argc and argv are the command line parameters which were passed to
 *  the ADD_TEST command in the CMakeLists.txt file. For the automatic
 *  tests, argv is either empty for the simple tests or contains the filename
 *  of a test image for the image tests (see CMakeLists.txt).
 */
 int mitkImageWriterTest(int  argc , char* argv[])
 {
   // always start with this!
   MITK_TEST_BEGIN("ImageWriter")
 
   // let's create an object of our class
   mitk::ImageWriter::Pointer myImageWriter = mitk::ImageWriter::New();
 
   // first test: did this work?
   // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since
   // it makes no sense to continue without an object.
   MITK_TEST_CONDITION_REQUIRED(myImageWriter.IsNotNull(),"Testing instantiation")
 
   // write your own tests here and use the macros from mitkTestingMacros.h !!!
   // do not write to std::cout and do not return from this function yourself!
 
   // load image
   MITK_TEST_CONDITION_REQUIRED(argc > 1, "File to load has been specified");
 
 
   mitk::Image::Pointer image = NULL;
 
   try
   {
     MITK_TEST_OUTPUT(<< "Loading file: " << argv[1]);
     image = mitk::IOUtil::LoadImage( argv[1] );
   }
   catch (itk::ExceptionObject & ex)
   {
     MITK_TEST_FAILED_MSG(<< "Exception during file loading: " << ex.GetDescription());
   }
 
 
   MITK_TEST_CONDITION_REQUIRED(image.IsNotNull(),"loaded image not NULL")
   std::stringstream filename_stream;
 
 #ifdef WIN32
   filename_stream << "test" << _getpid();
 #else
   filename_stream << "test" << getpid();
 #endif
 
 
   std::string filename = filename_stream.str();
   std::cout << filename << std::endl;
 
   // test set/get methods
   myImageWriter->SetInput(image);
   MITK_TEST_CONDITION_REQUIRED(myImageWriter->GetInput()==image,"test Set/GetInput()");
   myImageWriter->SetFileName(filename);
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFileName(),filename.c_str()),"test Set/GetFileName()");
   myImageWriter->SetFilePrefix("pref");
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFilePrefix(),"pref"),"test Set/GetFilePrefix()");
   myImageWriter->SetFilePattern("pattern");
   MITK_TEST_CONDITION_REQUIRED(!strcmp(myImageWriter->GetFilePattern(),"pattern"),"test Set/GetFilePattern()");
 
   // write ITK .mhd image (2D and 3D only)
   if( image->GetDimension() <= 3 )
   {
     try
     {
       myImageWriter->SetExtension(".mhd");
       myImageWriter->Update();
 
       mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( AppendExtension(filename, ".mhd").c_str() );
       MITK_TEST_CONDITION_REQUIRED( compareImage.IsNotNull(), "Image stored in MHD format was succesfully loaded again! ");
 
       std::string rawExtension = ".raw";
       std::fstream rawPartIn;
       rawPartIn.open(AppendExtension(filename, ".raw").c_str());
       if( !rawPartIn.is_open() )
       {
         rawExtension = ".zraw";
         rawPartIn.open(AppendExtension(filename, ".zraw").c_str());
       }
 
       MITK_TEST_CONDITION_REQUIRED(rawPartIn.is_open(),"Write .raw file");
       rawPartIn.close();
 
       // delete
       remove(AppendExtension(filename, ".mhd").c_str());
       remove(AppendExtension(filename, rawExtension.c_str()).c_str());
     }
     catch (...)
     {
       MITK_TEST_FAILED_MSG(<< "Exception during .mhd file writing");
     }
   }
 
   //testing more component image writing as nrrd files
   try
   {
     myImageWriter->SetExtension(".nrrd");
     myImageWriter->Update();
     std::fstream fin;
     mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage(AppendExtension(filename, ".nrrd").c_str());
     MITK_TEST_CONDITION_REQUIRED(compareImage.IsNotNull(), "Image stored in NRRD format was succesfully loaded again");
     fin.close();
     remove(AppendExtension(filename, ".nrrd").c_str());
   }
   catch(...)
   {
     MITK_TEST_FAILED_MSG(<< "Exception during .nrrd file writing");
   }
 
-
-  mitk::Image::Pointer singleSliceImage = NULL;
-  if( image->GetDimension() == 3 )
-  {
-    mitk::ExtractSliceFilter::Pointer extractFilter = mitk::ExtractSliceFilter::New();
-    extractFilter->SetInput( image );
-    extractFilter->SetWorldGeometry( image->GetSlicedGeometry()->GetGeometry2D(0) );
-
-    extractFilter->Update();
-    singleSliceImage = extractFilter->GetOutput();
-
-    // test 3D writing in format supporting only 2D
-    myImageWriter->SetExtension(".png");
-    myImageWriter->Update();
-
-    // test images
-    unsigned int foundImagesCount = 0;
-    for( unsigned int i=0; i< image->GetDimension(2); i++)
-    {
-      std::stringstream series_filenames;
-      series_filenames << filename << "." << i+1 << ".png";
-      mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( series_filenames.str() );
-      if( compareImage.IsNotNull() )
-      {
-        foundImagesCount++;
-        MITK_TEST_CONDITION(CompareImageMetaData( singleSliceImage, compareImage ), "Image meta data unchanged after writing and loading again. ");
-      }
-      remove( series_filenames.str().c_str() );
-    }
-    MITK_TEST_CONDITION( foundImagesCount == image->GetDimension(2), "All 2D-Slices of a 3D image were stored correctly as PNGs.");
-  }
-  else if( image->GetDimension() == 2 )
-  {
-    singleSliceImage = image;
-  }
-
-  // test 2D writing
-  if( singleSliceImage.IsNotNull() )
-  {
-    try
-    {
-      myImageWriter->SetInput( singleSliceImage );
-      myImageWriter->SetExtension(".png");
-      myImageWriter->Update();
-
-      mitk::Image::Pointer compareImage = mitk::IOUtil::LoadImage( AppendExtension(filename, ".png").c_str());
-      MITK_TEST_CONDITION_REQUIRED( compareImage.IsNotNull(), "Image stored in PNG format was succesfully loaded again");
-
-      MITK_TEST_CONDITION_REQUIRED( CompareImageMetaData(singleSliceImage, compareImage ), "Image meta data unchanged after writing and loading again. ");
-      remove(AppendExtension(filename, ".png").c_str());
-    }
-    catch(itk::ExceptionObject &e)
-    {
-      MITK_TEST_FAILED_MSG(<< "Exception during .png file writing: " << e.what() );
-    }
-
-  }
-
+  TestPictureWriting(image, filename, ".png");
+  TestPictureWriting(image, filename, ".jpg");
+  TestPictureWriting(image, filename, ".tiff");
+  TestPictureWriting(image, filename, ".bmp");
 
   // test for exception handling
   try
   {
     MITK_TEST_FOR_EXCEPTION_BEGIN(itk::ExceptionObject)
     myImageWriter->SetInput(image);
     myImageWriter->SetFileName("/usr/bin");
     myImageWriter->Update();
     MITK_TEST_FOR_EXCEPTION_END(itk::ExceptionObject)
   }
   catch(...) {
     //this means that a wrong exception (i.e. no itk:Exception) has been thrown
     MITK_TEST_FAILED_MSG(<< "Wrong exception (i.e. no itk:Exception) caught during write");
   }
 
   // always end with this!
   MITK_TEST_END();
 }