diff --git a/Core/Code/Algorithms/mitkCoreObjectFactory.cpp b/Core/Code/Algorithms/mitkCoreObjectFactory.cpp
index 3962472239..a3b4675fd1 100755
--- a/Core/Code/Algorithms/mitkCoreObjectFactory.cpp
+++ b/Core/Code/Algorithms/mitkCoreObjectFactory.cpp
@@ -1,400 +1,408 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #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 "mitkPointSetGLMapper2D.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 "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::PointSetGLMapper2D::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;
 
     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() );
     itk::ObjectFactoryBase::RegisterFactory( PicVolumeTimeSeriesIOFactory::New() );
 
     mitk::SurfaceVtkWriterFactory::RegisterOneFactory();
     mitk::PointSetWriterFactory::RegisterOneFactory();
     mitk::ImageWriterFactory::RegisterOneFactory();
 
     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::PointSetGLMapper2D::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>("*.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_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze image header files"));
+  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img", "Analyze image files"));
+  m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.img.gz", "Analyze compressed image files"));
 
   //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", "Image Header Files"));
+  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.hdr", "Analyze image header files"));
+  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.img", "Analyze image files"));
+  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.img.gz", "Analyze compressed image files"));
   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>("*.gipl.gz", "UMDS compressed GIPL Format Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii", "NIfTI format"));
+  m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.nii.gz", "NIfTI compressed 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/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index f97c2af03d..754709210f 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,328 +1,331 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date$
 Version:   $Revision$
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkImageWriter.h"
 
 #include "mitkItkPictureWrite.h"
 #include "mitkImage.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkPicFileWriter.h"
 #include "mitkImageAccessByItk.h"
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 
 mitk::ImageWriter::ImageWriter()
 {
   this->SetNumberOfRequiredInputs( 1 );
   m_MimeType = "";
   SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
   m_Extension = ".mhd";
 }
 
 #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();
 }
 
 void mitk::ImageWriter::WriteByITK(mitk::Image* image, const std::string& fileName)
 {
   // 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)
   {
     AccessByItk_1( image, _mitkItkPictureWrite, fileName );
     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->SetPixelTypeInfo( *(pixelType.GetTypeId()) );
 
   if(pixelType.GetNumberOfComponents() > 1)
     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.Set_vnl_vector(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) );
   }
 
   imageIO->SetIORegion(ioRegion);
   imageIO->SetFileName(fileName);
 
   const void * data = image->GetData();
   imageIO->Write(data);
 }
 
 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());
 
   mitk::Image::Pointer input = const_cast<mitk::Image*>(this->GetInput());
 
   bool vti = (m_Extension.find(".vti") != std::string::npos);
 
   // If the extension is NOT .pic and NOT .nrrd the following block is entered
   if ( m_Extension.find(".pic") == std::string::npos
        && m_Extension.find(".nrrd") == 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)
       {
         ::itk::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;
         }
         else
         {
           itkWarningMacro(<<"Error on write: TimeSlicedGeometry invalid of image " << filename << ".");
           filename <<  m_FileName.c_str() << "_T" << t << m_Extension;
         }
         if ( vti )
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(input, filename.str());
         }
       }
     }
     else if ( vti )
     {
       ::itk::OStringStream filename;
       filename <<  m_FileName.c_str() << m_Extension;
       writeVti(filename.str().c_str(), input);
     }
     else
     {
       ::itk::OStringStream filename;
       filename <<  m_FileName.c_str() << m_Extension;
       WriteByITK(input, filename.str());
     }
   }
   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
       ::itk::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 )
     {
         ::itk::OStringStream filename;
         filename <<  this->m_FileName.c_str() << this->m_Extension;
         WriteByITK(input, filename.str());
     }
 
   }
   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 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(".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(".img");
+  possibleFileExtensions.push_back(".img.gz");
   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 ) );
   }
 }
