diff --git a/Modules/DiffusionImaging/Algorithms/itkTensorImageToDiffusionImageFilter.txx b/Modules/DiffusionImaging/Algorithms/itkTensorImageToDiffusionImageFilter.txx
index d88a7f5d48..bb9a8cf43e 100644
--- a/Modules/DiffusionImaging/Algorithms/itkTensorImageToDiffusionImageFilter.txx
+++ b/Modules/DiffusionImaging/Algorithms/itkTensorImageToDiffusionImageFilter.txx
@@ -1,212 +1,212 @@
 /*=========================================================================
 
 Program:   Tensor ToolKit - TTK
 Module:    $URL: svn://scm.gforge.inria.fr/svn/ttk/trunk/Algorithms/itkTensorImageToDiffusionImageFilter.txx $
 Language:  C++
 Date:      $Date: 2010-06-07 13:39:13 +0200 (Mo, 07 Jun 2010) $
 Version:   $Revision: 68 $
 
 Copyright (c) INRIA 2010. All rights reserved.
 See LICENSE.txt for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 #ifndef _itk_TensorImageToDiffusionImageFilter_txx_
 #define _itk_TensorImageToDiffusionImageFilter_txx_
 #endif
 
 #include "itkTensorImageToDiffusionImageFilter.h"
 #include "itkTensorToL2NormImageFilter.h"
 #include "itkRescaleIntensityImageFilter.h"
 #include <itkImageRegionIterator.h>
 #include <itkImageRegionConstIterator.h>
 
 namespace itk
 {
 
   //template <class TInputScalarType, class TOutputScalarType>
   //void
   //  TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
   //  ::GenerateData()
   //{
   //  // Call a method that can be overriden by a subclass to allocate
   //  // memory for the filter's outputs
   //  this->AllocateOutputs();
 
   //  // Call a method that can be overridden by a subclass to perform
   //  // some calculations prior to splitting the main computations into
   //  // separate threads
   //  this->BeforeThreadedGenerateData();
 
   //  // Set up the multithreaded processing
   //  ThreadStruct str;
   //  str.Filter = this;
 
   //  this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
   //  this->GetMultiThreader()->SetSingleMethod(this->ThreaderCallback, &str);
 
   //  // multithread the execution
   //  this->GetMultiThreader()->SingleMethodExecute();
 
   //  // Call a method that can be overridden by a subclass to perform
   //  // some calculations after all the threads have completed
   //  this->AfterThreadedGenerateData();
 
   //}
 
   template <class TInputScalarType, class TOutputScalarType>
   void
     TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
     ::BeforeThreadedGenerateData()
   {
 
     if( m_GradientList.size()==0 )
     {
-      throw itk::ExceptionObject (__FILE__,__LINE__,"Error: gradient list is empty, cannot generate DWI.");      
+      throw itk::ExceptionObject (__FILE__,__LINE__,"Error: gradient list is empty, cannot generate DWI.");
     }
 
     // create a B0 image by taking the norm of the tensor field * scale:
     typedef itk::TensorToL2NormImageFilter<InputImageType, itk::Image<InputScalarType,3> >
       TensorToL2NormFilterType;
 
     typename TensorToL2NormFilterType::Pointer myFilter1 = TensorToL2NormFilterType::New();
     myFilter1->SetInput (this->GetInput());
 
     try
     {
       myFilter1->Update();
     }
     catch (itk::ExceptionObject &e)
     {
       std::cerr << e;
       return;
     }
 
     typename itk::RescaleIntensityImageFilter< itk::Image<InputScalarType,3>, BaselineImageType>::Pointer rescaler=
       itk::RescaleIntensityImageFilter<itk::Image<InputScalarType,3>, BaselineImageType>::New();
 
     rescaler->SetOutputMinimum ( 0 );
     rescaler->SetOutputMaximum ( 32767 );
     rescaler->SetInput ( myFilter1->GetOutput() );
     try
     {
       rescaler->Update();
     }
     catch (itk::ExceptionObject &e)
     {
       std::cerr << e;
       return;
     }
 
     m_BaselineImage = rescaler->GetOutput();
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( this->GetInput()->GetSpacing() );   // Set the image spacing
     outImage->SetOrigin( this->GetInput()->GetOrigin() );     // Set the image origin
     outImage->SetDirection( this->GetInput()->GetDirection() );  // Set the image direction
     outImage->SetLargestPossibleRegion( this->GetInput()->GetLargestPossibleRegion());
     outImage->SetBufferedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetRequestedRegion( this->GetInput()->GetLargestPossibleRegion() );
     outImage->SetVectorLength(m_GradientList.size()+1);
     outImage->Allocate();
 
     this->SetNumberOfRequiredOutputs (1);
     this->SetNthOutput (0, outImage);
 
   }
 
   template <class TInputScalarType, class TOutputScalarType>
   void
     TensorImageToDiffusionImageFilter<TInputScalarType, TOutputScalarType>
     ::ThreadedGenerateData ( const OutputImageRegionType &outputRegionForThread, int threadId )
   {
 
     typedef ImageRegionIterator<OutputImageType>      IteratorOutputType;
     typedef ImageRegionConstIterator<InputImageType>  IteratorInputType;
     typedef ImageRegionConstIterator<BaselineImageType>  IteratorBaselineType;
 
     unsigned long numPixels = outputRegionForThread.GetNumberOfPixels();
     unsigned long step = numPixels/100;
     unsigned long progress = 0;
 
     IteratorOutputType itOut (this->GetOutput(0), outputRegionForThread);
     IteratorInputType  itIn (this->GetInput(), outputRegionForThread);
     IteratorBaselineType itB0 (m_BaselineImage, outputRegionForThread);
 
     if( threadId==0 )
     {
       this->UpdateProgress (0.0);
     }
 
 
     while(!itIn.IsAtEnd())
     {
 
       if( this->GetAbortGenerateData() )
       {
         throw itk::ProcessAborted(__FILE__,__LINE__);
       }
 
       InputPixelType T = itIn.Get();
 
       BaselinePixelType b0 = itB0.Get();
 
-      OutputPixelType out; 
+      OutputPixelType out;
       out.SetSize(m_GradientList.size()+1);
 
       for( unsigned int i=0; i<m_GradientList.size(); i++)
       {
 
         if( b0 > 0)
         {
           GradientType g = m_GradientList[i];
-          
+
           InputPixelType S;
           S[0] = g[0]*g[0];
           S[1] = g[1]*g[0];
           S[2] = g[2]*g[0];
           S[3] = g[1]*g[1];
           S[4] = g[2]*g[1];
           S[5] = g[2]*g[2];
-          
-          double res = 
-              T[0]*S[0] + T[1]*S[1] + T[2]*S[2] + 
-              T[1]*S[1] + T[3]*S[3] + T[4]*S[4] + 
+
+          double res =
+              T[0]*S[0] + T[1]*S[1] + T[2]*S[2] +
+              T[1]*S[1] + T[3]*S[3] + T[4]*S[4] +
               T[2]*S[2] + T[4]*S[4] + T[5]*S[5];
-          
-          out[i] = static_cast<OutputScalarType>( 1.0*b0*exp ( -1.0 * m_BValue * res ) );
+
+          out[i] = static_cast<OutputScalarType>( 1.0*b0*exp ( -0.001 * m_BValue * res ) );
         }
 
       }
 
       out[m_GradientList.size()] = b0;
 
       itOut.Set(out);
 
       if( threadId==0 && step>0)
-      {        
+      {
         if( (progress%step)==0 )
         {
           this->UpdateProgress ( double(progress)/double(numPixels) );
         }
       }
 
       ++progress;
       ++itB0;
       ++itIn;
       ++itOut;
 
     }
 
     if( threadId==0 )
-    { 
+    {
       this->UpdateProgress (1.0);
-    }  
+    }
   }
 
 
 
 } // end of namespace
diff --git a/Modules/DiffusionImaging/IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp b/Modules/DiffusionImaging/IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
index 58c177ed84..339ca20aeb 100644
--- a/Modules/DiffusionImaging/IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/QBallImages/mitkNrrdQBallImageReader.cpp
@@ -1,158 +1,181 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNrrdQBallImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkImageRegionIterator.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "mitkITKImageImport.h"
 #include "mitkImageDataItem.h"
 
 namespace mitk
 {
 
   void NrrdQBallImageReader
     ::GenerateData()
-  {    
-    if ( m_FileName == "") 
+  {
+    if ( m_FileName == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename of the vessel tree to be read is empty!");
     }
     else
     {
       try
       {
+        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;
+          }
+        }
+
         typedef itk::VectorImage<float,3> ImageType;
         itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
         typedef itk::ImageFileReader<ImageType> FileReaderType;
         FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetImageIO(io);
         reader->SetFileName(this->m_FileName);
         reader->Update();
         ImageType::Pointer img = reader->GetOutput();
 
         typedef itk::Image<itk::Vector<float,QBALL_ODFSIZE>,3> VecImgType;
         VecImgType::Pointer vecImg = VecImgType::New();
         vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
         vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
         vecImg->SetDirection( img->GetDirection() );  // Set the image direction
         vecImg->SetLargestPossibleRegion( img->GetLargestPossibleRegion());
         vecImg->SetBufferedRegion( img->GetLargestPossibleRegion() );
         vecImg->Allocate();
 
         itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
         ot = ot.Begin();
 
         itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
 
         typedef ImageType::PixelType  VarPixType;
         typedef VecImgType::PixelType FixPixType;
 
         for (it = it.Begin(); !it.IsAtEnd(); ++it)
         {
           VarPixType vec = it.Get();
           FixPixType fixVec(vec.GetDataPointer());
           ot.Set(fixVec);
           ++ot;
         }
 
         this->GetOutput()->InitializeByItk(vecImg.GetPointer());
         this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
 
+        try
+        {
+          setlocale(LC_ALL, currLocale.c_str());
+        }
+        catch(...)
+        {
+          MITK_INFO << "Could not reset locale " << currLocale;
+        }
       }
       catch(std::exception& e)
       {
-        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());                    
+        throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested vessel tree file!");
       }
     }
   }
 
   void NrrdQBallImageReader::GenerateOutputInformation()
   {
 
   }
 
 
-  
+
   const char* NrrdQBallImageReader
     ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
-  
+
   void NrrdQBallImageReader
     ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
-  
+
   const char* NrrdQBallImageReader
     ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
-  
+
   void NrrdQBallImageReader
     ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
-  
+
   const char* NrrdQBallImageReader
     ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
-  
+
   void NrrdQBallImageReader
     ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
-  
+
   bool NrrdQBallImageReader
-    ::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/) 
+    ::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
   {
     // First check the extension
     if(  filename == "" )
     {
       return false;
     }
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".hqbi" || ext == ".qbi")
     {
       return true;
     }
 
     return false;
   }
 
 } //namespace MITK
diff --git a/Modules/DiffusionImaging/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp b/Modules/DiffusionImaging/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
index 4aed036ab7..f0c563025a 100644
--- a/Modules/DiffusionImaging/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
+++ b/Modules/DiffusionImaging/IODataStructures/TensorImages/mitkNrrdTensorImageReader.cpp
@@ -1,188 +1,212 @@
 /*=========================================================================
 
 Program:   Medical Imaging & Interaction Toolkit
 Language:  C++
 Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
 Version:   $Revision: 18127 $
 
 Copyright (c) German Cancer Research Center, Division of Medical and
 Biological Informatics. All rights reserved.
 See MITKCopyright.txt or http://www.mitk.org/copyright.html for details.
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notices for more information.
 
 =========================================================================*/
 
 #include "mitkNrrdTensorImageReader.h"
 
 #include "itkImageFileReader.h"
 #include "itkImageRegionIterator.h"
 #include "itkMetaDataObject.h"
 #include "itkNrrdImageIO.h"
 #include "itkDiffusionTensor3D.h"
 
 #include "mitkITKImageImport.h"
 #include "mitkImageDataItem.h"
 
 namespace mitk
 {
 
   void NrrdTensorImageReader
     ::GenerateData()
   {
     if ( m_FileName == "")
     {
       throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, the filename is empty!");
     }
     else
     {
       try
       {
+        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;
+          }
+        }
+
         typedef itk::VectorImage<float,3> ImageType;
         itk::NrrdImageIO::Pointer io = itk::NrrdImageIO::New();
         typedef itk::ImageFileReader<ImageType> FileReaderType;
         FileReaderType::Pointer reader = FileReaderType::New();
         reader->SetImageIO(io);
         reader->SetFileName(this->m_FileName);
         reader->Update();
         ImageType::Pointer img = reader->GetOutput();
 
         typedef itk::Image<itk::DiffusionTensor3D<float>,3> VecImgType;
         VecImgType::Pointer vecImg = VecImgType::New();
         vecImg->SetSpacing( img->GetSpacing() );   // Set the image spacing
         vecImg->SetOrigin( img->GetOrigin() );     // Set the image origin
         vecImg->SetDirection( img->GetDirection() );  // Set the image direction
         vecImg->SetRegions( img->GetLargestPossibleRegion());
         vecImg->Allocate();
 
         itk::ImageRegionIterator<VecImgType> ot (vecImg, vecImg->GetLargestPossibleRegion() );
         ot = ot.Begin();
 
         itk::ImageRegionIterator<ImageType> it (img, img->GetLargestPossibleRegion() );
         it = it.Begin();
 
         typedef ImageType::PixelType  VarPixType;
         typedef VecImgType::PixelType FixPixType;
         int numComponents = img->GetNumberOfComponentsPerPixel();
 
         if (numComponents==6)
         {
           while (!it.IsAtEnd())
           {
             VarPixType vec = it.Get();
             FixPixType fixVec(vec.GetDataPointer());
             ot.Set(fixVec);
             ++ot;
             ++it;
           }
         }
         else if(numComponents==9)
         {
           while (!it.IsAtEnd())
           {
             VarPixType vec = it.Get();
             itk::DiffusionTensor3D<float> tensor;
             tensor.SetElement(0, vec.GetElement(0));
             tensor.SetElement(1, vec.GetElement(1));
             tensor.SetElement(2, vec.GetElement(2));
             tensor.SetElement(3, vec.GetElement(4));
             tensor.SetElement(4, vec.GetElement(5));
             tensor.SetElement(5, vec.GetElement(8));
 
             FixPixType fixVec(tensor);
             ot.Set(fixVec);
             ++ot;
             ++it;
           }
         }
         else
         {
           throw itk::ImageFileReaderException(__FILE__, __LINE__, "Image has wrong number of pixel components!");
         }
 
         this->GetOutput()->InitializeByItk(vecImg.GetPointer());
         this->GetOutput()->SetVolume(vecImg->GetBufferPointer());
 
+        try
+        {
+          setlocale(LC_ALL, currLocale.c_str());
+        }
+        catch(...)
+        {
+          MITK_INFO << "Could not reset locale " << currLocale;
+        }
+
       }
       catch(std::exception& e)
       {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, e.what());
       }
       catch(...)
       {
         throw itk::ImageFileReaderException(__FILE__, __LINE__, "Sorry, an error occurred while reading the requested DTI file!");
       }
     }
   }
 
   void NrrdTensorImageReader::GenerateOutputInformation()
   {
 
   }
 
 
 
   const char* NrrdTensorImageReader
     ::GetFileName() const
   {
     return m_FileName.c_str();
   }
 
 
   void NrrdTensorImageReader
     ::SetFileName(const char* aFileName)
   {
     m_FileName = aFileName;
   }
 
 
   const char* NrrdTensorImageReader
     ::GetFilePrefix() const
   {
     return m_FilePrefix.c_str();
   }
 
 
   void NrrdTensorImageReader
     ::SetFilePrefix(const char* aFilePrefix)
   {
     m_FilePrefix = aFilePrefix;
   }
 
 
   const char* NrrdTensorImageReader
     ::GetFilePattern() const
   {
     return m_FilePattern.c_str();
   }
 
 
   void NrrdTensorImageReader
     ::SetFilePattern(const char* aFilePattern)
   {
     m_FilePattern = aFilePattern;
   }
 
 
   bool NrrdTensorImageReader
     ::CanReadFile(const std::string filename, const std::string /*filePrefix*/, const std::string /*filePattern*/)
   {
     // First check the extension
     if(  filename == "" )
     {
       return false;
     }
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext == ".hdti" || ext == ".dti")
     {
       return true;
     }
 
     return false;
   }
 
 } //namespace MITK