diff --git a/Core/Code/Common/mitkCoreObjectFactory.cpp b/Core/Code/Common/mitkCoreObjectFactory.cpp
index 3b4cbe8a99..a909c77dfa 100644
--- a/Core/Code/Common/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Common/mitkCoreObjectFactory.cpp
@@ -1,403 +1,405 @@
 /*===================================================================
 
 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 "mitkConfig.h"
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkAffineInteractor.h"
 #include "mitkColorProperty.h"
 #include "mitkDataNode.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkGeometry2DData.h"
 #include "mitkGeometry2DDataMapper2D.h"
 #include "mitkGeometry2DDataVtkMapper3D.h"
 #include "mitkGeometry3D.h"
 #include "mitkGeometryData.h"
 #include "mitkImage.h"
 #include <mitkImageVtkMapper2D.h>
 #include "mitkLevelWindowProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkPointSet.h"
 #include "mitkPointSetVtkMapper2D.h"
 #include "mitkPointSetVtkMapper3D.h"
 #include "mitkPolyDataGLMapper2D.h"
 #include "mitkProperties.h"
 #include "mitkPropertyList.h"
 #include "mitkSlicedGeometry3D.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkStringProperty.h"
 #include "mitkSurface.h"
 #include "mitkSurface.h"
 #include "mitkSurfaceGLMapper2D.h"
 #include "mitkSurfaceVtkMapper3D.h"
 #include "mitkTimeSlicedGeometry.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVolumeDataVtkMapper3D.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 
 //#include "mitkPicFileIOFactory.h"
 #include "mitkPointSetIOFactory.h"
 #include "mitkItkImageFileIOFactory.h"
 #include "mitkSTLFileIOFactory.h"
 #include "mitkVtkSurfaceIOFactory.h"
 #include "mitkVtkImageIOFactory.h"
 #include "mitkVtiFileIOFactory.h"
 //#include "mitkPicVolumeTimeSeriesIOFactory.h"
 
 #include "mitkImageWriterFactory.h"
+#include "mitkImageWriter.h"
 #include "mitkPointSetWriterFactory.h"
 #include "mitkSurfaceVtkWriterFactory.h"
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::m_FileWriters;
 
 void mitk::CoreObjectFactory::RegisterExtraFactory(CoreObjectFactoryBase* factory) {
   MITK_DEBUG << "CoreObjectFactory: registering extra factory of type " << factory->GetNameOfClass();
   m_ExtraFactories.insert(CoreObjectFactoryBase::Pointer(factory));
 }
 
 void mitk::CoreObjectFactory::UnRegisterExtraFactory(CoreObjectFactoryBase *factory)
 {
   MITK_DEBUG << "CoreObjectFactory: un-registering extra factory of type " << factory->GetNameOfClass();
   try
   {
     m_ExtraFactories.erase(factory);
   }
   catch( std::exception const& e)
   {
     MITK_ERROR << "Caugt exception while unregistering: " << e.what();
   }
 }
 
 mitk::CoreObjectFactory::Pointer mitk::CoreObjectFactory::GetInstance() {
   static mitk::CoreObjectFactory::Pointer instance;
   if (instance.IsNull())
   {
      instance = mitk::CoreObjectFactory::New();
   }
   return instance;
 }
 
 #include <mitkDataNodeFactory.h>
 
 void mitk::CoreObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
   if(node==NULL)
     return;
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
   if(image.IsNotNull() && image->IsInitialized())
   {
     mitk::ImageVtkMapper2D::SetDefaultProperties(node);
     mitk::VolumeDataVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
   if(surface.IsNotNull())
   {
     mitk::SurfaceGLMapper2D::SetDefaultProperties(node);
     mitk::SurfaceVtkMapper3D::SetDefaultProperties(node);
   }
 
   mitk::PointSet::Pointer pointSet = dynamic_cast<mitk::PointSet*>(node->GetData());
   if(pointSet.IsNotNull())
   {
     mitk::PointSetVtkMapper2D::SetDefaultProperties(node);
     mitk::PointSetVtkMapper3D::SetDefaultProperties(node);
   }
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     (*it)->SetDefaultProperties(node);
   }
 }
 
 mitk::CoreObjectFactory::CoreObjectFactory()
 {
   static bool alreadyDone = false;
   if (!alreadyDone)
   {
     MITK_DEBUG << "CoreObjectFactory c'tor" << std::endl;
 
     // FIXME itk::ObjectFactoryBase::RegisterFactory( PicFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( PointSetIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( STLFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtkSurfaceIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtkImageIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( VtiFileIOFactory::New() );
     itk::ObjectFactoryBase::RegisterFactory( ItkImageFileIOFactory::New() );
     // FIXME itk::ObjectFactoryBase::RegisterFactory( PicVolumeTimeSeriesIOFactory::New() );
 
     mitk::SurfaceVtkWriterFactory::RegisterOneFactory();
     mitk::PointSetWriterFactory::RegisterOneFactory();
     mitk::ImageWriterFactory::RegisterOneFactory();
+    m_FileWriters.push_back(mitk::ImageWriter::New().GetPointer());
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::Mapper::Pointer mitk::CoreObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper = NULL;
   mitk::Mapper::Pointer tmpMapper = NULL;
 
   // check whether extra factories provide mapper
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     tmpMapper = (*it)->CreateMapper(node,id);
     if(tmpMapper.IsNotNull())
       newMapper = tmpMapper;
   }
 
   if (newMapper.IsNull())
   {
 
     mitk::BaseData *data = node->GetData();
 
     if ( id == mitk::BaseRenderer::Standard2D )
     {
       if((dynamic_cast<Image*>(data)!=NULL))
       {
         newMapper = mitk::ImageVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
       {
         newMapper = mitk::Geometry2DDataMapper2D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Surface*>(data)!=NULL))
       {
         newMapper = mitk::SurfaceGLMapper2D::New();
         // cast because SetDataNode is not virtual
         mitk::SurfaceGLMapper2D *castedMapper = dynamic_cast<mitk::SurfaceGLMapper2D*>(newMapper.GetPointer());
         castedMapper->SetDataNode(node);
       }
       else if((dynamic_cast<PointSet*>(data)!=NULL))
       {
         newMapper = mitk::PointSetVtkMapper2D::New();
         newMapper->SetDataNode(node);
       }
     }
     else if ( id == mitk::BaseRenderer::Standard3D )
     {
       if((dynamic_cast<Image*>(data) != NULL))
       {
         newMapper = mitk::VolumeDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Geometry2DData*>(data)!=NULL))
       {
         newMapper = mitk::Geometry2DDataVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<Surface*>(data)!=NULL))
       {
         newMapper = mitk::SurfaceVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
       else if((dynamic_cast<PointSet*>(data)!=NULL))
       {
         newMapper = mitk::PointSetVtkMapper3D::New();
         newMapper->SetDataNode(node);
       }
     }
   }
 
   return newMapper;
 }
 
 /*
 // @deprecated
 //
 #define EXTERNAL_FILE_EXTENSIONS \
     "All known formats(*.dcm *.DCM *.dc3 *.DC3 *.gdcm *.ima *.mhd *.mps *.nii *.pic *.pic.gz *.bmp *.png *.jpg *.tiff *.pvtk *.stl *.vtk *.vtp *.vtu *.obj *.vti *.hdr *.nrrd *.nhdr );;" \
     "DICOM files(*.dcm *.DCM *.dc3 *.DC3 *.gdcm);;" \
     "DKFZ Pic (*.seq *.pic *.pic.gz *.seq.gz);;" \
     "NRRD Vector Images (*.nrrd *.nhdr);;" \
     "Point sets (*.mps);;" \
     "Sets of 2D slices (*.pic *.pic.gz *.bmp *.png *.dcm *.gdcm *.ima *.tiff);;" \
     "Surface files (*.stl *.vtk *.vtp *.obj);;" \
     "NIfTI format (*.nii)"
 
 #define SAVE_FILE_EXTENSIONS "all (*.pic *.mhd *.vtk *.vti *.hdr *.png *.tiff *.jpg *.hdr *.bmp *.dcm *.gipl *.nii *.nrrd *.nhdr *.spr *.lsm *.dwi *.hdwi *.qbi *.hqbi)"
 */
 
 /**
  * @brief This method gets the supported (open) file extensions as string. This string is can then used by the QT QFileDialog widget.
  * @return The c-string that contains the file extensions
  *
  */
 const char* mitk::CoreObjectFactory::GetFileExtensions()
 {
   MultimapType aMap;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
   {
     aMap = (*it)->GetFileExtensionsMap();
     this->MergeFileExtensions(m_FileExtensionsMap, aMap);
   }
   this->CreateFileExtensions(m_FileExtensionsMap, m_FileExtensions);
   return m_FileExtensions.c_str();
 }
 
 /**
  * @brief Merge the input map into the fileExtensionsMap. Duplicate entries are removed
  * @param fileExtensionsMap the existing map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files").
  *                          This map is extented/merged with the values from the input map.
  * @param inputMap the input map, it contains value pairs like ("*.dcm", "DICOM files"),("*.dc3", "DICOM files") returned by
  *                 the extra factories.
  *
  */
 void mitk::CoreObjectFactory::MergeFileExtensions(MultimapType& fileExtensionsMap, MultimapType inputMap)
 {
   bool duplicateFound = false;
   std::pair<MultimapType::iterator, MultimapType::iterator> pairOfIter;
   for (MultimapType::iterator it = inputMap.begin(); it != inputMap.end(); ++it)
   {
     duplicateFound = false;
     pairOfIter = fileExtensionsMap.equal_range((*it).first);
     for (MultimapType::iterator it2 = pairOfIter.first; it2 != pairOfIter.second; ++it2)
     {
       //cout << "  [" << (*it).first << ", " << (*it).second << "]" << endl;
       std::string aString = (*it2).second;
       if (aString.compare((*it).second) == 0)
       {
         //cout << "  DUP!! [" << (*it).first << ", " << (*it).second << "]" << endl;
         duplicateFound = true;
         break;
       }
     }
     if (!duplicateFound)
     {
       fileExtensionsMap.insert(std::pair<std::string, std::string>((*it).first, (*it).second));
     }
   }
 }
 
 /**
  * @brief get the defined (open) file extension map
  * @return the defined (open) file extension map
  */
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 /**
  * @brief initialize the file extension entries for open and save
  */
 void mitk::CoreObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DCM", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dc3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.DC3", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "DICOM files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.seq.gz", "DKFZ Pic"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img.gz", "Analyze Format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.mps", "Point sets"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic.gz", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.gdcm", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.ima", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.stl", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtp", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.obj", "Surface files"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii.gz", "NIfTI format"));
 
   //m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pic", "DKFZ Pic"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.mhd", "MetaImage"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vtk", "Surface Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.vti", "VTK Image Data Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze Format"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.png", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tiff", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.tif", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpg", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.jpeg", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.bmp", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dcm", "Sets of 2D slices"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.gipl", "UMDS GIPL Format Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nrrd", "Nearly Raw Raster Data"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nhdr", "NRRD with detached header"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.lsm", "Microscope Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.dwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdwi", "Diffusion Weighted Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.qbi", "Q-Ball Images"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hqbi", "Q-Ball Images"));
 
 }
 
 /**
  * @brief This method gets the supported (save) file extensions as string. This string is can then used by the QT QFileDialog widget.
  * @return The c-string that contains the (save) file extensions
  *
  */
 const char* mitk::CoreObjectFactory::GetSaveFileExtensions() {
   MultimapType aMap;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ )
   {
     aMap = (*it)->GetSaveFileExtensionsMap();
     this->MergeFileExtensions(m_SaveFileExtensionsMap, aMap);
 
   }
   this->CreateFileExtensions(m_SaveFileExtensionsMap, m_SaveFileExtensions);
   return m_SaveFileExtensions.c_str();
 };
 
 /**
  * @brief get the defined (save) file extension map
  * @return the defined (save) file extension map
  */
 mitk::CoreObjectFactoryBase::MultimapType mitk::CoreObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 mitk::CoreObjectFactory::FileWriterList mitk::CoreObjectFactory::GetFileWriters() {
   FileWriterList allWriters = m_FileWriters;
   for (ExtraFactoriesContainer::iterator it = m_ExtraFactories.begin(); it != m_ExtraFactories.end() ; it++ ) {
     FileWriterList list2 = (*it)->GetFileWriters();
     allWriters.merge(list2);
   }
   return allWriters;
 }
 void mitk::CoreObjectFactory::MapEvent(const mitk::Event*, const int) {
 
 }
 
