diff --git a/Core/Code/IO/mitkLocaleSwitch.h b/Core/Code/IO/mitkLocaleSwitch.h
new file mode 100644
index 0000000000..45f907c892
--- /dev/null
+++ b/Core/Code/IO/mitkLocaleSwitch.h
@@ -0,0 +1,60 @@
+/*===================================================================
+
+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 MITKLOCALESWITCH_H_
+#define MITKLOCALESWITCH_H_
+
+#include <MitkCoreExports.h>
+#include <clocale>
+
+namespace mitk {
+
+struct MITK_CORE_EXPORT LocaleSwitch
+{
+  LocaleSwitch(const std::string& newLocale)
+    : m_OldLocale(std::setlocale(LC_ALL, NULL))
+    , m_NewLocale(newLocale)
+  {
+    if (m_OldLocale == NULL)
+    {
+      m_OldLocale = "";
+    }
+    else if (m_NewLocale != m_OldLocale)
+    {
+      // set the locale
+      if (std::setlocale(LC_ALL, m_NewLocale.c_str()) == NULL)
+      {
+        MITK_INFO << "Could not set locale " << m_NewLocale;
+        m_OldLocale = NULL;
+      }
+    }
+  }
+  ~LocaleSwitch()
+  {
+    if (m_OldLocale != NULL && std::setlocale(LC_ALL, m_OldLocale) == NULL)
+    {
+      MITK_INFO << "Could not reset locale " << m_OldLocale;
+    }
+  }
+private:
+  const char* m_OldLocale;
+  const std::string m_NewLocale;
+};
+}
+
+#endif // MITKLOCALESWITCH_H_
diff --git a/Core/Code/Internal/mitkItkImageIO.cpp b/Core/Code/Internal/mitkItkImageIO.cpp
index 2080c7f555..5c08472171 100644
--- a/Core/Code/Internal/mitkItkImageIO.cpp
+++ b/Core/Code/Internal/mitkItkImageIO.cpp
@@ -1,509 +1,477 @@
 /*===================================================================
 
 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 "mitkItkImageIO.h"
 
 #include <mitkImage.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkCustomMimeType.h>
 #include <mitkIOMimeTypes.h>
 
 #include <itkImage.h>
 #include <itkImageIOFactory.h>
 #include <itkImageFileReader.h>
 #include <itkImageIORegion.h>
 #include <itkMetaDataObject.h>
 
-#include <clocale>
+#include <mitkLocaleSwitch.h>
+
 
 namespace mitk {
 
 ItkImageIO::ItkImageIO(const ItkImageIO& other)
   : AbstractFileIO(other)
   , m_ImageIO(dynamic_cast<itk::ImageIOBase*>(other.m_ImageIO->Clone().GetPointer()))
 {
 }
 
 std::vector<std::string> ItkImageIO::FixUpImageIOExtensions(const std::string& imageIOName)
 {
   std::vector<std::string> extensions;
   // Try to fix-up some known ITK image IO classes
   if (imageIOName == "GiplImageIO")
   {
     extensions.push_back("gipl");
     extensions.push_back("gipl.gz");
   }
   else if (imageIOName == "GDCMImageIO")
   {
     extensions.push_back("gdcm");
     extensions.push_back("dcm");
     extensions.push_back("DCM");
     extensions.push_back("dc3");
     extensions.push_back("DC3");
     extensions.push_back("ima");
     extensions.push_back("img");
   }
   else if (imageIOName == "PNGImageIO")
   {
     extensions.push_back("png");
     extensions.push_back("PNG");
   }
   else if (imageIOName == "StimulateImageIO")
   {
     extensions.push_back("spr");
   }
   else if (imageIOName == "HDF5ImageIO")
   {
     extensions.push_back("hdf");
     extensions.push_back("h4");
     extensions.push_back("hdf4");
     extensions.push_back("h5");
     extensions.push_back("hdf5");
     extensions.push_back("he4");
     extensions.push_back("he5");
     extensions.push_back("hd5");
   }
 
   if (!extensions.empty())
   {
     MITK_DEBUG << "Fixing up known extensions for " << imageIOName;
   }
 
   return extensions;
 }
 
 ItkImageIO::ItkImageIO(itk::ImageIOBase::Pointer imageIO)
   : AbstractFileIO(Image::GetStaticNameOfClass())
   , m_ImageIO(imageIO)
 {
   if (m_ImageIO.IsNull() )
   {
     mitkThrow() << "ITK ImageIOBase argument must not be NULL";
   }
 
   this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
 
   std::vector<std::string> readExtensions = m_ImageIO->GetSupportedReadExtensions();
 
   if (readExtensions.empty())
   {
     std::string imageIOName = m_ImageIO->GetNameOfClass();
     MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide read extensions";
     readExtensions = FixUpImageIOExtensions(imageIOName);
   }
 
   CustomMimeType customReaderMimeType;
   customReaderMimeType.SetCategory("Images");
   for(std::vector<std::string>::const_iterator iter = readExtensions.begin(),
       endIter = readExtensions.end(); iter != endIter; ++iter)
   {
     std::string extension = *iter;
     if (!extension.empty() && extension[0] == '.')
     {
       extension.assign(iter->begin()+1, iter->end());
     }
     customReaderMimeType.AddExtension(extension);
   }
   this->AbstractFileReader::SetMimeType(customReaderMimeType);
 
   std::vector<std::string> writeExtensions = imageIO->GetSupportedWriteExtensions();
   if (writeExtensions.empty())
   {
     std::string imageIOName = imageIO->GetNameOfClass();
     MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide write extensions";
     writeExtensions = FixUpImageIOExtensions(imageIOName);
   }
 
   if (writeExtensions != readExtensions)
   {
     CustomMimeType customWriterMimeType;
     customWriterMimeType.SetCategory("Images");
     for(std::vector<std::string>::const_iterator iter = writeExtensions.begin(),
         endIter = writeExtensions.end(); iter != endIter; ++iter)
     {
       std::string extension = *iter;
       if (!extension.empty() && extension[0] == '.')
       {
         extension.assign(iter->begin()+1, iter->end());
       }
       customWriterMimeType.AddExtension(extension);
     }
     this->AbstractFileWriter::SetMimeType(customWriterMimeType);
   }
 
   std::string description = std::string("ITK ") + imageIO->GetNameOfClass();
   this->SetReaderDescription(description);
   this->SetWriterDescription(description);
 
   this->RegisterService();
 }
 
 ItkImageIO::ItkImageIO(const CustomMimeType& mimeType, itk::ImageIOBase::Pointer imageIO, int rank)
   : AbstractFileIO(Image::GetStaticNameOfClass(), mimeType, std::string("ITK ") + imageIO->GetNameOfClass())
   , m_ImageIO(imageIO)
 {
   if (m_ImageIO.IsNull() )
   {
     mitkThrow() << "ITK ImageIOBase argument must not be NULL";
   }
 
   this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
 
   if (rank)
   {
     this->AbstractFileReader::SetRanking(rank);
     this->AbstractFileWriter::SetRanking(rank);
   }
 
   this->RegisterService();
 }
 
 std::vector<BaseData::Pointer> ItkImageIO::Read()
 {
   std::vector<BaseData::Pointer> result;
 
   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;
     }
   }
 
   Image::Pointer image = Image::New();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   const std::string path = this->GetLocalFileName();
 
   MITK_INFO << "loading " << path << " via itk::ImageIOFactory... " << std::endl;
 
   // Check to see if we can read the file given the name or prefix
   if (path.empty())
   {
     mitkThrow() << "Empty filename in mitk::ItkImageIO ";
   }
 
   // Got to allocate space for the image. Determine the characteristics of
   // the image.
   m_ImageIO->SetFileName( path );
   m_ImageIO->ReadImageInformation();
 
   unsigned int ndim = m_ImageIO->GetNumberOfDimensions();
   if ( ndim < MINDIM || ndim > MAXDIM )
   {
     MITK_WARN << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D.";
     ndim = MAXDIM;
   }
 
   itk::ImageIORegion ioRegion( ndim );
   itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
   itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
   unsigned int dimensions[ MAXDIM ];
   dimensions[ 0 ] = 0;
   dimensions[ 1 ] = 0;
   dimensions[ 2 ] = 0;
   dimensions[ 3 ] = 0;
 
   ScalarType spacing[ MAXDIM ];
   spacing[ 0 ] = 1.0f;
   spacing[ 1 ] = 1.0f;
   spacing[ 2 ] = 1.0f;
   spacing[ 3 ] = 1.0f;
 
   Point3D origin;
   origin.Fill(0);
 
   unsigned int i;
   for ( i = 0; i < ndim ; ++i )
   {
     ioStart[ i ] = 0;
     ioSize[ i ] = m_ImageIO->GetDimensions( i );
     if(i<MAXDIM)
     {
       dimensions[ i ] = m_ImageIO->GetDimensions( i );
       spacing[ i ] = m_ImageIO->GetSpacing( i );
       if(spacing[ i ] <= 0)
         spacing[ i ] = 1.0f;
     }
     if(i<3)
     {
       origin[ i ] = m_ImageIO->GetOrigin( i );
     }
   }
 
   ioRegion.SetSize( ioSize );
   ioRegion.SetIndex( ioStart );
 
   MITK_INFO << "ioRegion: " << ioRegion << std::endl;
   m_ImageIO->SetIORegion( ioRegion );
   void* buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
   m_ImageIO->Read( buffer );
 
   image->Initialize( MakePixelType(m_ImageIO), ndim, dimensions );
   image->SetImportChannel( buffer, 0, Image::ManageMemory );
 
   // access direction of itk::Image and include spacing
   mitk::Matrix3D matrix;
   matrix.SetIdentity();
   unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
   for ( i=0; i < itkDimMax3; ++i)
     for( j=0; j < itkDimMax3; ++j )
       matrix[i][j] = m_ImageIO->GetDirection(j)[i];
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = image->GetSlicedGeometry(0)->GetPlaneGeometry(0);
   planeGeometry->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
   MITK_INFO << slicedGeometry->GetCornerPoint(false,false,false);
   MITK_INFO << slicedGeometry->GetCornerPoint(true,true,true);
 
   // re-initialize TimeGeometry
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
   image->SetTimeGeometry(timeGeometry);
 
   buffer = NULL;
   MITK_INFO << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
 
   const itk::MetaDataDictionary& dictionary = m_ImageIO->GetMetaDataDictionary();
   for (itk::MetaDataDictionary::ConstIterator iter = dictionary.Begin(), iterEnd = dictionary.End();
        iter != iterEnd; ++iter)
   {
     std::string key = std::string("meta.") + iter->first;
     if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
     {
       std::string value = dynamic_cast<itk::MetaDataObject<std::string>*>(iter->second.GetPointer())->GetMetaDataObjectValue();
       image->SetProperty(key.c_str(), mitk::StringProperty::New(value));
     }
   }
 
   MITK_INFO << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 
   result.push_back(image.GetPointer());
   return result;
 }
 
 AbstractFileIO::ConfidenceLevel ItkImageIO::GetReaderConfidenceLevel() const
 {
   return m_ImageIO->CanReadFile(GetLocalFileName().c_str()) ? IFileReader::Supported : IFileReader::Unsupported;
 }
 
 void ItkImageIO::Write()
 {
   const mitk::Image* image = dynamic_cast<const mitk::Image*>(this->GetInput());
 
   if (image == NULL)
   {
     mitkThrow() << "Cannot write non-image data";
   }
 
-  struct LocaleSwitch
-  {
-    LocaleSwitch(const std::string& newLocale)
-      : m_OldLocale(std::setlocale(LC_ALL, NULL))
-      , m_NewLocale(newLocale)
-    {
-      if (m_OldLocale == NULL)
-      {
-        m_OldLocale = "";
-      }
-      else if (m_NewLocale != m_OldLocale)
-      {
-        // set the locale
-        if (std::setlocale(LC_ALL, m_NewLocale.c_str()) == NULL)
-        {
-          MITK_INFO << "Could not set locale " << m_NewLocale;
-          m_OldLocale = NULL;
-        }
-      }
-    }
-
-    ~LocaleSwitch()
-    {
-      if (m_OldLocale != NULL && std::setlocale(LC_ALL, m_OldLocale) == NULL)
-      {
-        MITK_INFO << "Could not reset locale " << m_OldLocale;
-      }
-    }
-
-  private:
-    const char* m_OldLocale;
-    const std::string m_NewLocale;
-  };
 
   // Switch the current locale to "C"
   LocaleSwitch localeSwitch("C");
 
   // Clone the image geometry, because we might have to change it
   // for writing purposes
   BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
 
   // Check if geometry information will be lost
   if (image->GetDimension() == 2 &&
       !geometry->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 = geometry->GetSpacing();
     mitk::Point3D origin = geometry->GetOrigin();
     geometry->SetIndexToWorldTransform(affTrans);
     geometry->SetSpacing(spacing);
     geometry->SetOrigin(origin);
   }
 
   LocalFile localFile(this);
   const std::string path = localFile.GetFileName();
 
   MITK_INFO << "Writing image: " << path << std::endl;
 
   try
   {
     // Implementation of writer using itkImageIO directly. This skips the use
     // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
     const unsigned int dimension = image->GetDimension();
     const unsigned int* const dimensions = image->GetDimensions();
     const mitk::PixelType pixelType = image->GetPixelType();
     const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
     const mitk::Point3D mitkOrigin = geometry->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 a 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 a valid value here
 
     // Set the necessary information for imageIO
     m_ImageIO->SetNumberOfDimensions(dimension);
     m_ImageIO->SetPixelType(pixelType.GetPixelType());
     m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
                                   static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                                   itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
     m_ImageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
 
     itk::ImageIORegion ioRegion( dimension );
 
     for(unsigned int i = 0; i < dimension; i++)
     {
       m_ImageIO->SetDimensions(i, dimensions[i]);
       m_ImageIO->SetSpacing(i, spacing4D[i]);
       m_ImageIO->SetOrigin(i, origin4D[i]);
 
       mitk::Vector3D mitkDirection;
       mitkDirection.SetVnlVector(geometry->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];
       }
       m_ImageIO->SetDirection(i, axisDirection);
 
       ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
       ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
     }
 
     //use compression if available
     m_ImageIO->UseCompressionOn();
 
     m_ImageIO->SetIORegion(ioRegion);
     m_ImageIO->SetFileName(path);
 
     // ***** Remove const_cast after bug 17952 is fixed ****
     ImageReadAccessor imageAccess(const_cast<mitk::Image*>(image));
     m_ImageIO->Write(imageAccess.GetData());
   }
   catch (const std::exception& e)
   {
     mitkThrow() << e.what();
   }
 }
 
 AbstractFileIO::ConfidenceLevel ItkImageIO::GetWriterConfidenceLevel() const
 {
   // Check if the image dimension is supported
   const Image* image = dynamic_cast<const Image*>(this->GetInput());
   if (image == NULL || !m_ImageIO->SupportsDimension(image->GetDimension()))
   {
     return IFileWriter::Unsupported;
   }
 
   // Check if geometry information will be lost
   if (image->GetDimension() == 2 &&
       !image->GetGeometry()->Is2DConvertable())
   {
     return IFileWriter::PartiallySupported;
   }
   return IFileWriter::Supported;
 }
 
 ItkImageIO* ItkImageIO::IOClone() const
 {
   return new ItkImageIO(*this);
 }
 
 }
diff --git a/Core/Code/Internal/mitkPointSetReaderService.cpp b/Core/Code/Internal/mitkPointSetReaderService.cpp
index 287b077282..e26b0a7be2 100644
--- a/Core/Code/Internal/mitkPointSetReaderService.cpp
+++ b/Core/Code/Internal/mitkPointSetReaderService.cpp
@@ -1,129 +1,130 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // MITK
 #include "mitkPointSetReaderService.h"
 #include "mitkIOMimeTypes.h"
 
 // STL
 #include <iostream>
 #include <fstream>
-#include <locale>
+#include <mitkLocaleSwitch.h>
 
 #include <tinyxml.h>
 
 mitk::PointSetReaderService::PointSetReaderService()
   : AbstractFileReader(CustomMimeType(IOMimeTypes::POINTSET_MIMETYPE_NAME()), "MITK Point Set Reader")
 {
   RegisterService();
 }
 
 mitk::PointSetReaderService::~PointSetReaderService()
 {}
 
 std::vector< itk::SmartPointer<mitk::BaseData> > mitk::PointSetReaderService::Read()
 {
-  std::locale::global(std::locale("C"));
+  // Switch the current locale to "C"
+  LocaleSwitch localeSwitch("C");
 
   std::vector< itk::SmartPointer<mitk::BaseData> > result;
 
   InputStream stream(this);
 
   TiXmlDocument doc;
   stream >> doc;
   if (!doc.Error())
   {
     TiXmlHandle docHandle( &doc );
     //unsigned int pointSetCounter(0);
     for( TiXmlElement* currentPointSetElement = docHandle.FirstChildElement("point_set_file").FirstChildElement("point_set").ToElement();
          currentPointSetElement != NULL; currentPointSetElement = currentPointSetElement->NextSiblingElement())
     {
       mitk::PointSet::Pointer newPointSet = mitk::PointSet::New();
       if(currentPointSetElement->FirstChildElement("time_series") != NULL)
       {
         for( TiXmlElement* currentTimeSeries = currentPointSetElement->FirstChildElement("time_series")->ToElement();
              currentTimeSeries != NULL; currentTimeSeries = currentTimeSeries->NextSiblingElement())
         {
           unsigned int currentTimeStep(0);
           TiXmlElement* currentTimeSeriesID = currentTimeSeries->FirstChildElement("time_series_id");
 
           currentTimeStep = atoi(currentTimeSeriesID->GetText());
 
           newPointSet = this->ReadPoint(newPointSet, currentTimeSeries, currentTimeStep);
         }
       }
       else
       {
         newPointSet = this->ReadPoint(newPointSet, currentPointSetElement, 0);
       }
       result.push_back( newPointSet.GetPointer() );
     }
   }
   else
   {
     mitkThrow() << "Parsing error at line " << doc.ErrorRow() << ", col " << doc.ErrorCol() << ": " << doc.ErrorDesc();
   }
 
   return result;
 }
 
 mitk::PointSet::Pointer mitk::PointSetReaderService::ReadPoint(mitk::PointSet::Pointer newPointSet,
                                                                TiXmlElement* currentTimeSeries, unsigned int currentTimeStep)
 {
   if(currentTimeSeries->FirstChildElement("point") != NULL)
   {
     for( TiXmlElement* currentPoint = currentTimeSeries->FirstChildElement("point")->ToElement();
       currentPoint != NULL; currentPoint = currentPoint->NextSiblingElement())
     {
       unsigned int id(0);
       mitk::PointSpecificationType spec((mitk::PointSpecificationType) 0);
       double x(0.0);
       double y(0.0);
       double z(0.0);
 
       id = atoi(currentPoint->FirstChildElement("id")->GetText());
       if(currentPoint->FirstChildElement("specification") != NULL)
       {
         spec = (mitk::PointSpecificationType) atoi(currentPoint->FirstChildElement("specification")->GetText());
       }
       x = atof(currentPoint->FirstChildElement("x")->GetText());
       y = atof(currentPoint->FirstChildElement("y")->GetText());
       z = atof(currentPoint->FirstChildElement("z")->GetText());
 
       mitk::Point3D point;
       mitk::FillVector3D(point, x, y, z);
       newPointSet->SetPoint(id, point, spec, currentTimeStep);
     }
   }
   else
   {
     if(currentTimeStep != newPointSet->GetTimeSteps()+1)
     {
       newPointSet->Expand(currentTimeStep+1);     // expand time step series with empty time step
     }
   }
   return newPointSet;
 }
 
 mitk::PointSetReaderService::PointSetReaderService(const mitk::PointSetReaderService& other)
   : mitk::AbstractFileReader(other)
 {
 }
 
 mitk::PointSetReaderService* mitk::PointSetReaderService::Clone() const
 {
   return new mitk::PointSetReaderService(*this);
 }
diff --git a/Core/Code/files.cmake b/Core/Code/files.cmake
index c23e4393ec..5e4a9e7038 100644
--- a/Core/Code/files.cmake
+++ b/Core/Code/files.cmake
@@ -1,422 +1,424 @@
 set(H_FILES
   Algorithms/itkImportMitkImageContainer.h
   Algorithms/itkImportMitkImageContainer.txx
   Algorithms/itkMITKScalarImageToHistogramGenerator.h
   Algorithms/itkMITKScalarImageToHistogramGenerator.txx
   Algorithms/mitkInstantiateAccessFunctions.h
   Algorithms/mitkPixelTypeList.h
   Algorithms/mitkPPArithmeticDec.h
   Algorithms/mitkPPArgCount.h
   Algorithms/mitkPPCat.h
   Algorithms/mitkPPConfig.h
   Algorithms/mitkPPControlExprIIf.h
   Algorithms/mitkPPControlIf.h
   Algorithms/mitkPPControlIIf.h
   Algorithms/mitkPPDebugError.h
   Algorithms/mitkPPDetailAutoRec.h
   Algorithms/mitkPPDetailDMCAutoRec.h
   Algorithms/mitkPPExpand.h
   Algorithms/mitkPPFacilitiesEmpty.h
   Algorithms/mitkPPFacilitiesExpand.h
   Algorithms/mitkPPLogicalBool.h
   Algorithms/mitkPPRepetitionDetailDMCFor.h
   Algorithms/mitkPPRepetitionDetailEDGFor.h
   Algorithms/mitkPPRepetitionDetailFor.h
   Algorithms/mitkPPRepetitionDetailMSVCFor.h
   Algorithms/mitkPPRepetitionFor.h
   Algorithms/mitkPPSeqElem.h
   Algorithms/mitkPPSeqForEach.h
   Algorithms/mitkPPSeqForEachProduct.h
   Algorithms/mitkPPSeq.h
   Algorithms/mitkPPSeqEnum.h
   Algorithms/mitkPPSeqSize.h
   Algorithms/mitkPPSeqToTuple.h
   Algorithms/mitkPPStringize.h
   Algorithms/mitkPPTupleEat.h
   Algorithms/mitkPPTupleElem.h
   Algorithms/mitkPPTupleRem.h
   Algorithms/mitkClippedSurfaceBoundsCalculator.h
   Algorithms/mitkExtractSliceFilter.h
   Algorithms/mitkConvert2Dto3DImageFilter.h
   Algorithms/mitkPlaneClipping.h
 
   Common/mitkCommon.h
   Common/mitkExceptionMacro.h
   Common/mitkGetClassHierarchy.h
 
   DataManagement/mitkProportionalTimeGeometry.h
   DataManagement/mitkTimeGeometry.h
   DataManagement/mitkImageAccessByItk.h
   DataManagement/mitkImageCast.h
   DataManagement/mitkImagePixelAccessor.h
   DataManagement/mitkImagePixelReadAccessor.h
   DataManagement/mitkImagePixelWriteAccessor.h
   DataManagement/mitkImageReadAccessor.h
   DataManagement/mitkImageWriteAccessor.h
   DataManagement/mitkITKImageImport.h
   DataManagement/mitkITKImageImport.txx
   DataManagement/mitkImageToItk.h
   DataManagement/mitkShaderProperty.h
   DataManagement/mitkImageToItk.txx
   DataManagement/mitkTimeSlicedGeometry.h # Deprecated, empty for compatibility reasons.
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkVectorDeprecated.h
   DataManagement/mitkArray.h
   DataManagement/mitkQuaternion.h
   DataManagement/mitkNumericTypes.h
   DataManagement/mitkVector.h
   DataManagement/mitkPoint.h
   DataManagement/mitkMatrix.h
 
   Interactions/mitkEventMapperAddOn.h
   Interactions/mitkInteractionConst.h
 
+
   Interfaces/mitkIDataNodeReader.h
   Interfaces/mitkIFileWriter.h
   Interfaces/mitkIFileWriter.cpp
   Interfaces/mitkIFileReader.h
   Interfaces/mitkIFileReader.cpp
 
   Rendering/mitkLocalStorageHandler.h
   Rendering/Colortables/HotIron.h
   Rendering/Colortables/Jet.h
   Rendering/Colortables/PET20.h
   Rendering/Colortables/PETColor.h
 
   IO/mitkPixelTypeTraits.h
+  IO/mitkLocaleSwitch.h
 )
 
 set(CPP_FILES
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataStorage.cpp
 # DataManagement/mitkDataTree.cpp
   DataManagement/mitkDataNode.cpp
 # DataManagement/mitkDataTreeStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkVector.cpp
 
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkShaderProperty.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 # Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 # Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkXML2EventParser.cpp
 
   Interfaces/mitkIMimeTypeProvider.cpp
   Interfaces/mitkInteractionEventObserver.cpp
   Interfaces/mitkIShaderRepository.cpp
   Interfaces/mitkIPropertyAliases.cpp
   Interfaces/mitkIPropertyDescriptions.cpp
   Interfaces/mitkIPropertyExtensions.cpp
   Interfaces/mitkIPropertyFilters.cpp
   Interfaces/mitkIPersistenceService.cpp
 
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkAbstractFileIO.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_SliceGroupingResult.cpp
 
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkIFileIO.cpp
 # IO/mitkIpPicGet.c
   IO/mitkImageGenerator.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOUtil.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkMimeType.cpp
   IO/mitkOperation.cpp
 # IO/mitkPicFileIOFactory.cpp
 # IO/mitkPicFileReader.cpp
 # IO/mitkPicFileWriter.cpp
 # IO/mitkPicHelper.cpp
 # IO/mitkPicVolumeTimeSeriesIOFactory.cpp
 # IO/mitkPicVolumeTimeSeriesReader.cpp
   IO/mitkPixelType.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkLog.cpp
 
   Rendering/mitkBaseRenderer.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkRenderWindowFrame.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkSurfaceVtkMapper2D.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVolumeDataVtkMapper3D.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 
   Rendering/mitkOverlay.cpp
   Rendering/mitkVtkOverlay.cpp
   Rendering/mitkVtkOverlay2D.cpp
   Rendering/mitkVtkOverlay3D.cpp
   Rendering/mitkOverlayManager.cpp
   Rendering/mitkAbstractOverlayLayouter.cpp
 
   Common/mitkException.cpp
   Common/mitkCoreObjectFactoryBase.cpp
   Common/mitkCoreObjectFactory.cpp
   Common/mitkCoreServices.cpp
 
   Internal/mitkCoreActivator.cpp
   Internal/mitkDicomSeriesReaderService.cpp
   Internal/mitkFileReaderWriterBase.cpp
   Internal/mitkImageVtkLegacyIO.cpp
   Internal/mitkImageVtkXmlIO.cpp
   Internal/mitkItkImageIO.cpp
   Internal/mitkLegacyFileReaderService.cpp
   Internal/mitkLegacyFileWriterService.cpp
   Internal/mitkMimeTypeProvider.cpp
   Internal/mitkPointSetReaderService.cpp
   Internal/mitkPointSetWriterService.cpp
   Internal/mitkRawImageFileReader.cpp
   Internal/mitkSurfaceStlIO.cpp
   Internal/mitkSurfaceVtkIO.cpp
   Internal/mitkSurfaceVtkLegacyIO.cpp
   Internal/mitkSurfaceVtkXmlIO.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Modules/ContourModel/IO/mitkContourModelReader.cpp b/Modules/ContourModel/IO/mitkContourModelReader.cpp
index 9242064561..796c709fe8 100644
--- a/Modules/ContourModel/IO/mitkContourModelReader.cpp
+++ b/Modules/ContourModel/IO/mitkContourModelReader.cpp
@@ -1,160 +1,161 @@
 /*===================================================================
 
 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 "mitkContourModelReader.h"
 #include <mitkCustomMimeType.h>
 #include <iostream>
 #include <fstream>
-#include <locale>
+#include <mitkLocaleSwitch.h>
 
 mitk::ContourModelReader::ContourModelReader(const mitk::ContourModelReader& other)
   : mitk::AbstractFileReader(other)
 {
 }
 
 mitk::ContourModelReader::ContourModelReader()
   : AbstractFileReader()
 {
   std::string category = "Contour File";
   mitk::CustomMimeType customMimeType;
   customMimeType.SetCategory(category);
   customMimeType.AddExtension("cnt");
 
   this->SetDescription(category);
   this->SetMimeType(customMimeType);
 
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::ContourModelReader::~ContourModelReader()
 {
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::ContourModelReader::Read()
 {
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
   std::string location = GetInputLocation();
 
-  std::locale::global(std::locale("C"));
+  // Switch the current locale to "C"
+  LocaleSwitch localeSwitch("C");
 
 
   try{
     TiXmlDocument doc(location.c_str());
     bool loadOkay = doc.LoadFile();
     if (loadOkay)
     {
       TiXmlHandle docHandle( &doc );
 
       /*++++ handle n contourModels within data tags ++++*/
       for( TiXmlElement* currentContourElement = docHandle.FirstChildElement("contourModel").ToElement();
         currentContourElement != NULL; currentContourElement = currentContourElement->NextSiblingElement())
       {
         mitk::ContourModel::Pointer newContourModel = mitk::ContourModel::New();
         if(currentContourElement->FirstChildElement("data")->FirstChildElement("timestep") != NULL)
         {
 
           //handle geometry information
           //TiXmlElement* currentGeometryInfo = currentContourElement->FirstChildElement("head")->FirstChildElement("geometryInformation")->ToElement();
           ///////////// NOT SUPPORTED YET ////////////////
 
 
           /*++++ handle n timesteps within timestep tags ++++*/
           for( TiXmlElement* currentTimeSeries = currentContourElement->FirstChildElement("data")->FirstChildElement("timestep")->ToElement();
             currentTimeSeries != NULL; currentTimeSeries = currentTimeSeries->NextSiblingElement())
           {
             unsigned int currentTimeStep(0);
 
 
             currentTimeStep = atoi(currentTimeSeries->Attribute("n"));
 
             this->ReadPoints(newContourModel, currentTimeSeries, currentTimeStep);
 
             int isClosed;
             currentTimeSeries->QueryIntAttribute("isClosed", &isClosed);
             if( isClosed )
             {
               newContourModel->Close(currentTimeStep);
             }
           }
           /*++++ END handle n timesteps within timestep tags ++++*/
 
         }
         else
         {
           //this should not happen
           MITK_WARN << "wrong file format!";
           //newContourModel = this->ReadPoint(newContourModel, currentContourElement, 0);
         }
         newContourModel->UpdateOutputInformation();
         result.push_back(dynamic_cast<mitk::BaseData*>(newContourModel.GetPointer()));
       }
       /*++++ END handle n contourModels within data tags ++++*/
     }
     else
     {
       MITK_WARN << "XML parser error!";
     }
   }catch(...)
   {
     MITK_ERROR  << "Cannot read contourModel.";
   }
 
   return result;
 }
 
 mitk::ContourModelReader* mitk::ContourModelReader::Clone() const
 {
   return new ContourModelReader(*this);
 }
 
 void mitk::ContourModelReader::ReadPoints(mitk::ContourModel::Pointer newContourModel,
         TiXmlElement* currentTimeSeries, unsigned int currentTimeStep)
 {
   //check if the timesteps in contourModel have to be expanded
   if(currentTimeStep != newContourModel->GetTimeSteps())
   {
     newContourModel->Expand(currentTimeStep+1);
   }
 
   //read all points within controlPoints tag
   if(currentTimeSeries->FirstChildElement("controlPoints")->FirstChildElement("point") != NULL)
   {
     for( TiXmlElement* currentPoint = currentTimeSeries->FirstChildElement("controlPoints")->FirstChildElement("point")->ToElement();
               currentPoint != NULL; currentPoint = currentPoint->NextSiblingElement())
       {
 
         double x(0.0);
         double y(0.0);
         double z(0.0);
 
         x = atof(currentPoint->FirstChildElement("x")->GetText());
         y = atof(currentPoint->FirstChildElement("y")->GetText());
         z = atof(currentPoint->FirstChildElement("z")->GetText());
 
         int isActivePoint;
         currentPoint->QueryIntAttribute("isActive", &isActivePoint);
 
         mitk::Point3D point;
         mitk::FillVector3D(point, x, y, z);
         newContourModel->AddVertex(point, isActivePoint,currentTimeStep);
       }
     }
   else
   {
     //nothing to read
   }
 
 }
