diff --git a/Core/Code/DataManagement/mitkDataNodeFactory.cpp b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
index 6665197e52..bc484ae09c 100644
--- a/Core/Code/DataManagement/mitkDataNodeFactory.cpp
+++ b/Core/Code/DataManagement/mitkDataNodeFactory.cpp
@@ -1,489 +1,489 @@
 /*===================================================================
 
 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 <mitkDataNodeFactory.h>
 #include <mitkBaseDataIOFactory.h>
 #include <mitkCoreObjectFactory.h>
 #include <mitkITKImageImport.h>
 
 // C-Standard library includes
 #include <stdlib.h>
 #include <locale.h>
 
 // STL-related includes
 #include <vector>
 #include <map>
 #include <istream>
 #include <cstdlib>
 #include <locale>
 
 
 // VTK-related includes
 #include <vtkSTLReader.h>
 #include <vtkOBJReader.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataNormals.h>
 
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkStructuredPointsReader.h>
 
 #include <vtkStructuredPoints.h>
 #include <vtkLookupTable.h>
 #include <vtkPointData.h>
 #include <vtkXMLImageDataReader.h>
 
 // ITK-related includes
 
 #include <itksys/SystemTools.hxx>
 #include <itksys/Directory.hxx>
 #include <itkImage.h>
 #include <itkImageSeriesReader.h>
 #include <itkImageFileReader.h>
 #include <itkImageIOFactory.h>
 #include <itkImageIORegion.h>
 #include <itkImageSeriesReader.h>
 #include <itkGDCMImageIO.h>
 
 #ifdef NOMINMAX
 #  define DEF_NOMINMAX
 #  undef NOMINMAX
 #endif
 
 #include <itkGDCMSeriesFileNames.h>
 
 #ifdef DEF_NOMINMAX
 #  ifndef NOMINMAX
 #    define NOMINMAX
 #  endif
 #  undef DEF_NOMINMAX
 #endif
 
 #include <itkNumericSeriesFileNames.h>
 #include <itkCommand.h>
 
 // MITK-related includes
 #include "mitkSurface.h"
 #include "mitkPointSet.h"
 #include "mitkStringProperty.h"
 #include "mitkProperties.h"
 //#include "mitkMaterialProperty.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "mitkVtkInterpolationProperty.h"
 #include "mitkVtkScalarModeProperty.h"
 #include "mitkImage.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkLookupTable.h"
 #include "mitkImageChannelSelector.h"
 #include "mitkImageSliceSelector.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkTransferFunctionProperty.h"
 #include "mitkVtkResliceInterpolationProperty.h"
 #include "mitkProgressBar.h"
 #include <mitkDicomSeriesReader.h>
 
 bool mitk::DataNodeFactory::m_TextureInterpolationActive = false;    // default value for texture interpolation if nothing is defined in global options (see QmitkMainTemplate.ui.h)
 
 mitk::DataNodeFactory::DataNodeFactory()
 {
   m_Serie = false;
   m_OldProgress = 0;
   this->Modified();
   //ensure that a CoreObjectFactory has been instantiated
   mitk::CoreObjectFactory::GetInstance();
 }
 
 mitk::DataNodeFactory::~DataNodeFactory()
 {}
 
 void mitk::DataNodeFactory::SetImageSerie(bool serie)
 {
   m_Serie = serie;
 }
 
 void mitk::DataNodeFactory::GenerateData()
 {
   // IF filename is something.pic, and something.pic does not exist, try to read something.pic.gz
   // if there are both, something.pic and something.pic.gz, only the requested file is read
   // not only for images, but for all formats
   std::ifstream exists(m_FileName.c_str());
   if (!exists)
   {
     std::string testfilename = m_FileName + ".gz";
 
     std::ifstream exists(testfilename.c_str());
     if (exists.good())
     {
       m_FileName += ".gz";
     }
     else
     {
       testfilename = m_FileName + ".GZ";
       std::ifstream exists(testfilename.c_str());
       if (exists.good())
       {
         m_FileName += ".GZ";
       }
       else
       {
         std::string message("File does not exist, or cannot be read. Filename = ");
         message += m_FileName;
         MITK_ERROR << message;
-        itkExceptionMacro( << message );
+        itkExceptionMacro( << message.str() );
       }
     }
   }
 
   // part for DICOM
 //  const char *numbers = "0123456789.";
 //  std::string::size_type first_non_number;
 //  first_non_number = itksys::SystemTools::GetFilenameName(m_FileName).find_first_not_of ( numbers );
 
   if (DicomSeriesReader::IsDicom(this->m_FileName) /*|| first_non_number == std::string::npos*/)
   {
     this->ReadFileSeriesTypeDCM();
   }
   else
   {
     bool usedNewDTNF = false;
 
     // the mitkBaseDataIO class returns a pointer of a vector of BaseData objects
     std::vector<mitk::BaseData::Pointer> baseDataVector = mitk::BaseDataIO::LoadBaseDataFromFile( m_FileName, m_FilePrefix, m_FilePattern, m_Serie );
 
     if( !baseDataVector.empty() )
       this->ResizeOutputs((unsigned int)baseDataVector.size());
 
     for(int i=0; i<(int)baseDataVector.size(); i++)
     {
       mitk::BaseData::Pointer baseData = baseDataVector.at(i);
 
       if( baseData.IsNotNull() )
       {
         usedNewDTNF = true;
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(baseData);
         this->SetDefaultCommonProperties( node );
 
         this->SetOutput(this->MakeNameFromOutputIndex(i), node);
       }
     }
     if(!usedNewDTNF && ( m_FileName != "" ) && !(m_Serie == false))
         ReadFileSeriesTypeITKImageSeriesReader();
   }
 }
 
 void mitk::DataNodeFactory::ResizeOutputs( const unsigned int& num )
 {
   unsigned int prevNum = this->GetNumberOfOutputs();
   this->SetNumberOfIndexedOutputs( num );
   for ( unsigned int i = prevNum; i < num; ++i )
   {
     this->SetNthOutput( i, this->MakeOutput( i ).GetPointer() );
   }
 }
 
 bool mitk::DataNodeFactory::FileNameEndsWith( const std::string& name )
 {
   if (m_FileName.size() < name.size()) return false;
 
   return m_FileName.substr(m_FileName.size() - name.size()) == name;
 }
 
 bool mitk::DataNodeFactory::FilePatternEndsWith( const std::string& name )
 {
   return m_FilePattern.find( name ) != std::string::npos;
 }
 
 std::string mitk::DataNodeFactory::GetBaseFileName()
 {
   return itksys::SystemTools::GetFilenameName( m_FileName );
 }
 
 std::string mitk::DataNodeFactory::GetBaseFilePrefix()
 {
   return itksys::SystemTools::GetFilenameName( m_FilePrefix );
 }
 
 std::string mitk::DataNodeFactory::GetDirectory()
 {
   if ( !m_FileName.empty() )   return itksys::SystemTools::GetFilenamePath( m_FileName );
   if ( !m_FilePrefix.empty() ) return itksys::SystemTools::GetFilenamePath( m_FilePrefix );
 
   return std::string();
 }
 
 void mitk::DataNodeFactory::ReadFileSeriesTypeDCM()
 {
   const char* previousCLocale = setlocale(LC_NUMERIC, NULL);
   setlocale(LC_NUMERIC, "C");
   std::locale previousCppLocale( std::cin.getloc() );
   std::locale l( "C" );
   std::cin.imbue(l);
 
   if (  DicomSeriesReader::IsPhilips3DDicom(this->GetFileName()) )
   {
     MITK_INFO << "it is a Philips3D US Dicom file" << std::endl;
     this->ResizeOutputs(1);
     DataNode::Pointer node = this->GetOutput();
     mitk::DicomSeriesReader::StringContainer stringvec;
     stringvec.push_back(this->GetFileName());
     if (DicomSeriesReader::LoadDicomSeries(stringvec, *node))
     {
       node->SetName(this->GetBaseFileName());
     }
     setlocale(LC_NUMERIC, previousCLocale);
     std::cin.imbue(previousCppLocale);
     return;
 
   }
 
   DicomSeriesReader::FileNamesGrouping imageBlocks = DicomSeriesReader::GetSeries(this->GetDirectory(), true, this->m_SeriesRestrictions); // true = group gantry tilt images
   const unsigned int size = imageBlocks.size();
 
   this->ResizeOutputs(size);
   ProgressBar::GetInstance()->AddStepsToDo(size);
   ProgressBar::GetInstance()->Progress();
 
   unsigned int outputIndex = 0u;
   const DicomSeriesReader::FileNamesGrouping::const_iterator n_end = imageBlocks.end();
 
   for (DicomSeriesReader::FileNamesGrouping::const_iterator n_it = imageBlocks.begin(); n_it != n_end; ++n_it)
   {
     const std::string &uid = n_it->first;
     DataNode::Pointer node = this->GetOutput(outputIndex);
 
     const DicomSeriesReader::ImageBlockDescriptor& imageBlockDescriptor( n_it->second );
 
     MITK_INFO << "--------------------------------------------------------------------------------";
     MITK_INFO << "DataNodeFactory: Loading DICOM series " << outputIndex << ": Series UID " << imageBlockDescriptor.GetSeriesInstanceUID() << std::endl;
     MITK_INFO << "  " << imageBlockDescriptor.GetFilenames().size() << " '" << imageBlockDescriptor.GetModality() << "' files (" << imageBlockDescriptor.GetSOPClassUIDAsString() << ") loaded into 1 mitk::Image";
     MITK_INFO << "  multi-frame: " << (imageBlockDescriptor.IsMultiFrameImage()?"Yes":"No");
     MITK_INFO << "  reader support: " << DicomSeriesReader::ReaderImplementationLevelToString(imageBlockDescriptor.GetReaderImplementationLevel());
     MITK_INFO << "  pixel spacing type: " << DicomSeriesReader::PixelSpacingInterpretationToString( imageBlockDescriptor.GetPixelSpacingType() );
     MITK_INFO << "  gantry tilt corrected: " << (imageBlockDescriptor.HasGantryTiltCorrected()?"Yes":"No");
     MITK_INFO << "  3D+t: " << (imageBlockDescriptor.HasMultipleTimePoints()?"Yes":"No");
     MITK_INFO << "--------------------------------------------------------------------------------";
 
     if (DicomSeriesReader::LoadDicomSeries(n_it->second.GetFilenames(), *node, true, true, true))
     {
       std::string nodeName(uid);
       std::string studyDescription;
       if ( node->GetStringProperty( "dicom.study.StudyDescription", studyDescription ) )
       {
         nodeName = studyDescription;
         std::string seriesDescription;
         if ( node->GetStringProperty( "dicom.series.SeriesDescription", seriesDescription ) )
         {
           nodeName += "/" + seriesDescription;
         }
       }
 
       node->SetName(nodeName);
 
       ++outputIndex;
     }
     else
     {
       MITK_ERROR << "DataNodeFactory: Skipping series " << outputIndex << " due to some unspecified error..." << std::endl;
     }
 
     ProgressBar::GetInstance()->Progress();
   }
 
   setlocale(LC_NUMERIC, previousCLocale);
   std::cin.imbue(previousCppLocale);
 }
 
 
 
 void mitk::DataNodeFactory::ReadFileSeriesTypeITKImageSeriesReader()
 {
   typedef itk::Image<int, 3> ImageType;
   typedef itk::ImageSeriesReader< ImageType > ReaderType;
 
   if ( ! this->GenerateFileList() )
   {
     itkWarningMacro( "Sorry, file list could not be generated!" );
     return ;
   }
   if ( m_MatchedFileNames.size() == 0 )
   {
     itkWarningMacro( "Sorry, no files matched the given filename ("<< m_FileName <<")!" );
     return ;
   }
 
   //
   // Finally, initialize the ITK-reader and load the files!
   //
   ReaderType::Pointer reader = ReaderType::New();
   reader->SetFileNames( m_MatchedFileNames );
   try
   {
     reader->Update();
     ResizeOutputs( reader->GetNumberOfOutputs() );
     for ( unsigned int i = 0; i < reader->GetNumberOfOutputs(); ++i )
     {
       //Initialize mitk image from itk
       mitk::Image::Pointer image = mitk::Image::New();
       image->InitializeByItk( reader->GetOutput( i ) );
       image->SetVolume( reader->GetOutput( i )->GetBufferPointer() );
 
       //add the mitk image to the node
       mitk::DataNode::Pointer node = this->GetOutput( i );
       node->SetData( image );
 
       mitk::StringProperty::Pointer nameProp = mitk::StringProperty::New( m_FileName );
       node->SetProperty( "name", nameProp );
     }
   }
   catch ( const std::exception & e )
   {
     itkWarningMacro( << e.what() );
     return ;
   }
 }
 
 
 
 mitk::ColorProperty::Pointer mitk::DataNodeFactory::DefaultColorForOrgan( const std::string& organ )
 {
   static bool initialized = false;
   static std::map< std::string, std::string > s_ColorMap;
 
   if (!initialized)
   {
     // all lowercase here, please!
 
     s_ColorMap.insert( std::make_pair( "ankle",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "appendix",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "blood vessels",       "0xff3131") );
     s_ColorMap.insert( std::make_pair( "bronchial tree",      "0x3168ff") );
     s_ColorMap.insert( std::make_pair( "bone",                "0xd5d5d5") );
     s_ColorMap.insert( std::make_pair( "brain",               "0xff9cca") );
     s_ColorMap.insert( std::make_pair( "coccyx",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "colon",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "cyst",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "elbow",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "eye",                 "0xe38686") );
     s_ColorMap.insert( std::make_pair( "fallopian tube",      "0xe38686") );
     s_ColorMap.insert( std::make_pair( "fat",                 "0xff2bee") );
     s_ColorMap.insert( std::make_pair( "hand",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "gall bladder",        "0x567f18") );
     s_ColorMap.insert( std::make_pair( "heart",               "0xeb1d32") );
     s_ColorMap.insert( std::make_pair( "hip",                 "0xe38686") );
     s_ColorMap.insert( std::make_pair( "kidney",              "0xd33f00") );
     s_ColorMap.insert( std::make_pair( "knee",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "larynx",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "liver",               "0xffcc3d") );
     s_ColorMap.insert( std::make_pair( "lung",                "0x6bdcff") );
     s_ColorMap.insert( std::make_pair( "lymph node",          "0xff0000") );
     s_ColorMap.insert( std::make_pair( "muscle",              "0xff456a") );
     s_ColorMap.insert( std::make_pair( "nerve",               "0xffea4f") );
     s_ColorMap.insert( std::make_pair( "nose",                "0xe38686") );
     s_ColorMap.insert( std::make_pair( "oesophagus",          "0xe38686") );
     s_ColorMap.insert( std::make_pair( "ovaries",             "0xe38686") );
     s_ColorMap.insert( std::make_pair( "pancreas",            "0xf9ab3d") );
     s_ColorMap.insert( std::make_pair( "pelvis",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "penis",               "0xe38686") );
     s_ColorMap.insert( std::make_pair( "pharynx",             "0xe38686") );
     s_ColorMap.insert( std::make_pair( "prostate",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "rectum",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "sacrum",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "seminal vesicle",     "0xe38686") );
     s_ColorMap.insert( std::make_pair( "shoulder",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "spinal cord",         "0xf5f93d") );
     s_ColorMap.insert( std::make_pair( "spleen",              "0xf96c3d") );
     s_ColorMap.insert( std::make_pair( "stomach",             "0xf96c3d") );
     s_ColorMap.insert( std::make_pair( "teeth",               "0xfffcd8") );
     s_ColorMap.insert( std::make_pair( "testicles",           "0xe38686") );
     s_ColorMap.insert( std::make_pair( "thyroid",             "0xfff694") );
     s_ColorMap.insert( std::make_pair( "tongue",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "tumor",               "0x937011") );
     s_ColorMap.insert( std::make_pair( "urethra",             "0xf8ff32") );
     s_ColorMap.insert( std::make_pair( "urinary bladder",     "0xf8ff32") );
     s_ColorMap.insert( std::make_pair( "uterus",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "vagina",              "0xe38686") );
     s_ColorMap.insert( std::make_pair( "vertebra",            "0xe38686") );
     s_ColorMap.insert( std::make_pair( "wrist",               "0xe38686") );
     initialized = true;
   }
 
   std::string lowercaseOrgan(organ);
   for(unsigned int i = 0; i < organ.length(); i++)
   {
     lowercaseOrgan[i] = tolower(lowercaseOrgan[i]);
   }
 
   std::map< std::string, std::string >::iterator iter = s_ColorMap.find( lowercaseOrgan );
   if ( iter != s_ColorMap.end() )
   {
     std::string hexColor = iter->second;
     std::string hexRed   = std::string("0x") + hexColor.substr( 2, 2 );
     std::string hexGreen = std::string("0x") + hexColor.substr( 4, 2 );
     std::string hexBlue  = std::string("0x") + hexColor.substr( 6, 2 );
 
     long int red   = strtol( hexRed.c_str(), NULL, 16 );
     long int green = strtol( hexGreen.c_str(), NULL, 16 );
     long int blue  = strtol( hexBlue.c_str(), NULL, 16 );
 
     return ColorProperty::New( (float)red/ 255.0, (float)green/ 255.0, (float)blue/ 255.0 );
   }
   else
   {
     // a default color (green)
     return ColorProperty::New( 0.0, 1.0, 0.0 );
   }
 
 }
 
 void mitk::DataNodeFactory::SetDefaultCommonProperties(mitk::DataNode::Pointer &node)
 {
   // path
   mitk::StringProperty::Pointer pathProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenamePath( m_FileName ) );
   node->SetProperty( StringProperty::PATH, pathProp );
 
 
   // name already defined?
   mitk::StringProperty::Pointer nameProp = dynamic_cast<mitk::StringProperty*>(node->GetProperty("name"));
   if(nameProp.IsNull() || (strcmp(nameProp->GetValue(),"No Name!")==0))
   {
     // name already defined in BaseData
     mitk::StringProperty::Pointer baseDataNameProp = dynamic_cast<mitk::StringProperty*>(node->GetData()->GetProperty("name").GetPointer() );
     if(baseDataNameProp.IsNull() || (strcmp(baseDataNameProp->GetValue(),"No Name!")==0))
     {
       // name neither defined in node, nor in BaseData -> name = filename
       if (FileNameEndsWith( ".gz" ))
         m_FileName = m_FileName.substr( 0, m_FileName.length()-3 );
 
       nameProp = mitk::StringProperty::New( itksys::SystemTools::GetFilenameWithoutLastExtension( m_FileName ) );
 
       node->SetProperty( "name", nameProp );
     }
     else
     {
       // name defined in BaseData!
       nameProp = mitk::StringProperty::New( baseDataNameProp->GetValue() );
       node->SetProperty( "name", nameProp );
     }
   }
 
   // visibility
   if(!node->GetProperty("visible"))
     node->SetVisibility(true);
 }
 