diff --git a/Core/Code/IO/mitkIOUtil.cpp b/Core/Code/IO/mitkIOUtil.cpp
index d671110b0a..d14ad43a05 100644
--- a/Core/Code/IO/mitkIOUtil.cpp
+++ b/Core/Code/IO/mitkIOUtil.cpp
@@ -1,317 +1,373 @@
 /*===================================================================
 
 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 "mitkIOUtil.h"
 #include "mitkDataNodeFactory.h"
 #include "mitkImageWriter.h"
 #include "mitkPointSetWriter.h"
 #include "mitkSurfaceVtkWriter.h"
 
 #include <mitkGetModuleContext.h>
 #include <mitkModuleContext.h>
 #include <mitkStandaloneDataStorage.h>
 #include <mitkIDataNodeReader.h>
 #include <mitkProgressBar.h>
 
+#include <mitkCoreObjectFactory.h>
+
 //ITK
 #include <itksys/SystemTools.hxx>
 
 //VTK
 #include <vtkPolyData.h>
 #include <vtkTriangleFilter.h>
 #include <vtkSmartPointer.h>
 
 
 namespace mitk {
 
 const std::string IOUtil::DEFAULTIMAGEEXTENSION = ".nrrd";
 const std::string IOUtil::DEFAULTSURFACEEXTENSION = ".stl";
 const std::string IOUtil::DEFAULTPOINTSETEXTENSION = ".mps";
 
 int IOUtil::LoadFiles(const std::vector<std::string> &fileNames, DataStorage &ds)
 {
     // Get the set of registered mitk::IDataNodeReader services
     ModuleContext* context = mitk::GetModuleContext();
     const std::list<ServiceReference> refs = context->GetServiceReferences<IDataNodeReader>();
     std::vector<IDataNodeReader*> services;
     services.reserve(refs.size());
     for (std::list<ServiceReference>::const_iterator i = refs.begin();
          i != refs.end(); ++i)
     {
         IDataNodeReader* s = context->GetService<IDataNodeReader>(*i);
         if (s != 0)
         {
             services.push_back(s);
         }
     }
 
     mitk::ProgressBar::GetInstance()->AddStepsToDo(2*fileNames.size());
 
     // Iterate over all file names and use the IDataNodeReader services
     // to load them.
     int nodesRead = 0;
     for (std::vector<std::string>::const_iterator i = fileNames.begin();
          i != fileNames.end(); ++i)
     {
         for (std::vector<IDataNodeReader*>::const_iterator readerIt = services.begin();
              readerIt != services.end(); ++readerIt)
         {
             try
             {
                 int n = (*readerIt)->Read(*i, ds);
                 nodesRead += n;
                 if (n > 0) break;
             }
             catch (const std::exception& e)
             {
                 MITK_WARN << e.what();
             }
         }
         mitk::ProgressBar::GetInstance()->Progress(2);
     }
 
     for (std::list<ServiceReference>::const_iterator i = refs.begin();
          i != refs.end(); ++i)
     {
         context->UngetService(*i);
     }
 
     return nodesRead;
 }
 
 DataStorage::Pointer IOUtil::LoadFiles(const std::vector<std::string>& fileNames)
 {
     mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
     LoadFiles(fileNames, *ds);
     return ds.GetPointer();
 }
 
 DataNode::Pointer IOUtil::LoadDataNode(const std::string path)
 {
     mitk::DataNodeFactory::Pointer reader = mitk::DataNodeFactory::New();
     try
     {
         reader->SetFileName( path );
         reader->Update();
 
         if((reader->GetNumberOfOutputs()<1))
         {
             MITK_ERROR << "Could not find data '" << path << "'";
             mitkThrow() << "An exception occured during loading the file " << path << ". Exception says could not find data.";
         }
 
         mitk::DataNode::Pointer node = reader->GetOutput();
 
         if(node.IsNull())
         {
             MITK_ERROR << "Could not find path: '" << path << "'" << " datanode is NULL" ;
             mitkThrow() << "An exception occured during loading the file " << path << ". Exception says datanode is NULL.";
         }
 
         return reader->GetOutput( 0 );
      }
     catch ( itk::ExceptionObject & e )
     {
         MITK_ERROR << "Exception occured during load data of '" << path << "': Exception: " << e.what();
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: " << e.what();
     }
 }
 
 Image::Pointer IOUtil::LoadImage(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
     if(image.IsNull())
     {
         MITK_ERROR << "Image is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the image " << path << ". Exception says: Image is NULL.";
     }
     return image;
 }
 
 Surface::Pointer IOUtil::LoadSurface(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(node->GetData());
     if(surface.IsNull())
     {
         MITK_ERROR << "Surface is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Surface is NULL.";
     }
     return surface;
 }
 
 PointSet::Pointer IOUtil::LoadPointSet(const std::string path)
 {
     mitk::DataNode::Pointer node = LoadDataNode(path);
     mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(node->GetData());
     if(pointset.IsNull())
     {
         MITK_ERROR << "PointSet is NULL '" << path << "'";
         mitkThrow() << "An exception occured during loading the file " << path << ". Exception says: Pointset is NULL.";
     }
     return pointset;
 }
 
 bool IOUtil::SaveImage(mitk::Image::Pointer image, const std::string path)
 {
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
-    std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
-    std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
+    std::string baseFilename = itksys::SystemTools::GetFilenameWithoutExtension( path );
+    std::string extension = itksys::SystemTools::GetFilenameExtension( path );
     std::string finalFileName = dir + "/" + baseFilename;
 
     mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
     //check if an extension is given, else use the defaul extension
     if( extension == "" )
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTIMAGEEXTENSION;
         extension = DEFAULTIMAGEEXTENSION;
     }
 
     // check if extension is suitable for writing image data
     if (!imageWriter->IsExtensionValid(extension))
     {
         MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
                   << DEFAULTIMAGEEXTENSION;
         extension = DEFAULTIMAGEEXTENSION;
     }
 
     try
     {
         //write the data
         imageWriter->SetInput(image);
         imageWriter->SetFileName(finalFileName.c_str());
         imageWriter->SetExtension(extension.c_str());
         imageWriter->Write();
     }
     catch ( std::exception& e )
     {
         MITK_ERROR << " during attempt to write '" << finalFileName + extension << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
 
 bool IOUtil::SaveSurface(Surface::Pointer surface, const std::string path)
 {
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
     std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
     std::string finalFileName = dir + "/" + baseFilename;
 
     if (extension == "") // if no extension has been set we use the default extension
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTSURFACEEXTENSION;
         extension = DEFAULTSURFACEEXTENSION;
     }
     try
     {
         finalFileName += extension;
         if(extension == ".stl" )
         {
             mitk::SurfaceVtkWriter<vtkSTLWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkSTLWriter>::New();
 
             // check if surface actually consists of triangles; if not, the writer will not do anything; so, convert to triangles...
             vtkPolyData* polys = surface->GetVtkPolyData();
             if( polys->GetNumberOfStrips() > 0 )
             {
                 vtkSmartPointer<vtkTriangleFilter> triangleFilter = vtkSmartPointer<vtkTriangleFilter>::New();
                 triangleFilter->SetInput(polys);
                 triangleFilter->Update();
                 polys = triangleFilter->GetOutput();
                 polys->Register(NULL);
                 surface->SetVtkPolyData(polys);
             }
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->GetVtkWriter()->SetFileTypeToBinary();
             surfaceWriter->Write();
         }
         else if(extension == ".vtp")
         {
             mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::New();
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->GetVtkWriter()->SetDataModeToBinary();
             surfaceWriter->Write();
         }
         else if(extension == ".vtk")
         {
             mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer surfaceWriter = mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
             surfaceWriter->SetInput( surface );
             surfaceWriter->SetFileName( finalFileName.c_str() );
             surfaceWriter->Write();
         }
         else
         {
             // file extension not suitable for writing specified data type
             MITK_ERROR << "File extension is not suitable for writing'" << finalFileName;
             mitkThrow() << "An exception occured during writing the file " << finalFileName <<
                            ". File extension " << extension << " is not suitable for writing.";
         }
     }
     catch(std::exception& e)
     {
         MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
 
 bool IOUtil::SavePointSet(PointSet::Pointer pointset, const std::string path)
 {
     mitk::PointSetWriter::Pointer pointSetWriter = mitk::PointSetWriter::New();
 
     std::string dir = itksys::SystemTools::GetFilenamePath( path );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( path );
     std::string extension = itksys::SystemTools::GetFilenameLastExtension( path );
     std::string finalFileName = dir + "/" + baseFilename;
 
     if (extension == "") // if no extension has been entered manually into the filename
     {
         MITK_WARN << extension << " extension is not set. Extension set to default: " << finalFileName
                   << DEFAULTPOINTSETEXTENSION;
         extension = DEFAULTPOINTSETEXTENSION;
     }
 
     // check if extension is valid
     if (!pointSetWriter->IsExtensionValid(extension))
     {
         MITK_WARN << extension << " extension is unknown. Extension set to default: " << finalFileName
                   << DEFAULTPOINTSETEXTENSION;
         extension = DEFAULTPOINTSETEXTENSION;
     }
     try
     {
         pointSetWriter->SetInput( pointset );
         finalFileName += extension;
         pointSetWriter->SetFileName( finalFileName.c_str() );
         pointSetWriter->Update();
     }
     catch( std::exception& e )
     {
         MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
         MITK_ERROR << e.what();
         mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
     }
     return true;
 }
+
+bool IOUtil::SaveBaseData( mitk::BaseData* data, const std::string& path )
+{
+  if (data == NULL || path.empty()) return false;
+
+  std::string dir = itksys::SystemTools::GetFilenamePath( path );
+  std::string baseFilename = itksys::SystemTools::GetFilenameWithoutExtension( path );
+  std::string extension = itksys::SystemTools::GetFilenameExtension( path );
+  std::string fileNameWithoutExtension = dir + "/" + baseFilename;
+
+  mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
+
+  for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it)
+  {
+    if ( (*it)->CanWriteBaseDataType(data) )
+    {
+      // Ensure a valid filename
+      if(baseFilename=="")
+      {
+        baseFilename = (*it)->GetDefaultFilename();
+      }
+      // Check if an extension exists already and if not, append the default extension
+      if (extension=="" )
+      {
+        extension=(*it)->GetDefaultExtension();
+      }
+      else
+      {
+        if (!(*it)->IsExtensionValid(extension))
+        {
+          MITK_WARN << extension << " extension is unknown";
+          continue;
+        }
+      }
+
+      std::string finalFileName = fileNameWithoutExtension + extension;
+      try
+      {
+        (*it)->SetFileName( finalFileName.c_str() );
+        (*it)->DoWrite( data );
+        return true;
+      }
+      catch( const std::exception& e )
+      {
+        MITK_ERROR << " during attempt to write '" << finalFileName << "' Exception says:";
+        MITK_ERROR << e.what();
+        mitkThrow() << "An exception occured during writing the file " << finalFileName << ". Exception says " << e.what();
+      }
+    }
+  }
+
+  return false;
+}
+
 }
diff --git a/Core/Code/IO/mitkIOUtil.h b/Core/Code/IO/mitkIOUtil.h
index af9d8c8593..d59a58176d 100644
--- a/Core/Code/IO/mitkIOUtil.h
+++ b/Core/Code/IO/mitkIOUtil.h
@@ -1,144 +1,154 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef MITKIOUTIL_H
 #define MITKIOUTIL_H
 
 #include <MitkExports.h>
 #include <mitkDataStorage.h>
 #include <mitkSurface.h>
 #include <mitkPointSet.h>
 #include <mitkImage.h>
 
 namespace mitk {
 
 /**
  * \ingroup IO
  *
  * \brief A utility class to load and save data from/to the local file system.
  *
  * This method LoadFiles queries the MITK Micro Services registry for registered mitk::IDataNodeReader service
  * instances. The service instance with the highest ranking will be asked first to load the
  * given file. On error (exception thrown) or if no mitk::DataNode was constructed, the next
  * service instance is used.
  *
  * The methods LoadImage, LoadSurface, and LoadPointSet are convenience methods for general loading of
  * the three main data types in MITK. They all use the more generic method LoadDataNode.
  *
  * The methods SaveImage, SaveSurface, and SurfacePointSet are also meant for convenience (e.g. during testing).
  * Currently, there is no generic way to save a generic DataNode with an appropriate format. Thus, every method
  * initializes the corresponding instance of the special writer for the data type.
  *
  * \see mitk::IDataNodeReader
  */
 class MITK_CORE_EXPORT IOUtil
 {
 
 public:
 
   /**
    * Load a files in <code>fileNames</code> and add the constructed mitk::DataNode instances
    * to the mitk::DataStorage <code>storage</code>
    *
    * \param fileNames A list (vector) of absolute file name paths.
    * \param storage The data storage to which the constructed data nodes are added.
    * \return The number of added mitk::DataNode instances.
    */
   static int LoadFiles(const std::vector<std::string>&fileNames, DataStorage& storage);
 
   /**
    * This method will create a new mitk::DataStorage instance and pass it to
    * LoadFiles(std::vector<std::string>,DataStorage).
    *
    * \param fileNames A list (vector) of absolute file name paths.
    * \return The new mitk::DataStorage containing the constructed data nodes.
    *
    * \see LoadFiles(std::vector<std::string>,DataStorage)
    */
   static DataStorage::Pointer LoadFiles(const std::vector<std::string>& fileNames);
 
   /**
    * @brief LoadDataNode Method to load an arbitrary DataNode.
    * @param path The path to the file including file name and file extension.
    * @throws mitk::Exception This exception is thrown when the DataNodeFactory is not able to read/find the file
    * or the DataNode is NULL.
    * @return Returns the DataNode.
    */
   static mitk::DataNode::Pointer LoadDataNode(const std::string path);
 
   /**
    * @brief LoadImage Convenience method to load an arbitrary mitkImage.
    * @param path The path to the image including file name and file extension.
    * @throws mitk::Exception This exception is thrown when the Image is NULL.
    * @return Returns the mitkImage.
    */
   static mitk::Image::Pointer LoadImage(const std::string path);
 
   /**
    * @brief LoadSurface Convenience method to load an arbitrary mitkSurface.
    * @param path The path to the surface including file name and file extension.
    * @throws mitk::Exception This exception is thrown when the Surface is NULL.
    * @return Returns the mitkSurface.
    */
   static mitk::Surface::Pointer LoadSurface(const std::string path);
 
   /**
    * @brief LoadPointSet Convenience method to load an arbitrary mitkPointSet.
    * @param path The path to the pointset including file name and file extension (currently, only .mps is supported).
    * @throws mitk::Exception This exception is thrown when the PointSet is NULL.
    * @return Returns the mitkPointSet.
    */
   static mitk::PointSet::Pointer LoadPointSet(const std::string path);
 
   /**
    * @brief SaveImage Convenience method to save an arbitrary mitkImage.
    * @param path The path to the image including file name and file extension.
    * If not extention is set, the default value (defined in DEFAULTIMAGEEXTENSION) is used.
    * @param image The image to save.
    * @throws mitk::Exception This exception is thrown when the writer is not able to write the image.
    * @return Returns true for success else false.
    */
   static bool SaveImage(mitk::Image::Pointer image, const std::string path);
 
+  /**
+   * @brief SaveBaseData Convenience method to save arbitrary baseData.
+   * @param path The path to the image including file name and file extension.
+   * If not extention is set, the default value (defined in DEFAULTIMAGEEXTENSION) is used.
+   * @param data The data to save.
+   * @throws mitk::Exception This exception is thrown when the writer is not able to write the image.
+   * @return Returns true for success else false.
+   */
+  static bool SaveBaseData(mitk::BaseData* data, const std::string& path);
+
   /**
    * @brief SaveSurface Convenience method to save an arbitrary mitkSurface.
    * @param path The path to the surface including file name and file extension.
    * If not extention is set, the default value (defined in DEFAULTSURFACEEXTENSION) is used.
    * @throws mitk::Exception This exception is thrown when the writer is not able to write the surface.
    * or if the fileextension is not suitable for writing.
    * @return Returns true for success else false.
    */
   static bool SaveSurface(mitk::Surface::Pointer surface, const std::string path);
 
   /**
    * @brief SavePointSet Convenience method to save an mitkPointSet.
    * @param path The path to the pointset including file name and file extension (currently, only .mps is supported).
    * If not extention is set, the default value (defined in DEFAULTPOINTSETEXTENSION) is used.
    * @throws mitk::Exception This exception is thrown when the writer is not able to write the pointset.
    * @return Returns true for success else false.
    */
   static bool SavePointSet(mitk::PointSet::Pointer pointset, const std::string path);
 
   static const std::string DEFAULTIMAGEEXTENSION;
   static const std::string DEFAULTSURFACEEXTENSION;
   static const std::string DEFAULTPOINTSETEXTENSION;
 
 };
 
 }
 
 #endif // MITKIOUTIL_H
diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index b915f30859..5afaebd0bf 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,377 +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()
 {
-  m_Extension = ".mhd";
+  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)
   {
     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_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
+          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_FileName.c_str() << "_T" << t << m_Extension;
+          filename <<  m_FileNameWithoutExtension << "_T" << t << m_Extension;
         }
         if ( vti )
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(image, filename.str());
         }
       }
     }
     else if ( vti )
     {
-      std::ostringstream filename;
-      filename <<  m_FileName.c_str() << m_Extension;
-      writeVti(filename.str().c_str(), input);
+      writeVti(m_FileName.c_str(), input);
     }
     else
     {
-      std::ostringstream filename;
-      filename <<  m_FileName.c_str() << m_Extension;
-      WriteByITK(input, filename.str());
+      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
         )
     {
-        std::ostringstream filename;
-        filename <<  this->m_FileName.c_str() << this->m_Extension;
-        WriteByITK(input, filename.str());
+        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 )
   {
-    mitk::BaseData* data = input->GetData();
-    if ( data )
-    {
-       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( data );
-       if( image.IsNotNull() )
-       {
-         //"SetDefaultExtension()" set m_Extension to ".mhd" ?????
-         m_Extension = ".pic";
-         return true;
-       }
-    }
+    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 (*.pic, *.pic.gz, *.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/IO/mitkImageWriter.h b/Core/Code/IO/mitkImageWriter.h
index 1b5c5a82f8..b8bd51241f 100644
--- a/Core/Code/IO/mitkImageWriter.h
+++ b/Core/Code/IO/mitkImageWriter.h
@@ -1,159 +1,170 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #ifndef _MITK_IMAGE_WRITER__H_
 #define _MITK_IMAGE_WRITER__H_
 
-#include <mitkFileWriter.h>
+#include <mitkFileWriterWithInformation.h>
 
 
 namespace mitk
 {
 class Image;
 /**
  * @brief Writer for mitk::Image
  *
  * Uses the given extension (SetExtension) to decide the format to write
  * (.mhd is default, .pic, .tif, .png, .jpg supported yet).
  * @ingroup IO
  */
-class MITK_CORE_EXPORT ImageWriter :  public mitk::FileWriter
+class MITK_CORE_EXPORT ImageWriter :  public mitk::FileWriterWithInformation
 {
 public:
 
     mitkClassMacro( ImageWriter, mitk::FileWriter );
 
     itkNewMacro( Self );
 
     mitkWriterMacro;
 
     /**
      * Sets the filename of the file to write.
      * @param _arg the name of the file to write.
      */
-    itkSetStringMacro( FileName );
+    virtual void SetFileName (const char* fileName);
+    virtual void SetFileName (const std::string& fileName);
 
     /**
      * @returns the name of the file to be written to disk.
      */
     itkGetStringMacro( FileName );
 
     /**
      * \brief Explicitly set the extension to be added to the filename.
      * @param _arg to be added to the filename, including a "."
      * (e.g., ".mhd").
      */
-    itkSetStringMacro( Extension );
+    virtual void SetExtension (const char* extension);
+    virtual void SetExtension (const std::string& extension);
 
     /**
      * \brief Get the extension to be added to the filename.
      * @returns the extension to be added to the filename (e.g.,
      * ".mhd").
      */
     itkGetStringMacro( Extension );
 
     /**
      * \brief Set the extension to be added to the filename to the default
      */
     void SetDefaultExtension();
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePrefix );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkSetStringMacro( FilePattern );
 
     /**
      * @warning multiple write not (yet) supported
      */
     itkGetStringMacro( FilePattern );
 
     /**
      * Sets the 0'th input object for the filter.
      * @param input the first input for the filter.
      */
     void SetInput( mitk::Image* input );
 
     //##Documentation
     //## @brief Return the possible file extensions for the data type associated with the writer
     virtual std::vector<std::string> GetPossibleFileExtensions();
 
     /**
     * @brief Return the extension to be added to the filename.
     */
     virtual std::string GetFileExtension();
 
     /**
     * @brief Check if the Writer can write the Content of the
     */
     virtual bool CanWriteDataType( DataNode* );
 
     /**
     * @brief Return the MimeType of the saved File.
     */
     virtual std::string GetWritenMIMEType();
 
     using Superclass::SetInput;
     /**
     * @brief Set the DataTreenode as Input. Important: The Writer always have a SetInput-Function.
     */
     virtual void SetInput( DataNode* );
 
     /**
      * @returns the 0'th input object of the filter.
      */
     const mitk::Image* GetInput();
 
+    // FileWriterWithInformation methods
+    virtual const char* GetDefaultFilename();
+    virtual const char *GetFileDialogPattern();
+    virtual const char *GetDefaultExtension();
+    virtual bool CanWriteBaseDataType(BaseData::Pointer data);
+    virtual void DoWrite(BaseData::Pointer data);
+
 protected:
 
     /**
      * Constructor.
      */
     ImageWriter();
 
     /**
      * Virtual destructor.
      */
     virtual ~ImageWriter();
 
     virtual void GenerateData();
 
     virtual void WriteByITK(mitk::Image* image, const std::string& fileName);
 
     std::string m_FileName;
 
+    std::string m_FileNameWithoutExtension;
+
     std::string m_FilePrefix;
 
     std::string m_FilePattern;
 
     std::string m_Extension;
 
     std::string m_MimeType;
 };
 
 }
 
 #endif //_MITK_IMAGE_WRITER__H_
diff --git a/Core/Code/Testing/mitkIOUtilTest.cpp b/Core/Code/Testing/mitkIOUtilTest.cpp
index c232c77387..1694c4b31d 100644
--- a/Core/Code/Testing/mitkIOUtilTest.cpp
+++ b/Core/Code/Testing/mitkIOUtilTest.cpp
@@ -1,71 +1,69 @@
 /*===================================================================
 
 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 "mitkTestingMacros.h"
 #include <mitkTestingConfig.h>
 #include <mitkIOUtil.h>
 
 int mitkIOUtilTest(int  argc , char* argv[])
 {
     // always start with this!
     MITK_TEST_BEGIN("mitkIOUtilTest")
             MITK_TEST_CONDITION_REQUIRED( argc >= 4, "Testing if input parameters are set.");
 
     std::string pathToImage = argv[1];
     std::string pathToPointSet = argv[2];
     std::string pathToSurface = argv[3];
 
     mitk::Image::Pointer img1 = mitk::IOUtil::LoadImage(pathToImage);
     MITK_TEST_CONDITION( img1.IsNotNull(), "Testing if image 1 could be loaded");
     mitk::PointSet::Pointer pointset = mitk::IOUtil::LoadPointSet(pathToPointSet);
     MITK_TEST_CONDITION( pointset.IsNotNull(), "Testing if pointset could be loaded");
     mitk::Surface::Pointer surface = mitk::IOUtil::LoadSurface(pathToSurface);
     MITK_TEST_CONDITION( surface.IsNotNull(), "Testing if surface could be loaded");
 
     std::string outDir = MITK_TEST_OUTPUT_DIR;
     std::string imagePath = outDir+"/diffpic3d.nrrd";
+    std::string imagePath2 = outDir+"/diffpic3d.nii.gz";
     std::string pointSetPath = outDir + "/diffpointset.mps";
     std::string surfacePath = outDir + "/diffsurface.stl";
     std::string pointSetPathWithDefaultExtension = outDir + "/diffpointset2.mps";
     std::string pointSetPathWithoutDefaultExtension = outDir + "/diffpointset2.xXx";
 
-    // the cases where no exception is thrown
-    try{
-        MITK_TEST_CONDITION(mitk::IOUtil::SaveImage(img1, imagePath.c_str()), "Testing if the image could be saved");
-        MITK_TEST_CONDITION(mitk::IOUtil::SavePointSet(pointset, pointSetPath.c_str()), "Testing if the pointset could be saved");
-        MITK_TEST_CONDITION(mitk::IOUtil::SaveSurface(surface, surfacePath.c_str()), "Testing if the surface could be saved");
-
-        // test if defaultextension is inserted if no extension is present
-        MITK_TEST_CONDITION(mitk::IOUtil::SavePointSet(pointset, pointSetPathWithoutDefaultExtension.c_str()), "Testing if the pointset could be saved");
-    }catch ( mitk::Exception e){
-            MITK_INFO << "Exception is thrown during writeing";
-    }
+    // the cases where no exception should be thrown
+    MITK_TEST_CONDITION(mitk::IOUtil::SaveImage(img1, imagePath), "Testing if the image could be saved");
+    MITK_TEST_CONDITION(mitk::IOUtil::SaveBaseData(img1.GetPointer(), imagePath2), "Testing if the image could be saved");
+    MITK_TEST_CONDITION(mitk::IOUtil::SavePointSet(pointset, pointSetPath), "Testing if the pointset could be saved");
+    MITK_TEST_CONDITION(mitk::IOUtil::SaveSurface(surface, surfacePath), "Testing if the surface could be saved");
+
+    // test if defaultextension is inserted if no extension is present
+    MITK_TEST_CONDITION(mitk::IOUtil::SavePointSet(pointset, pointSetPathWithoutDefaultExtension.c_str()), "Testing if the pointset could be saved");
 
     // test if exception is thrown as expected on unknown extsension
     MITK_TEST_FOR_EXCEPTION(mitk::Exception, mitk::IOUtil::SaveSurface(surface,"testSurface.xXx"));
     //load data which does not exist
     MITK_TEST_FOR_EXCEPTION(mitk::Exception, mitk::IOUtil::LoadImage("fileWhichDoesNotExist.nrrd"));
 
     //delete the files after the test is done
     remove(imagePath.c_str());
     remove(pointSetPath.c_str());
     remove(surfacePath.c_str());
     //remove the pointset with default extension and not the one without
     remove(pointSetPathWithDefaultExtension.c_str());
 
     MITK_TEST_END();
 
 }