diff --git a/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.cpp b/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.cpp
index 1d4e43fbb6..2b71192769 100644
--- a/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.cpp
+++ b/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.cpp
@@ -1,674 +1,694 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-09-18 09:35:44 +0200 (Do, 18 Sep 2008) $
 Version:   $Revision: 15278 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include <qregexp.h>
 #include <qmessagebox.h>
 #include <qfileinfo.h>
 #include <qstring.h>
 #include <QDateTime>
 #include <string>
 #include <strstream>
 #include "mitkPointSetWriter.h"
 #include "mitkConfig.h"
 #include "mitkCoreObjectFactory.h"
 #include "QmitkCommonFunctionality.h"
 #include <mitkImageAccessByItk.h>
 #include <mitkPicFileReader.h>
 
 #include <mitkIpPic.h>
 
 #include <vtkWindowToImageFilter.h>
 #include <vtkRenderWindow.h>
 #include <vtkPNGWriter.h>
 #include <vtkCellArray.h>
 #include <vtkTriangleFilter.h>
 
 #include <Poco/Path.h>
 
 void CommonFunctionality::SaveToFileWriter( mitk::FileWriterWithInformation::Pointer fileWriter, mitk::BaseData::Pointer data, const char* aFileName, const char* propFileName)
 { 
   if (! fileWriter->CanWriteBaseDataType(data) ) {
     QMessageBox::critical(NULL,"ERROR","Could not write file. Invalid data type for file writer.");
     return;
   }
 
   QString fileName;
   if (aFileName == NULL)
   {
     QString proposedName("");
     if(propFileName == NULL)
     {
       proposedName.append(fileWriter->GetDefaultFilename());
     }
     else
     {
       proposedName.append(propFileName).append(fileWriter->GetDefaultExtension());
     }
     fileName = GetSaveFileNameStartingInLastDirectory("Save file", proposedName,QString::fromAscii(fileWriter->GetFileDialogPattern()));
 
     // Check if an extension exists already and if not, append the default extension
     if ( !fileName.contains( QRegExp("\\.\\w+$") ) )
     {
       fileName.append( fileWriter->GetDefaultExtension() );
     }
     else
     {
       std::string extension = itksys::SystemTools::GetFilenameLastExtension( fileName.toLocal8Bit().constData() );
       if (!fileWriter->IsExtensionValid(extension))
       {
         QString message;
         message.append("File extension not suitable for writing given data. Choose one extension of this list: ");
         message.append(fileWriter->GetPossibleFileExtensionsAsString().c_str());
         QMessageBox::critical(NULL,"ERROR",message);
         return;
       }
     }
   }
   else
     fileName = aFileName;
 
   if (fileName.isEmpty() == false )
   {
     fileWriter->SetFileName( fileName.toLocal8Bit().constData() );
     fileWriter->DoWrite( data );
   }
 }
 
 
 /**
 * Saves the given mitk::BaseData to a file. The user is prompted to
 * enter a file name. Currently only mitk::Image, mitk::Surface, mitk::PointSet and
 * mitk::VesselGraphData are supported. This function is deprecated
 * until the save-problem is solved by means of a Save-Factory or any
 * other "nice" mechanism
 */
 void CommonFunctionality::SaveBaseData( mitk::BaseData* data, const char * aFileName )
 {
   //save initial time
   QDateTime initialTime = QDateTime::currentDateTime();
   std::string fileNameUsed; //file name that was actually used by the writer (e.g. after file open dialog)
   bool writingSuccessful = false;
 
   try{
     if (data != NULL)
     {
       mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(data);
       QString classname(data->GetNameOfClass());
       if ( image.IsNotNull() && (classname.compare("Image")==0 || classname.compare("SeedsImage")==0  ) )
       {
         fileNameUsed = CommonFunctionality::SaveImage(image, aFileName, true);
         if(!(fileNameUsed.length()>0)){
           return;
         } else {
           writingSuccessful = true;
         }
       }
 
       if(!writingSuccessful)
       {
         mitk::PointSet::Pointer pointset = dynamic_cast<mitk::PointSet*>(data);
         if(pointset.IsNotNull())
         {
           std::string fileName;
           if(aFileName == NULL)
             fileName = "PointSet";
           else
             fileName = aFileName;
 
           
           
           fileName = itksys::SystemTools::GetFilenameWithoutExtension(fileName);
                     
           QString initialFileName = QString::fromStdString(fileName);
 
           QString selected_suffix("MITK Point-Sets (*.mps)");
           QString possible_suffixes("MITK Point-Sets (*.mps)");
           
 
           /*QString qfileName = QFileDialog::getSaveFileName( NULL, "Save image", initialFilename ,mitk::CoreObjectFactory::GetInstance()->GetSaveFileExtensions(),&selected_suffix);
           */
           QString qfileName = GetSaveFileNameStartingInLastDirectory("Save file", initialFileName, possible_suffixes, &selected_suffix);
           
           
           MITK_INFO<<qfileName.toLocal8Bit().constData();
 
           mitk::PointSetWriter::Pointer writer = mitk::PointSetWriter::New();
           std::string extension = itksys::SystemTools::GetFilenameLastExtension( qfileName.toLocal8Bit().constData() );
           if (extension == "") // if no extension has been entered manually into the filename
           {
             // get from combobox selected file extension
             extension = itksys::SystemTools::GetFilenameLastExtension( selected_suffix.toLocal8Bit().constData());
             extension = extension.substr(0, extension.size()-1);
             qfileName += QString::fromStdString(extension);
           }
 
           MITK_INFO<<"extension: " << extension;
           // check if extension is valid
           if (!writer->IsExtensionValid(extension))
           {
             QString message;
             message.append("File extension not suitable for writing point set data. Choose one extension of this list: ");
             message.append(writer->GetPossibleFileExtensionsAsString().c_str());
             QMessageBox::critical(NULL,"ERROR",message);
             return;
           }
 
           if (qfileName.isEmpty() == false )
           {
             writer->SetInput( pointset );
             writer->SetFileName( qfileName.toLocal8Bit().constData() );
             writer->Update();
             fileNameUsed = writer->GetFileName();
             writingSuccessful = true;
           } else {
             return;
           }
         }
 
         if(!writingSuccessful)
         {
           mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>(data);
           if(surface.IsNotNull())
           {
             fileNameUsed = CommonFunctionality::SaveSurface(surface, aFileName);
             if(!(fileNameUsed.length()>0)){
               return;
             } else {
               writingSuccessful = true;
             }
           }
 
           if(!writingSuccessful)
           {
             // now try the file writers provided by the CoreObjectFactory
             mitk::CoreObjectFactory::FileWriterList fileWriters = mitk::CoreObjectFactory::GetInstance()->GetFileWriters();
             bool writerFound = false;
 
             for (mitk::CoreObjectFactory::FileWriterList::iterator it = fileWriters.begin() ; it != fileWriters.end() ; ++it) 
             {
               if ( (*it)->CanWriteBaseDataType(data) ) {
                 writerFound = true;
                 SaveToFileWriter(*it, data, NULL, aFileName); 
                 fileNameUsed = (*it)->GetFileName();
                 // correct writer has been found->break
                 if(!(fileNameUsed.length()>0)){
                   return;
                 } else {
                   writingSuccessful = true;
                   break;
                 }
               } 
             }
             if(!writerFound)
             {
               // no appropriate writer has been found 
               QMessageBox::critical(NULL,"ERROR","Could not find file writer for this data type"); 
               return;
             }
           }
         }
 
       }
     } else {
       QMessageBox::critical(NULL,"ERROR","Cannot write data (invalid/empty)"); 
       return;
     }
   } catch(itk::ExceptionObject e)
   {
     QMessageBox::critical( NULL, "SaveDialog", e.GetDescription(),QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
   }
 
   //writing is assumed to have been successful
 
   //check if file exists, file size >0 and last modified after this function was called
   try{
     QFileInfo* fileInfo = new QFileInfo(QString(fileNameUsed.c_str()));
     if(!fileInfo->exists())
     {
       QMessageBox::warning(NULL,"WARNING","File was not created or was split into multiple files");
     } else if(fileInfo->size()==0) {
       QMessageBox::warning(NULL,"WARNING","File is empty");
     } else if(fileInfo->lastModified()<initialTime) {
       QMessageBox::warning(NULL,"WARNING","Save not successful. File was not updated (only old version available)");
     }
     delete fileInfo;
   } catch(...) {
     QMessageBox::critical(NULL,"ERROR","Save not successful. Possibly no writing permission.");
   }
 }
 mitk::DataNode::Pointer CommonFunctionality::FileOpen( const QString& fileName)
 {
   return FileOpen( fileName.toLocal8Bit().constData() );
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpen( const char * fileName )
 {
   mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
 
   try
   {
     factory->SetFileName( fileName );
     factory->Update();
     return factory->GetOutput( 0 );
   }
   catch ( itk::ExceptionObject & ex )
   {
     itkGenericOutputMacro( << "Exception during file open: " << ex );
     return NULL;
   }
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpenImageSequence(const QString& aFileName)
 {
   return FileOpenImageSequence( aFileName.toLocal8Bit().constData() );
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpenImageSequence(const char* aFileName)
 {
   if(aFileName==NULL) return NULL;
 
   mitk::DataNodeFactory::Pointer factory = mitk::DataNodeFactory::New();
 
   QString fileName = aFileName;
   if (!fileName.contains("dcm") && !fileName.contains("DCM"))
   {
     int fnstart = fileName.lastIndexOf( QRegExp("[/\\\\]"), fileName.length() );
     if(fnstart<0) fnstart=0;
     int start = fileName.indexOf( QRegExp("[0-9]"), fnstart );
     if(start<0)
     {
       return FileOpen(fileName.toLocal8Bit().constData());;
     }
 
     char prefix[1024], pattern[1024];
 
     strncpy(prefix, fileName.toLocal8Bit().constData(), start);
     prefix[start]=0;
 
     int stop=fileName.indexOf( QRegExp("[^0-9]"), start );
     sprintf(pattern, "%%s%%0%uu%s",stop-start,fileName.toLocal8Bit().constData()+stop);
 
 
     factory->SetFilePattern( pattern );
     factory->SetFilePrefix( prefix );
   }
   else
   {
     //    factory->SetFileName( fileName );
     factory->SetFilePattern( fileName.toLocal8Bit().constData() );
     factory->SetFilePrefix( fileName.toLocal8Bit().constData() );
   }
   factory->Update();
   return factory->GetOutput( 0 );
 
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpenImageSequence()
 {
   QString fileName = QFileDialog::getOpenFileName(NULL,mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
 
   if ( !fileName.isNull() )
   {
     return FileOpenImageSequence(fileName);
   }
   else
   {
     return NULL;
   }
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpen()
 {
   return CommonFunctionality::FileOpenSpecific( mitk::CoreObjectFactory::GetInstance()->GetFileExtensions() );
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpenSpecific( const QString& fileExtensions)
 {
   return FileOpenSpecific( fileExtensions.toLocal8Bit().constData() );
 }
 
 mitk::DataNode::Pointer CommonFunctionality::FileOpenSpecific( const char *fileExtensions )
 {
   QString fileName = QFileDialog::getOpenFileName( NULL, fileExtensions );
   if ( !fileName.isNull() )
   {
     mitk::DataNode::Pointer result = FileOpen(fileName.toLocal8Bit().constData());
     if ( result.IsNull() )
     {
       return FileOpenImageSequence(fileName);
     }
     else
     {
       return result;
     }
   }
   else
   {
     return NULL;
   }
 }
 
 mitk::DataNode::Pointer CommonFunctionality::OpenVolumeOrSliceStack()
 {
   mitk::DataNode::Pointer newNode = NULL;
 
   QString fileName = QFileDialog::getOpenFileName(NULL,mitk::CoreObjectFactory::GetInstance()->GetFileExtensions() );
   if ( !fileName.isNull() )
   {
     newNode = CommonFunctionality::FileOpen(fileName);
     if (newNode.IsNotNull())
     {
       mitk::Image::Pointer imageData = dynamic_cast<mitk::Image*> (newNode->GetData()) ;
       if (imageData.IsNull()) return NULL;
 
       if (imageData->GetDimension(2) == 1)
       {
         //        std::string dir = itksys::SystemTools::GetFilenamePath( std::string(fileName.ascii()) )
         newNode = CommonFunctionality::FileOpenImageSequence(fileName);
         imageData = dynamic_cast<mitk::Image*> (newNode->GetData());
       }
       return newNode;
     }
   }
   {
     return NULL;
   }
 }
 
 #include "mitkSurfaceVtkWriter.h"
 #include <vtkSTLWriter.h>
 #include <vtkPolyDataWriter.h>
 #include <vtkXMLPolyDataWriter.h>
 
 std::string CommonFunctionality::SaveSurface(mitk::Surface* surface, const char* aFileName)
 {
   std::string fileName;
   if(aFileName == NULL)
     fileName = "Surface";
   else
     fileName = aFileName;
 
   std::string selectedItemsName = itksys::SystemTools::GetFilenameWithoutExtension(fileName);
   //selectedItemsName += ".stl"
   QString selected_suffix("STL File (*.stl)");
   QString possible_suffixes("STL File (*.stl);; VTK File (*.vtk);; VTP File (*.vtp)");
   QString qfileName = GetSaveFileNameStartingInLastDirectory("Save surface object", QString::fromStdString(selectedItemsName), possible_suffixes,&selected_suffix);
 
   if (qfileName.isEmpty())
     return "";
 
   std::string extension = itksys::SystemTools::GetFilenameLastExtension( qfileName.toStdString() );
   if (extension == "") // if no extension has been entered manually into the filename
   {
     // get from combobox selected file extension
     extension = itksys::SystemTools::GetFilenameLastExtension( selected_suffix.toLocal8Bit().constData());
     extension = extension.substr(0, extension.size()-1);
     qfileName += QString::fromStdString(extension);
   }
 
   if(extension == ".stl" )
   {
     mitk::SurfaceVtkWriter<vtkSTLWriter>::Pointer writer=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 )
     {
       vtkTriangleFilter* triangleFilter = vtkTriangleFilter::New();
       triangleFilter->SetInput(polys);
       triangleFilter->Update();
       polys = triangleFilter->GetOutput();
       polys->Register(NULL);
       triangleFilter->Delete();
       surface->SetVtkPolyData(polys);
     }
 
     writer->SetInput( surface );
     writer->SetFileName(qfileName.toLocal8Bit().constData());
     writer->GetVtkWriter()->SetFileTypeToBinary();
     writer->Write();
   }
   else if(extension == ".vtp")
   {
     mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::Pointer writer=mitk::SurfaceVtkWriter<vtkXMLPolyDataWriter>::New();
     writer->SetInput( surface );
     writer->SetFileName(qfileName.toLocal8Bit().constData());
     writer->GetVtkWriter()->SetDataModeToBinary();
     writer->Write();
   }
   else if (extension == ".vtk")
   {
     mitk::SurfaceVtkWriter<vtkPolyDataWriter>::Pointer writer=mitk::SurfaceVtkWriter<vtkPolyDataWriter>::New();
     writer->SetInput( surface );
     writer->SetFileName(qfileName.toLocal8Bit().constData());
     writer->Write();
   }
   else
   {
     // file extension not suitable for writing specified data type
     QMessageBox::critical(NULL,"ERROR","File extension not suitable for writing Surface data. Choose .vtk, .stl or .vtp");
     return "";
   }
   return qfileName.toLocal8Bit().constData();
 }
 
 #include "mitkImageWriter.h"
 #include <itksys/SystemTools.hxx>
 
+void CommonFunctionality::HandleGZExtension(std::string &baseFileName, std::string &extension)
+{
+  if (extension == ".gz")
+  {
+    std::string filenameWithoutGZ = baseFileName;
+    baseFileName = itksys::SystemTools::GetFilenameWithoutLastExtension( filenameWithoutGZ );
+    extension = itksys::SystemTools::GetFilenameLastExtension( filenameWithoutGZ ) + ".gz";
+  }
+}
+
 std::string CommonFunctionality::SaveImage(mitk::Image* image, const char* aFileName, bool askForDifferentFilename)
 {
   QString selected_suffix("Nearly Raw Raster Data (*.nrrd)");
 
   std::string fileName;
+
   if(aFileName == NULL || askForDifferentFilename)
   {
     QString initialFilename(aFileName);
     if (initialFilename.isEmpty()) initialFilename = "NewImage.pic";
 
     QString qfileName = GetSaveFileNameStartingInLastDirectory("Save image", initialFilename ,mitk::CoreObjectFactory::GetInstance()->GetSaveFileExtensions(),&selected_suffix);
     MITK_INFO<<qfileName.toLocal8Bit().constData();
     if (qfileName.isEmpty() )
+    {
       return "";
+    }
     fileName = qfileName.toLocal8Bit().constData();
   }
   else
+  {
     fileName = aFileName;
+  }
 
   try
   {
     std::string dir = itksys::SystemTools::GetFilenamePath( fileName );
     std::string baseFilename = itksys::SystemTools::GetFilenameWithoutLastExtension( fileName );
     std::string extension = itksys::SystemTools::GetFilenameLastExtension( fileName );
+    HandleGZExtension(baseFilename, extension);
 
     if (extension == "") // if no extension has been entered manually into the filename
     {
       // get from combobox selected file extension
-      extension = itksys::SystemTools::GetFilenameLastExtension( selected_suffix.toLocal8Bit().constData());
+      std::string selectedSuffix = selected_suffix.toLocal8Bit().constData();
+      std::string baseSelectedSuffix = itksys::SystemTools::GetFilenameWithoutLastExtension( selectedSuffix );
+      extension = itksys::SystemTools::GetFilenameLastExtension( selectedSuffix );
       extension = extension.substr(0, extension.size()-1);
+
+      HandleGZExtension(baseSelectedSuffix, extension);
       fileName += extension;
     }
 
-    if (extension == ".gz")
+    if (extension == ".pic.gz")
     {
       QMessageBox::critical( NULL, "SaveDialog", "Warning: You can not save an image in the compressed \n"
         ".pic.gz format. You must save as a normal .pic file.\n"
         "Please press Save again and choose a filename with a .pic ending.",
         QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
       return "";
     }
     // check if extension is suitable for writing image data
     mitk::ImageWriter::Pointer imageWriter = mitk::ImageWriter::New();
     if (!imageWriter->IsExtensionValid(extension))
     {
       QString message;
       message.append("File extension not suitable for writing image data. Choose one extension of this list: ");
       message.append(imageWriter->GetPossibleFileExtensionsAsString().c_str());
       QMessageBox::critical(NULL,"ERROR",message);
       return "";
     }
 
     dir += "/";
     dir += baseFilename;
    
     imageWriter->SetInput(image);
     imageWriter->SetFileName(dir.c_str());
     imageWriter->SetExtension(extension.c_str());
     imageWriter->Write();
   }
   catch ( itk::ExceptionObject &err)
   {
     itkGenericOutputMacro( << "Exception during write: " << err );
     QString exceptionString;
     exceptionString.append("Error during write image: ");
     exceptionString.append(err.GetDescription());
     QMessageBox::critical(NULL,"ERROR",exceptionString);
     return "";
   }
   catch ( ... )
   {
     itkGenericOutputMacro( << "Unknown type of exception during write" );
     QMessageBox::critical(NULL,"ERROR","Error during write image. Possibly no writing permission.");
     fileName = "";
   }
   return fileName;
 }
 
 
 std::string CommonFunctionality::SaveScreenshot( vtkRenderWindow* renderWindow , const char* filename )
 {
   //
   // perform some error checking
   //
   if ( ! renderWindow )
   {
     itkGenericOutputMacro( << "render window is NULL!" );
     return std::string("");
   }
   if ( ! renderWindow )
   {
     itkGenericOutputMacro( << "Unsupported type of render window! The only supported type is currently QmitkRenderWindow." );
     return std::string("");
   }
 
   //
   // create the screenshot before the filechooser is opened,
   // so there the file chooser will not be part of the screenshot
   //
   //QPixmap buffer = QPixmap::grabWindow( qtRenderWindow->winId() );
 
   // new Version: 
   //// take screenshot of render window without the coloured frame of 2 pixels by cropping the raw image data
   vtkWindowToImageFilter* wti = vtkWindowToImageFilter::New();
   wti->SetInput( renderWindow );
   wti->Update();
   vtkImageData* imageData = wti->GetOutput();
   int framesize = 5;
   int* windowSize = renderWindow->GetSize();
   int numberOfScalarComponents = imageData->GetNumberOfScalarComponents();
   vtkImageData* processedImageData = vtkImageData::New();
   processedImageData->SetNumberOfScalarComponents(numberOfScalarComponents);
   processedImageData->SetExtent(0,windowSize[0]-2*framesize-1,0,windowSize[1]-2*framesize-1,0,0);
   processedImageData->SetScalarTypeToUnsignedChar();
   for (int i=framesize; i<windowSize[0]-framesize; i++)
   {
     for (int j=framesize; j<windowSize[1]-framesize; j++)
     {
       for (int k=0; k<numberOfScalarComponents; k++)
       {
         processedImageData->SetScalarComponentFromDouble(i-framesize,j-framesize,0,k,imageData->GetScalarComponentAsDouble(i,j,0,k));
       }
     }
   }
 
   // write new image as *.png to file
   vtkPNGWriter* pngWriter = vtkPNGWriter::New();
 
   //
   // if the provided filename is empty ask the user 
   // for the name of the file in which the screenshot
   // should be saved
   //
   std::string concreteFilename = "";
   if( filename == NULL )
   {
     //
     // show a file selector with the supported file formats
     //
     QString qfileName = GetSaveFileNameStartingInLastDirectory("Save screenshot", QString::fromStdString(""), QString::fromStdString(".png") );
     if ( qfileName.isEmpty() )
       return "";
     concreteFilename = qfileName.toLocal8Bit().constData();
   }
   else
     concreteFilename = filename;
 
   // make sure the filename ends with .png
   const std::string outFileSuffix("png");
   std::string::size_type pos = concreteFilename.rfind('.');
 
   if ( pos == std::string::npos )
     concreteFilename = concreteFilename + '.' + outFileSuffix;
   else 
   {
     std::string extname = concreteFilename.substr(pos+1);
     if ( extname.empty() ) concreteFilename += outFileSuffix; // name ended with '.'
     if ( !(extname == outFileSuffix) )
       concreteFilename.replace( pos+1, std::string::npos, "png" );
   }
 
   //
   // wait for 500 ms to let the file chooser close itself
   //  
   // int msecs = 500;
   // clock_t ticks = ( clock_t )( ( ( ( float ) msecs ) / 1000.0f ) * ( ( float ) CLOCKS_PER_SEC ) );
   // clock_t goal = ticks + std::clock();
   // while ( goal > std::clock() );
   //
 
   //
   // save the screenshot under the given filename
   //
 
   pngWriter->SetInput(processedImageData);
   //pngWriter->SetInput( wti->GetOutput() );
   pngWriter->SetFileName( concreteFilename.c_str() );
 
   pngWriter->Write();
 
   if ( pngWriter->GetErrorCode() != 0 )
     QMessageBox::information(NULL, "Save Screenshot...", "The file could not be saved. Please check filename, format and access rights...");
 
   wti->Delete();
   pngWriter->Delete();
   return concreteFilename;  
 }
 
 QString CommonFunctionality::GetSaveFileNameStartingInLastDirectory(QString caption, QString defaultFilename, QString filter, QString* selectedFilter)
 {
 QString returnValue = "";
 static QString lastDirectory = "";
 QString filename = lastDirectory + defaultFilename;
 returnValue = QFileDialog::getSaveFileName(NULL,caption,filename,filter,selectedFilter);
 if (returnValue != "")
   {
   std::string dir = itksys::SystemTools::GetFilenamePath( returnValue.toStdString() );
   dir += Poco::Path::separator();
   lastDirectory = dir.c_str(); // remember path for next save dialog
   }
 return returnValue;
 }
 
diff --git a/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.h b/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.h
index dd85e13fe5..fba136ba5a 100644
--- a/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.h
+++ b/Modules/QmitkExt/QmitkApplicationBase/QmitkCommonFunctionality.h
@@ -1,155 +1,161 @@
 /*=========================================================================
  
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2008-07-30 13:49:05 +0200 (Mi, 30 Jul 2008) $
 Version:   $Revision: 14840 $
  
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
  
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
  
 =========================================================================*/
 
 
 #ifndef _CommonFunctionality__h_
 #define _CommonFunctionality__h_
 
 #include "mitkConfig.h"
 #include "QmitkExtExports.h"
 #include <mitkCommon.h>
 
 // std
 #include <string>
 #include <vector>
 
 #include <vtkRenderWindow.h>
 
 // itk includes
 #include <itkMinimumMaximumImageCalculator.h>
 
 // mitk includes
 #include <mitkProperties.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkStringProperty.h>
 #include <mitkDataNode.h>
 #include <mitkDataNodeFactory.h>
 #include <mitkImageCast.h>
 #include <mitkSurface.h>
 #include "itkImage.h"
 #include <mitkFileWriterWithInformation.h>
 
 #include <qstring.h>
 #include <qfiledialog.h>
 
 #include <itksys/SystemTools.hxx>
 
 #include "mitkLevelWindow.h"
 #include "vtkPolyData.h"
 
 struct mitkIpPicDescriptor;
 
 namespace mitk
 {
   class Surface;
   class Image;
   class VesselTreeData;
 }
 
 /**
  * This class provides some data handling methods, like loading data or adding different 
  * types to the data tree...
  */
 namespace CommonFunctionality
 {
 
   typedef std::vector<mitk::DataNode*> DataNodeVector;
   /** \brief compute min and max
   */
   template < typename TImageType >
   static void MinMax(typename TImageType::Pointer image, float &min, float &max)
   {
     typedef itk::MinimumMaximumImageCalculator<TImageType> MinMaxCalcType;
     typename MinMaxCalcType::Pointer minmax = MinMaxCalcType::New();
     minmax->SetImage( image );
     minmax->ComputeMinimum();
     minmax->ComputeMaximum();
 
     min = (float) minmax->GetMinimum();
     max = (float) minmax->GetMaximum();
 
 
   }
 
   template < typename TImageType >
   static void AutoLevelWindow( mitk::DataNode::Pointer node )
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*> (node->GetData() );
     if ( image.IsNotNull() )
     {
       typename TImageType::Pointer itkImage= TImageType::New();
       mitk::CastToItkImage( image, itkImage);
       float extrema[2];
       extrema[0] = 0;
       extrema[1] = 4096;
       MinMax<TImageType>(itkImage,extrema[0],extrema[1]);
 
       mitk::LevelWindowProperty::Pointer levWinProp = dynamic_cast<mitk::LevelWindowProperty*>(node->GetPropertyList()->GetProperty("levelwindow"));
       if( levWinProp.IsNull() )
       {
         levWinProp = mitk::LevelWindowProperty::New();
         node->GetPropertyList()->SetProperty("levelwindow", levWinProp);
       }
 
       double window = (extrema[1] - extrema[0])/10.0;
       double level  = window/2;
 
       mitk::LevelWindow levWin = levWinProp->GetLevelWindow();
       levWin.SetRangeMinMax(extrema[0], extrema[1]);
       levWin.SetLevelWindow( level, window );
       levWinProp->SetLevelWindow(levWin);
 
     }
   }
 
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpen( const QString& fileName);
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpen( const char *fileName );
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpenSpecific( const QString& fileExtensions);
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpenSpecific( const char *fileExtensions );
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpenImageSequence(const QString& fileName);
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpenImageSequence(const char* fileName);
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpenImageSequence();
   QmitkExt_EXPORT mitk::DataNode::Pointer FileOpen();
   QmitkExt_EXPORT mitk::DataNode::Pointer OpenVolumeOrSliceStack();
 
   QmitkExt_EXPORT std::string SaveImage(mitk::Image* image, const char* aFileName = NULL, bool askForDifferentFilename = false);
 
+  /**
+   * @brief Used by SaveImage to handle the case when extension=.gz.
+   * So, if input baseFileName="tmp.nii" and extension=".gz", output will be baseFileName="tmp" and extension=".nii.gz".
+   */
+  QmitkExt_EXPORT void HandleGZExtension(std::string &baseFileName, std::string &extension);
+
   QmitkExt_EXPORT std::string SaveSurface(mitk::Surface* surface, const char* fileName = NULL);
   
   /**
    * Saves a screenshot of the given renderer in a file.
    * @param renderWindow the render window to generate a screenshot from. If renderWindow
    *                     is NULL, the function returns an empty string.
    * @param filename     the filename, under which the file should be saved. If 
    *                     filename is NULL, a file selector pops up and asks for a
    *                     file name. The file type is determined via the extension
    *                     of the screen shot
    * @returns the filename of the saved file
    */
   QmitkExt_EXPORT std::string SaveScreenshot( vtkRenderWindow* renderWindow , const char* filename = NULL );
 
   QmitkExt_EXPORT void SaveToFileWriter( mitk::FileWriterWithInformation::Pointer fileWriter, mitk::BaseData::Pointer data, const char* aFileName, const char* propFileName);
 
   // internal vessel graph save code removed ...
   
   QmitkExt_EXPORT void SaveBaseData( mitk::BaseData* data, const char* name = NULL );
 
   /** @brief Opens a dialog to define a save filename which starts in the same directory like last time. */
   QString GetSaveFileNameStartingInLastDirectory(QString caption, QString defaultFilename, QString filter, QString* selectedFilter = 0);
 
 };
 #endif // _CommonFunctionality__h_