diff --git a/Core/Code/IO/mitkImageWriter.cpp b/Core/Code/IO/mitkImageWriter.cpp
index 03efccd907..e6e5a66c15 100644
--- a/Core/Code/IO/mitkImageWriter.cpp
+++ b/Core/Code/IO/mitkImageWriter.cpp
@@ -1,490 +1,490 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkImageWriter.h"
 
 #include "mitkItkPictureWrite.h"
 #include "mitkImage.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageReadAccessor.h"
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 mitk::ImageWriter::ImageWriter()
 {
    this->SetNumberOfRequiredInputs( 1 );
    m_MimeType = "";
    SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetFileName(const char* fileName)
 {
    if ( fileName && ( fileName == this->m_FileName ) )
    {
       return;
    }
    if ( fileName )
    {
       this->m_FileName = fileName;
       this->m_FileNameWithoutExtension = this->m_FileName;
       this->m_Extension.clear();
       std::size_t pos = this->m_FileName.find_last_of("/\\");
       if (pos != std::string::npos)
       {
          std::size_t ppos = this->m_FileName.find_first_of('.', pos);
          if (ppos != std::string::npos)
          {
             this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
             this->m_Extension = this->m_FileName.substr(ppos);
          }
       }
    }
    else
    {
       this->m_FileName.clear();
       this->m_FileNameWithoutExtension.clear();
       this->m_Extension.clear();
    }
    this->Modified();
 }
 
 void mitk::ImageWriter::SetFileName(const std::string & fileName)
 {
    this->SetFileName( fileName.c_str() );
 }
 
 void mitk::ImageWriter::SetExtension(const char* extension)
 {
    if ( extension && ( extension == this->m_Extension ) )
    {
       return;
    }
    if ( extension )
    {
       this->m_Extension = extension;
       this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
    }
    else
    {
       this->m_Extension.clear();
       this->m_FileName = this->m_FileNameWithoutExtension;
    }
    this->Modified();
 }
 
 void mitk::ImageWriter::SetExtension(const std::string & extension)
 {
    this->SetFileName( extension.c_str() );
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
    this->m_Extension = ".mhd";
    this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
    this->Modified();
 }
 
 #include <vtkConfigure.h>
 #include <vtkImageData.h>
 #include <vtkXMLImageDataWriter.h>
 static void writeVti(const char * filename, mitk::Image* image, int t=0)
 {
    vtkXMLImageDataWriter * vtkwriter = vtkXMLImageDataWriter::New();
    vtkwriter->SetFileName( filename );
    vtkwriter->SetInputData(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 || fileName.find(".bmp") != std::string::npos)
    {
       try
       {
          // switch processing of single/multi-component images
          if( image->GetPixelType(0).GetNumberOfComponents() == 1)
          {
             AccessByItk_1( image, _mitkItkPictureWrite, fileName );
          }
          else
          {
             AccessFixedPixelTypeByItk_1( image, _mitkItkPictureWriteComposite, MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ , fileName);
          }
       }
       catch(itk::ExceptionObject &e)
       {
          std::cerr << "Caught " << e.what() << std::endl;
       }
       catch(std::exception &e)
       {
          std::cerr << "Caught std::exception " << e.what() << std::endl;
       }
 
       return;
    }
 
    // Implementation of writer using itkImageIO directly. This skips the use
    // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
    unsigned int dimension = image->GetDimension();
    unsigned int* dimensions = image->GetDimensions();
    mitk::PixelType pixelType = image->GetPixelType();
    mitk::Vector3D mitkSpacing = image->GetGeometry()->GetSpacing();
    mitk::Point3D mitkOrigin = image->GetGeometry()->GetOrigin();
 
    // Due to templating in itk, we are forced to save a 4D spacing and 4D Origin, though they are not supported in MITK
    itk::Vector<double, 4u> spacing4D;
    spacing4D[0] = mitkSpacing[0];
    spacing4D[1] = mitkSpacing[1];
    spacing4D[2] = mitkSpacing[2];
    spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have an valid value here
 
    itk::Vector<double, 4u> origin4D;
    origin4D[0] = mitkOrigin[0];
    origin4D[1] = mitkOrigin[1];
    origin4D[2] = mitkOrigin[2];
    origin4D[3] = 0; // There is no support for a 4D origin. However, we should have an valid value here
 
    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,spacing4D[i]);
       imageIO->SetOrigin(i,origin4D[i]);
 
       mitk::Vector3D mitkDirection;
       mitkDirection.SetVnlVector(image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
       itk::Vector<double, 4u> direction4D;
       direction4D[0] = mitkDirection[0];
       direction4D[1] = mitkDirection[1];
       direction4D[2] = mitkDirection[2];
 
       // MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
       // save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
       if (i == 3)
          direction4D[3] = 1; // homogenous component
       else
          direction4D[3] = 0;
 
       vnl_vector< double > axisDirection(dimension);
       for(unsigned int j=0; j<dimension; j++)
       {
          axisDirection[j] = direction4D[j]/spacing4D[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->GetTimeGeometry()->IsValidTimeStep(t))
             {
                const mitk::TimeBounds& timebounds = input->GetTimeGeometry()->GetGeometryForTimeStep(t)->GetTimeBounds();
                filename <<  m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
             }
             else
             {
-               itkWarningMacro(<<"Error on write: TimeGeometry invalid of image " << filename << ".");
+               itkWarningMacro(<<"Error on write: TimeGeometry invalid of image " << filename.str() << ".");
                filename <<  m_FileNameWithoutExtension << "_T" << t << m_Extension;
             }
             if ( vti )
             {
                writeVti(filename.str().c_str(), input, t);
             }
             else
             {
                WriteByITK(image, filename.str());
             }
          }
       }
       else if ( vti )
       {
          writeVti(m_FileName.c_str(), input);
       }
       else
       {
          WriteByITK(input, m_FileName);
       }
    }
    else
    {
       // use the PicFileWriter for the .pic data type
       if( m_Extension.find(".pic") != std::string::npos )
       {
          /*    PicFileWriter::Pointer picWriter = PicFileWriter::New();
          size_t found;
          found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
          if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
          {
          //if Extension not in Filename
          std::ostringstream filename;
          filename <<  m_FileName.c_str() << m_Extension;
          picWriter->SetFileName( filename.str().c_str() );
          }
          else
          {
          picWriter->SetFileName( m_FileName.c_str() );
          }
          picWriter->SetInputImage( input );
          picWriter->Write();
          */    }
 
       // use the ITK .nrrd Image writer
       if( m_Extension.find(".nrrd") != std::string::npos
          || m_Extension.find(".nii") != std::string::npos
          || m_Extension.find(".nii.gz") != std::string::npos
          )
       {
          WriteByITK(input, this->m_FileName);
       }
    }
    m_MimeType = "application/MITK.Pic";
 
    try
    {
       setlocale(LC_ALL, currLocale.c_str());
    }
    catch(...)
    {
       MITK_INFO << "Could not reset locale " << currLocale;
    }
 }
 
 bool mitk::ImageWriter::CanWriteDataType( DataNode* input )
 {
    if ( input )
    {
       return this->CanWriteBaseDataType(input->GetData());
    }
    return false;
 }
 
 void mitk::ImageWriter::SetInput( DataNode* input )
 {
    if( input && CanWriteDataType( input ) )
       this->ProcessObject::SetNthInput( 0, dynamic_cast<mitk::Image*>( input->GetData() ) );
 }
 
 std::string mitk::ImageWriter::GetWritenMIMEType()
 {
    return m_MimeType;
 }
 
 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
 {
    std::vector<std::string> possibleFileExtensions;
    possibleFileExtensions.push_back(".pic");
    possibleFileExtensions.push_back(".pic.gz");
    possibleFileExtensions.push_back(".bmp");
    possibleFileExtensions.push_back(".dcm");
    possibleFileExtensions.push_back(".DCM");
    possibleFileExtensions.push_back(".dicom");
    possibleFileExtensions.push_back(".DICOM");
    possibleFileExtensions.push_back(".gipl");
    possibleFileExtensions.push_back(".gipl.gz");
    possibleFileExtensions.push_back(".mha");
    possibleFileExtensions.push_back(".nii");
    possibleFileExtensions.push_back(".nii.gz");
    possibleFileExtensions.push_back(".nrrd");
    possibleFileExtensions.push_back(".nhdr");
    possibleFileExtensions.push_back(".png");
    possibleFileExtensions.push_back(".PNG");
    possibleFileExtensions.push_back(".spr");
    possibleFileExtensions.push_back(".mhd");
    possibleFileExtensions.push_back(".vtk");
    possibleFileExtensions.push_back(".vti");
    possibleFileExtensions.push_back(".hdr");
    possibleFileExtensions.push_back(".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 ) );
    }
 }
 
 const char* mitk::ImageWriter::GetDefaultFilename()
 {
    return "Image.nrrd";
 }
 
 const char* mitk::ImageWriter::GetFileDialogPattern()
 {
    return
       "Nearly Raw Raster Data (*.nrrd);;"
       "NIfTI format (*.nii *.nii.gz);;"
       "VTK Image Data Files (*.vti);;"
       "NRRD with detached header (*.nhdr);;"
       "Analyze Format (*.hdr);;"
       "MetaImage (*.mhd);;"
       "Sets of 2D slices (*.png *.tiff *.jpg *.jpeg *.bmp);;"
       "DICOM (*.dcm *.DCM *.dicom *.DICOM);;"
       "UMDS GIPL Format Files (*.gipl *.gipl.gz)";
 }
 
 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();
    }
 }