diff --git a/Modules/ContourModel/IO/mitkContourModelSetReader.cpp b/Modules/ContourModel/IO/mitkContourModelSetReader.cpp
index d0b6b551ce..af33effe02 100644
--- a/Modules/ContourModel/IO/mitkContourModelSetReader.cpp
+++ b/Modules/ContourModel/IO/mitkContourModelSetReader.cpp
@@ -1,81 +1,82 @@
 /*===================================================================
 
 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 "mitkContourModelSetReader.h"
 #include "mitkContourModelReader.h"
 #include <mitkCustomMimeType.h>
 #include <iostream>
 #include <fstream>
-#include <locale>
+#include <mitkLocaleSwitch.h>
 
 
 mitk::ContourModelSetReader::ContourModelSetReader(const mitk::ContourModelSetReader& other)
   : mitk::AbstractFileReader(other)
 {
 }
 
 mitk::ContourModelSetReader::ContourModelSetReader()
   : AbstractFileReader()
 {
   std::string category = "ContourModelSet File";
   CustomMimeType customMimeType;
   customMimeType.SetCategory(category);
   customMimeType.AddExtension("cnt_set");
 
   this->SetDescription(category);
   this->SetMimeType(customMimeType);
 
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::ContourModelSetReader::~ContourModelSetReader()
 {
 }
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::ContourModelSetReader::Read()
 {
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
   std::vector<itk::SmartPointer<mitk::BaseData> > internalResult;
 
   std::string location = GetInputLocation();
 
-  std::locale::global(std::locale("C"));
+  // Switch the current locale to "C"
+  LocaleSwitch localeSwitch("C");
 
   try{
     mitk::ContourModelSet::Pointer contourSet = mitk::ContourModelSet::New();
 
     mitk::ContourModelReader reader;
     reader.SetInput(location);
     internalResult = reader.Read();
 
     for(unsigned int i = 0; i < internalResult.size(); ++i)
     {
       contourSet->AddContourModel( dynamic_cast<mitk::ContourModel*>(internalResult.at(i).GetPointer()) );
     }
     result.push_back(dynamic_cast<mitk::BaseData*>(contourSet.GetPointer()));
 
   }catch(...)
   {
     MITK_ERROR  << "Cannot read contourModel.";
   }
 
   return result;
 }
 
 mitk::ContourModelSetReader* mitk::ContourModelSetReader::Clone() const
 {
   return new ContourModelSetReader(*this);
 }
diff --git a/Modules/LegacyIO/mitkPointSetReader.cpp b/Modules/LegacyIO/mitkPointSetReader.cpp
index efeb37719c..7b8effcf13 100644
--- a/Modules/LegacyIO/mitkPointSetReader.cpp
+++ b/Modules/LegacyIO/mitkPointSetReader.cpp
@@ -1,194 +1,195 @@
 /*===================================================================
 
 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 "mitkPointSetReader.h"
 #include <iostream>
 #include <fstream>
-#include <locale>
+#include <mitkLocaleSwitch.h>
 
 mitk::PointSetReader::PointSetReader()
 {
   m_Success = false;
 }
 
 
 mitk::PointSetReader::~PointSetReader()
 {}
 
 
 void mitk::PointSetReader::GenerateData()
 {
-    std::locale::global(std::locale("C"));
+    // Switch the current locale to "C"
+    LocaleSwitch localeSwitch("C");
 
     m_Success = false;
     if ( m_FileName == "" )
     {
       itkWarningMacro( << "Sorry, filename has not been set!" );
         return ;
     }
     if ( ! this->CanReadFile( m_FileName.c_str() ) )
     {
       itkWarningMacro( << "Sorry, can't read file " << m_FileName << "!" );
         return ;
     }
 
   try{
     TiXmlDocument doc(m_FileName.c_str());
     bool loadOkay = doc.LoadFile();
     if (loadOkay)
     {
       TiXmlHandle docHandle( &doc );
       unsigned int pointSetCounter(0);
       for( TiXmlElement* currentPointSetElement = docHandle.FirstChildElement("point_set_file").FirstChildElement("point_set").ToElement();
         currentPointSetElement != NULL; currentPointSetElement = currentPointSetElement->NextSiblingElement())
       {
         mitk::PointSet::Pointer newPointSet = mitk::PointSet::New();
         if(currentPointSetElement->FirstChildElement("time_series") != NULL)
         {
           for( TiXmlElement* currentTimeSeries = currentPointSetElement->FirstChildElement("time_series")->ToElement();
             currentTimeSeries != NULL; currentTimeSeries = currentTimeSeries->NextSiblingElement())
           {
             unsigned int currentTimeStep(0);
             TiXmlElement* currentTimeSeriesID = currentTimeSeries->FirstChildElement("time_series_id");
 
             currentTimeStep = atoi(currentTimeSeriesID->GetText());
 
             newPointSet = this->ReadPoint(newPointSet, currentTimeSeries, currentTimeStep);
           }
         }
         else
         {
           newPointSet = this->ReadPoint(newPointSet, currentPointSetElement, 0);
         }
         this->SetNthOutput( pointSetCounter, newPointSet );
         pointSetCounter++;
       }
     }
     else
     {
       MITK_WARN << "XML parser error!";
     }
   }catch(...)
    {
       MITK_ERROR  << "Cannot read point set.";
       m_Success = false;
    }
     m_Success = true;
 }
 
 mitk::PointSet::Pointer mitk::PointSetReader::ReadPoint(mitk::PointSet::Pointer newPointSet,
         TiXmlElement* currentTimeSeries, unsigned int currentTimeStep)
 {
   if(currentTimeSeries->FirstChildElement("point") != NULL)
   {
     for( TiXmlElement* currentPoint = currentTimeSeries->FirstChildElement("point")->ToElement();
               currentPoint != NULL; currentPoint = currentPoint->NextSiblingElement())
       {
         unsigned int id(0);
         mitk::PointSpecificationType spec((mitk::PointSpecificationType) 0);
         double x(0.0);
         double y(0.0);
         double z(0.0);
 
        id = atoi(currentPoint->FirstChildElement("id")->GetText());
         if(currentPoint->FirstChildElement("specification") != NULL)
         {
           spec = (mitk::PointSpecificationType) atoi(currentPoint->FirstChildElement("specification")->GetText());
         }
         x = atof(currentPoint->FirstChildElement("x")->GetText());
         y = atof(currentPoint->FirstChildElement("y")->GetText());
         z = atof(currentPoint->FirstChildElement("z")->GetText());
 
         mitk::Point3D point;
         mitk::FillVector3D(point, x, y, z);
         newPointSet->SetPoint(id, point, spec, currentTimeStep);
       }
     }
   else
   {
     if(currentTimeStep != newPointSet->GetTimeSteps()+1)
     {
       newPointSet->Expand(currentTimeStep+1);     // expand time step series with empty time step
     }
   }
     return newPointSet;
 }
 
 void mitk::PointSetReader::GenerateOutputInformation()
 {
 }
 
 int mitk::PointSetReader::CanReadFile ( const char *name )
 {
     std::ifstream in( name );
     bool isGood = in.good();
     in.close();
     return isGood;
 }
 
 bool mitk::PointSetReader::CanReadFile(const std::string filename, const std::string filePrefix, const std::string filePattern)
 {
   // First check the extension
   if(  filename == "" )
   {
       //MITK_INFO<<"No filename specified."<<std::endl;
     return false;
   }
 
   // check if image is serie
   if( filePattern != "" && filePrefix != "" )
     return false;
 
   bool extensionFound = false;
   std::string::size_type MPSPos = filename.rfind(".mps");
   if ((MPSPos != std::string::npos)
       && (MPSPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   MPSPos = filename.rfind(".MPS");
   if ((MPSPos != std::string::npos)
       && (MPSPos == filename.length() - 4))
     {
     extensionFound = true;
     }
 
   if( !extensionFound )
     {
       //MITK_INFO<<"The filename extension is not recognized."<<std::endl;
     return false;
     }
 
   return true;
 }
 
 void mitk::PointSetReader::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::PointSetReader::GetSuccess() const
 {
     return m_Success;
 }