\ No newline at end of file
diff --git a/Core/Code/IO/mitkSurfaceVtkWriter.txx b/Core/Code/IO/mitkSurfaceVtkWriter.txx
index 91521b6a1f..9fc7fe2c25 100644
--- a/Core/Code/IO/mitkSurfaceVtkWriter.txx
+++ b/Core/Code/IO/mitkSurfaceVtkWriter.txx
@@ -1,174 +1,174 @@
 /*===================================================================
 
 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 "mitkSurfaceVtkWriter.h"
 #include <vtkConfigure.h>
 #include <vtkPolyData.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkErrorCode.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter()
 : m_WriterWriteHasReturnValue( false )
 {
   this->SetNumberOfRequiredInputs( 1 );
 
   m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
 
   //enable to write ascii-formatted-file
   //m_VtkWriter->SetFileTypeToASCII();
 
   SetDefaultExtension(); // and information about the Writer's Write() method
 }
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
 {
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
 {
   m_Extension = ".vtk";
 }
 
 template<class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite( VtkWriterType* vtkWriter )
 {
   if ( vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0 )
   {
     itkExceptionMacro(<<"Error during surface writing: " << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()) );
   }
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
 {
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::Surface::Pointer input = const_cast<mitk::Surface*>(this->GetInput());
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   vtkPolyData * polyData;
   Geometry3D* geometry;
 
   unsigned int t, timesteps = input->GetTimeGeometry()->CountTimeSteps();
 
   for(t = 0; t < timesteps; ++t)
   {
     // surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
     if( input->GetVtkPolyData(t) == NULL ) continue;
 
     std::ostringstream filename;
     filename.imbue(::std::locale::classic());
     geometry = input->GetGeometry(t);
     if ( timesteps > 1 )
     {
       if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const TimeBounds& timebounds = geometry->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: TimeGeometry invalid of surface " << filename << ".");
+        itkWarningMacro(<<"Error on write: TimeGeometry invalid of surface " << filename.str() << ".");
         filename <<  m_FileName.c_str() << "_T" << t << m_Extension;
       }
       m_VtkWriter->SetFileName(filename.str().c_str());
     }
     else
       m_VtkWriter->SetFileName(m_FileName.c_str());
 
     geometry->TransferItkToVtkTransform();
     transformPolyData->SetInputData(input->GetVtkPolyData(t));
     transformPolyData->SetTransform(geometry->GetVtkTransform());
     transformPolyData->UpdateWholeExtent();
     polyData = transformPolyData->GetOutput();
 
     m_VtkWriter->SetInputData(polyData);
 
     ExecuteWrite( m_VtkWriter );
   }
 
   m_MimeType = "application/MITK.Surface";
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( mitk::Surface* surface )
 {
   this->ProcessObject::SetNthInput( 0, surface );
 }
 
 template <class VTKWRITER>
 const mitk::Surface* mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
 {
   if ( this->GetNumberOfInputs() < 1 )
   {
     return NULL;
   }
   else
   {
     return static_cast< const Surface * >( this->ProcessObject::GetInput( 0 ) );
   }
 }
 
 template <class VTKWRITER>
 bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType( DataNode* input )
 {
   if ( input )
   {
     BaseData* data = input->GetData();
     if ( data )
     {
       Surface::Pointer surface = dynamic_cast<Surface*>( data );
       if( surface.IsNotNull() )
       {
         SetDefaultExtension();
         return true;
       }
     }
   }
   return false;
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput( DataNode* input )
 {
   if( input && CanWriteDataType( input ) )
     SetInput( dynamic_cast<Surface*>( input->GetData() ) );
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
 {
   return m_Extension;
 }
diff --git a/Modules/Ext/IO/mitkUnstructuredGridVtkWriter.txx b/Modules/Ext/IO/mitkUnstructuredGridVtkWriter.txx
index a09db5110a..c4890229c4 100644
--- a/Modules/Ext/IO/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/Ext/IO/mitkUnstructuredGridVtkWriter.txx
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 #define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 
 #include <itkLightObject.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformFilter.h>
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 namespace mitk {
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter()
   : m_Success(false)
 {
   this->SetNumberOfRequiredInputs(1);
 }
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
 {
 
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
 {
   m_Success = false;
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid*>(this->GetInput());
 
   if (input.IsNull())
   {
     itkWarningMacro( << "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
     return;
   }
 
   VTKWRITER* unstructuredGridWriter = VTKWRITER::New();
   vtkTransformFilter* transformPointSet = vtkTransformFilter::New();
   vtkUnstructuredGrid * unstructuredGrid;
   Geometry3D* geometry;
 
   if(input->GetTimeGeometry()->CountTimeSteps()>1)
   {
 
     int t, timesteps;
 
     timesteps = input->GetTimeGeometry()->CountTimeSteps();
     for(t = 0; t < timesteps; ++t)
     {
       std::ostringstream filename;
       geometry = input->GetGeometry(t);
       if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const mitk::TimeBounds& timebounds = geometry->GetTimeBounds();
         filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
       }
       else
       {
-        itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename << ".");
+        itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename.str() << ".");
         filename <<  m_FileName.c_str() << "_T" << t << GetDefaultExtension();
       }
       geometry->TransferItkToVtkTransform();
       transformPointSet->SetInputData(input->GetVtkUnstructuredGrid(t));
       transformPointSet->SetTransform(geometry->GetVtkTransform());
       transformPointSet->UpdateWholeExtent();
       unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
       unstructuredGridWriter->SetFileName(filename.str().c_str());
       unstructuredGridWriter->SetInputData(unstructuredGrid);
 
       ExecuteWrite( unstructuredGridWriter );
     }
   }
   else
   {
     geometry = input->GetGeometry();
     geometry->TransferItkToVtkTransform();
     transformPointSet->SetInputData(input->GetVtkUnstructuredGrid());
     transformPointSet->SetTransform(geometry->GetVtkTransform());
     transformPointSet->UpdateWholeExtent();
     unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
     unstructuredGridWriter->SetFileName(m_FileName.c_str());
     unstructuredGridWriter->SetInputData(unstructuredGrid);
 
     ExecuteWrite( unstructuredGridWriter );
   }
   transformPointSet->Delete();
   unstructuredGridWriter->Delete();
 
   m_Success = true;
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite( VTKWRITER* vtkWriter )
 {
   struct stat fileStatus;
   time_t timeBefore=0;
   if (!stat(vtkWriter->GetFileName(), &fileStatus))
   {
     timeBefore = fileStatus.st_mtime;
   }
   if (!vtkWriter->Write())
   {
     itkExceptionMacro( << "Error during unstructured grid writing.");
   }
 
   // check if file can be written because vtkWriter doesn't check that
   if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
   {
     itkExceptionMacro(<<"Error during unstructured grid writing: file could not be written");
   }
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
 {
   this->ProcessObject::SetNthInput(0, input);
 }
 
 template<class VTKWRITER>
 const UnstructuredGrid* UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
   else
   {
     return dynamic_cast<UnstructuredGrid*>(this->ProcessObject::GetInput(0));
   }
 }
 
 template<class VTKWRITER>
 bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return (dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()) != 0);
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
 {
   if (CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()));
     this->Update();
   }
 }
 
 template<class VTKWRITER>
 std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
 {
   throw std::exception(); // no specialization available!
 }
 
 }
 
 #endif
diff --git a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
index a09db5110a..c4890229c4 100644
--- a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
@@ -1,205 +1,205 @@
 /*===================================================================
 
 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_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 #define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 
 #include <itkLightObject.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformFilter.h>
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 
 #include <sstream>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <stdio.h>
 
 namespace mitk {
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter()
   : m_Success(false)
 {
   this->SetNumberOfRequiredInputs(1);
 }
 
 template<class VTKWRITER>
 UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
 {
 
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
 {
   m_Success = false;
   if ( m_FileName == "" )
   {
     itkWarningMacro( << "Sorry, filename has not been set!" );
     return ;
   }
 
   mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid*>(this->GetInput());
 
   if (input.IsNull())
   {
     itkWarningMacro( << "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
     return;
   }
 
   VTKWRITER* unstructuredGridWriter = VTKWRITER::New();
   vtkTransformFilter* transformPointSet = vtkTransformFilter::New();
   vtkUnstructuredGrid * unstructuredGrid;
   Geometry3D* geometry;
 
   if(input->GetTimeGeometry()->CountTimeSteps()>1)
   {
 
     int t, timesteps;
 
     timesteps = input->GetTimeGeometry()->CountTimeSteps();
     for(t = 0; t < timesteps; ++t)
     {
       std::ostringstream filename;
       geometry = input->GetGeometry(t);
       if(input->GetTimeGeometry()->IsValidTimeStep(t))
       {
         const mitk::TimeBounds& timebounds = geometry->GetTimeBounds();
         filename <<  m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
       }
       else
       {
-        itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename << ".");
+        itkWarningMacro(<<"Error on write: TimeGeometry invalid of unstructured grid " << filename.str() << ".");
         filename <<  m_FileName.c_str() << "_T" << t << GetDefaultExtension();
       }
       geometry->TransferItkToVtkTransform();
       transformPointSet->SetInputData(input->GetVtkUnstructuredGrid(t));
       transformPointSet->SetTransform(geometry->GetVtkTransform());
       transformPointSet->UpdateWholeExtent();
       unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
       unstructuredGridWriter->SetFileName(filename.str().c_str());
       unstructuredGridWriter->SetInputData(unstructuredGrid);
 
       ExecuteWrite( unstructuredGridWriter );
     }
   }
   else
   {
     geometry = input->GetGeometry();
     geometry->TransferItkToVtkTransform();
     transformPointSet->SetInputData(input->GetVtkUnstructuredGrid());
     transformPointSet->SetTransform(geometry->GetVtkTransform());
     transformPointSet->UpdateWholeExtent();
     unstructuredGrid = static_cast<vtkUnstructuredGrid*>(transformPointSet->GetOutput());
 
     unstructuredGridWriter->SetFileName(m_FileName.c_str());
     unstructuredGridWriter->SetInputData(unstructuredGrid);
 
     ExecuteWrite( unstructuredGridWriter );
   }
   transformPointSet->Delete();
   unstructuredGridWriter->Delete();
 
   m_Success = true;
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite( VTKWRITER* vtkWriter )
 {
   struct stat fileStatus;
   time_t timeBefore=0;
   if (!stat(vtkWriter->GetFileName(), &fileStatus))
   {
     timeBefore = fileStatus.st_mtime;
   }
   if (!vtkWriter->Write())
   {
     itkExceptionMacro( << "Error during unstructured grid writing.");
   }
 
   // check if file can be written because vtkWriter doesn't check that
   if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
   {
     itkExceptionMacro(<<"Error during unstructured grid writing: file could not be written");
   }
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
 {
   this->ProcessObject::SetNthInput(0, input);
 }
 
 template<class VTKWRITER>
 const UnstructuredGrid* UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return 0;
   }
   else
   {
     return dynamic_cast<UnstructuredGrid*>(this->ProcessObject::GetInput(0));
   }
 }
 
 template<class VTKWRITER>
 bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return (dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()) != 0);
 }
 
 template<class VTKWRITER>
 void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
 {
   if (CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::UnstructuredGrid*>(data.GetPointer()));
     this->Update();
   }
 }
 
 template<class VTKWRITER>
 std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
 {
   throw std::exception(); // no specialization available!
 }
 
 template<class VTKWRITER>
 const char* UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
 {
   throw std::exception(); // no specialization available!
 }
 
 }
 
 #endif
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarDoubleEllipse.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarDoubleEllipse.cpp
index 35c6e366d5..22fb6754d0 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarDoubleEllipse.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarDoubleEllipse.cpp
@@ -1,249 +1,251 @@
 /*===================================================================
 
 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 "mitkPlanarDoubleEllipse.h"
 #include <mitkProperties.h>
 
+#include <algorithm>
+
 mitk::PlanarDoubleEllipse::PlanarDoubleEllipse()
   : FEATURE_ID_MAJOR_AXIS(Superclass::AddFeature("Major Axis", "mm")),
     FEATURE_ID_MINOR_AXIS(Superclass::AddFeature("Minor Axis", "mm")),
     FEATURE_ID_THICKNESS(Superclass::AddFeature("Thickness", "mm")),
     m_NumberOfSegments(64),
     m_ConstrainCircle(true),
     m_ConstrainThickness(true)
 {
   this->ResetNumberOfControlPoints(4);
   this->SetNumberOfPolyLines(2);
   this->SetProperty("closed", mitk::BoolProperty::New(true));
 }
 
 mitk::PlanarDoubleEllipse::~PlanarDoubleEllipse()
 {
 }
 
 mitk::Point2D mitk::PlanarDoubleEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D& point)
 {
   if (index == 2 && !m_ConstrainCircle)
   {
     Point2D centerPoint = this->GetControlPoint(0);
     Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint;
 
     Vector2D minorDirection;
     minorDirection[0] = outerMajorVector[1];
     minorDirection[1] = -outerMajorVector[0];
     minorDirection.Normalize();
 
     double outerMajorRadius = outerMajorVector.GetNorm();
     double innerMajorRadius = (this->GetControlPoint(3) - centerPoint).GetNorm();
     ScalarType radius = std::max(outerMajorRadius - innerMajorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius));
 
     return centerPoint + minorDirection * radius;
   }
   else if (index == 3 && !m_ConstrainThickness)
   {
     Point2D centerPoint = this->GetControlPoint(0);
     Vector2D outerMajorVector = this->GetControlPoint(1) - centerPoint;
 
     double outerMajorRadius = outerMajorVector.GetNorm();
     double outerMinorRadius = (this->GetControlPoint(2) - centerPoint).GetNorm();
     ScalarType radius = std::max(outerMajorRadius - outerMinorRadius, std::min(centerPoint.EuclideanDistanceTo(point), outerMajorRadius));
 
     outerMajorVector.Normalize();
 
     return centerPoint - outerMajorVector * radius;
   }
 
   return point;
 }
 
 void mitk::PlanarDoubleEllipse::EvaluateFeaturesInternal()
 {
   Point2D centerPoint = this->GetControlPoint(0);
   ScalarType outerMajorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(1));
 
   this->SetQuantity(FEATURE_ID_MAJOR_AXIS, 2 * outerMajorRadius);
   this->SetQuantity(FEATURE_ID_MINOR_AXIS, 2 * centerPoint.EuclideanDistanceTo(this->GetControlPoint(2)));
   this->SetQuantity(FEATURE_ID_THICKNESS, outerMajorRadius - centerPoint.EuclideanDistanceTo(this->GetControlPoint(3)));
 }
 
 void mitk::PlanarDoubleEllipse::GenerateHelperPolyLine(double, unsigned int)
 {
 }
 
 void mitk::PlanarDoubleEllipse::GeneratePolyLine()
 {
   this->ClearPolyLines();
 
   Point2D centerPoint = this->GetControlPoint(0);
   Point2D outerMajorPoint = this->GetControlPoint(1);
 
   Vector2D direction = outerMajorPoint - centerPoint;
   direction.Normalize();
 
   const ScalarType deltaAngle = vnl_math::pi / (m_NumberOfSegments / 2);
 
   int start = 0;
   int end = m_NumberOfSegments;
 
   if (direction[1] < 0.0)
   {
     direction[0] = -direction[0];
     end = m_NumberOfSegments / 2;
     start = -end;
   }
 
   vnl_matrix_fixed<mitk::ScalarType, 2, 2> rotation;
   rotation[1][0] = std::sin(std::acos(direction[0]));
   rotation[0][0] = direction[0];
   rotation[1][1] = direction[0];
   rotation[0][1] = -rotation[1][0];
 
   ScalarType outerMajorRadius = centerPoint.EuclideanDistanceTo(outerMajorPoint);
   ScalarType outerMinorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
   ScalarType innerMajorRadius = centerPoint.EuclideanDistanceTo(this->GetControlPoint(3));
   ScalarType innerMinorRadius = innerMajorRadius - (outerMajorRadius - outerMinorRadius);
 
   ScalarType angle;
   ScalarType cosAngle;
   ScalarType sinAngle;
   vnl_vector_fixed<mitk::ScalarType, 2> vector;
   Point2D point;
 
   for (int i = start; i < end; ++i)
   {
     angle = i * deltaAngle;
     cosAngle = std::cos(angle);
     sinAngle = std::sin(angle);
 
     vector[0] = outerMajorRadius * cosAngle;
     vector[1] = outerMinorRadius * sinAngle;
     vector = rotation * vector;
 
     point[0] = centerPoint[0] + vector[0];
     point[1] = centerPoint[1] + vector[1];
 
     this->AppendPointToPolyLine(0, PolyLineElement(point, 0));
 
     vector[0] = innerMajorRadius * cosAngle;
     vector[1] = innerMinorRadius * sinAngle;
     vector = rotation * vector;
 
     point[0] = centerPoint[0] + vector[0];
     point[1] = centerPoint[1] + vector[1];
 
     this->AppendPointToPolyLine(1, PolyLineElement(point, 0));
   }
 }
 
 unsigned int mitk::PlanarDoubleEllipse::GetNumberOfSegments() const
 {
   return m_NumberOfSegments;
 }
 
 void mitk::PlanarDoubleEllipse::SetNumberOfSegments(unsigned int numSegments)
 {
   m_NumberOfSegments = std::max(4U, numSegments);
 
   if (this->IsPlaced())
   {
     this->GeneratePolyLine();
     this->Modified();
   }
 }
 
 unsigned int mitk::PlanarDoubleEllipse::GetMaximumNumberOfControlPoints() const
 {
   return 4;
 }
 
 unsigned int mitk::PlanarDoubleEllipse::GetMinimumNumberOfControlPoints() const
 {
   return 4;
 }
 
 bool mitk::PlanarDoubleEllipse::SetControlPoint(unsigned int index, const Point2D& point, bool createIfDoesNotExist)
 {
   switch (index)
   {
     case 0:
     {
       Point2D centerPoint = this->GetControlPoint(0);
       Vector2D vector = point - centerPoint;
 
       Superclass::SetControlPoint(0, point, createIfDoesNotExist);
       Superclass::SetControlPoint(1, this->GetControlPoint(1) + vector, createIfDoesNotExist);
       Superclass::SetControlPoint(2, this->GetControlPoint(2) + vector, createIfDoesNotExist);
       Superclass::SetControlPoint(3, this->GetControlPoint(3) + vector, createIfDoesNotExist);
 
       break;
     }
 
     case 1:
     {
       Vector2D vector = point - this->GetControlPoint(1);
 
       Superclass::SetControlPoint(1, point, createIfDoesNotExist);
 
       Point2D centerPoint = this->GetControlPoint(0);
       Vector2D outerMajorVector = point - centerPoint;
 
       Vector2D outerMinorVector;
       outerMinorVector[0] = outerMajorVector[1];
       outerMinorVector[1] = -outerMajorVector[0];
 
       if (!m_ConstrainCircle)
       {
         outerMinorVector.Normalize();
         outerMinorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
       }
 
       Superclass::SetControlPoint(2, centerPoint + outerMinorVector, createIfDoesNotExist);
 
       Vector2D innerMajorVector = outerMajorVector;
 
       if (!m_ConstrainThickness)
       {
         innerMajorVector.Normalize();
         innerMajorVector *= centerPoint.EuclideanDistanceTo(this->GetControlPoint(3) - vector);
       }
 
       Superclass::SetControlPoint(3, centerPoint - innerMajorVector, createIfDoesNotExist);
 
       break;
     }
 
     case 2:
     {
       m_ConstrainCircle = false;
       Superclass::SetControlPoint(2, point, createIfDoesNotExist);
 
       break;
     }
 
     case 3:
     {
       m_ConstrainThickness = false;
       Superclass::SetControlPoint(3, point, createIfDoesNotExist);
 
       break;
     }
 
     default:
       return false;
   }
 
   return true;
 }
diff --git a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
index 0a766813e3..ac13384947 100644
--- a/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
+++ b/Modules/PlanarFigure/DataManagement/mitkPlanarEllipse.cpp
@@ -1,273 +1,275 @@
 /*===================================================================
 
 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 <algorithm>
 
 #include "mitkPlanarEllipse.h"
 #include "mitkGeometry2D.h"
 #include "mitkProperties.h"
 
+#include <algorithm>
 
 mitk::PlanarEllipse::PlanarEllipse()
     : m_MinRadius(0),
       m_MaxRadius(100),
       m_MinMaxRadiusContraintsActive(false),
       m_TreatAsCircle(true)
 {
     // Ellipse has three control points
     this->ResetNumberOfControlPoints( 4 );
     this->SetNumberOfPolyLines( 2 );
     this->SetProperty( "closed", mitk::BoolProperty::New(true) );
 }
 
 
 mitk::PlanarEllipse::~PlanarEllipse()
 {
 }
 
 bool mitk::PlanarEllipse::SetControlPoint( unsigned int index, const Point2D &point, bool createIfDoesNotExist )
 {
     if(index == 0) // moving center point and control points accordingly
     {
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D boundaryPoint1 = GetControlPoint( 1 );
         Point2D boundaryPoint2 = GetControlPoint( 2 );
         Point2D boundaryPoint3 = GetControlPoint( 3 );
         vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
 
         boundaryPoint1[0] += vec[0];
         boundaryPoint1[1] += vec[1];
         boundaryPoint2[0] += vec[0];
         boundaryPoint2[1] += vec[1];
         boundaryPoint3[0] += vec[0];
         boundaryPoint3[1] += vec[1];
         PlanarFigure::SetControlPoint( 0, point, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 1, boundaryPoint1, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 2, boundaryPoint2, createIfDoesNotExist );
         PlanarFigure::SetControlPoint( 3, boundaryPoint3, createIfDoesNotExist );
         return true;
     }
     else if (index < 3)
     {
         PlanarFigure::SetControlPoint( index, point, createIfDoesNotExist );
         int otherIndex = index+1;
         if (otherIndex > 2)
             otherIndex = 1;
 
         const Point2D &centerPoint = GetControlPoint( 0 );
         Point2D otherPoint = GetControlPoint( otherIndex );
         Point2D point3 = GetControlPoint( 3 );
 
         Vector2D vec1 = point - centerPoint;
         Vector2D vec2;
 
         if (index == 1 && m_TreatAsCircle )
         {
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             otherPoint = centerPoint+vec2;
             PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
 
             // adjust additional third control point
             Point2D p3 = this->GetControlPoint(3);
             Vector2D vec3;
             vec3[0] = p3[0]-centerPoint[0];
             vec3[1] = p3[1]-centerPoint[1];
             if (vec3[0]!=0 || vec3[1]!=0)
             {
                 vec3.Normalize();
                 vec3 *= r;
             }
             else
             {
                 vec3[0] = r;
                 vec3[1] = 0;
             }
             point3 = centerPoint + vec3;
             PlanarFigure::SetControlPoint( 3, point3, createIfDoesNotExist );
         }
         else if ( vec1.GetNorm() > 0 )
         {
             float r = centerPoint.EuclideanDistanceTo(otherPoint);
             float x = vec1[0];
             vec2[0] = vec1[1];
             vec2[1] = x;
 
             if (index==1)
                 vec2[0] *= -1;
             else
                 vec2[1] *= -1;
 
             vec2.Normalize(); vec2 *= r;
 
             if ( vec2.GetNorm() > 0 )
             {
                 otherPoint = centerPoint+vec2;
                 PlanarFigure::SetControlPoint( otherIndex, otherPoint, createIfDoesNotExist );
             }
 
             // adjust third control point
             Vector2D vec3 = point3 - centerPoint; vec3.Normalize();
             double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
             double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
             Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
             PlanarFigure::SetControlPoint( 3, newPoint, createIfDoesNotExist );
 
             m_TreatAsCircle = false;
         }
         return true;
     }
     else if (index == 3)
     {
         Point2D centerPoint = GetControlPoint( 0 );
         Vector2D vec3 = point - centerPoint; vec3.Normalize();
         double r1 = centerPoint.EuclideanDistanceTo( GetControlPoint( 1 ) );
         double r2 = centerPoint.EuclideanDistanceTo( GetControlPoint( 2 ) );
         Point2D newPoint = centerPoint + vec3*std::max(r1, r2);
         PlanarFigure::SetControlPoint( index, newPoint, createIfDoesNotExist );
         m_TreatAsCircle = false;
         return true;
     }
     return false;
 }
 
 void mitk::PlanarEllipse::PlaceFigure( const mitk::Point2D &point )
 {
     PlanarFigure::PlaceFigure( point );
     m_SelectedControlPoint = 1;
 }
 
 mitk::Point2D mitk::PlanarEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
 {
     return point;
 
     Point2D indexPoint;
     this->GetGeometry2D()->WorldToIndex( point, indexPoint );
 
     BoundingBox::BoundsArrayType bounds = this->GetGeometry2D()->GetBounds();
     if ( indexPoint[0] < bounds[0] ) { indexPoint[0] = bounds[0]; }
     if ( indexPoint[0] > bounds[1] ) { indexPoint[0] = bounds[1]; }
     if ( indexPoint[1] < bounds[2] ) { indexPoint[1] = bounds[2]; }
     if ( indexPoint[1] > bounds[3] ) { indexPoint[1] = bounds[3]; }
 
     Point2D constrainedPoint;
     this->GetGeometry2D()->IndexToWorld( indexPoint, constrainedPoint );
 
     if(m_MinMaxRadiusContraintsActive)
     {
         if( index != 0)
         {
             const Point2D &centerPoint = this->GetControlPoint(0);
             double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
 
             Vector2D vectorProjectedPoint;
             vectorProjectedPoint = point - centerPoint;
             vectorProjectedPoint.Normalize();
 
             if( euclideanDinstanceFromCenterToPoint1 > m_MaxRadius )
             {
                 vectorProjectedPoint *= m_MaxRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
             else if( euclideanDinstanceFromCenterToPoint1 < m_MinRadius )
             {
                 vectorProjectedPoint *= m_MinRadius;
                 constrainedPoint = centerPoint;
                 constrainedPoint += vectorProjectedPoint;
             }
         }
     }
 
     return constrainedPoint;
 }
 
 void mitk::PlanarEllipse::GeneratePolyLine()
 {
     // clear the PolyLine-Contrainer, it will be reconstructed soon enough...
     this->ClearPolyLines();
 
     const Point2D &centerPoint = GetControlPoint( 0 );
     const Point2D &boundaryPoint1 = GetControlPoint( 1 );
     const Point2D &boundaryPoint2 = GetControlPoint( 2 );
 
     Vector2D dir = boundaryPoint1 - centerPoint; dir.Normalize();
     vnl_matrix_fixed<float, 2, 2> rot;
 
     // differentiate between clockwise and counterclockwise rotation
     int start = 0;
     int end = 64;
     if (dir[1]<0)
     {
         dir[0] = -dir[0];
         start = -32;
         end = 32;
     }
     // construct rotation matrix to align ellipse with control point vector
     rot[0][0] = dir[0];
     rot[1][1] = rot[0][0];
     rot[1][0] = sin(acos(rot[0][0]));
     rot[0][1] = -rot[1][0];
 
     double radius1 = centerPoint.EuclideanDistanceTo( boundaryPoint1 );
     double radius2 = centerPoint.EuclideanDistanceTo( boundaryPoint2 );
 
     // Generate poly-line with 64 segments
     for ( int t = start; t < end; ++t )
     {
         double alpha = (double) t * vnl_math::pi / 32.0;
 
         // construct the new polyline point ...
         vnl_vector_fixed< float, 2 > vec;
         vec[0] = radius1 * cos( alpha );
         vec[1] = radius2 * sin( alpha );
         vec = rot*vec;
 
         Point2D polyLinePoint;
         polyLinePoint[0] = centerPoint[0] + vec[0];
         polyLinePoint[1] = centerPoint[1] + vec[1];
 
         // ... and append it to the PolyLine.
         // No extending supported here, so we can set the index of the PolyLineElement to '0'
         AppendPointToPolyLine( 0, PolyLineElement( polyLinePoint, 0 ) );
     }
 
     AppendPointToPolyLine( 1, PolyLineElement( centerPoint, 0 ) );
     AppendPointToPolyLine( 1, PolyLineElement( GetControlPoint( 3 ), 0 ) );
 }
 
 void mitk::PlanarEllipse::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
 {
     // A circle does not require a helper object
 }
 
 void mitk::PlanarEllipse::EvaluateFeaturesInternal()
 {
 
 }
 
 
 void mitk::PlanarEllipse::PrintSelf( std::ostream& os, itk::Indent indent) const
 {
     Superclass::PrintSelf( os, indent );
 }