diff --git a/Modules/DiffusionImaging/Tractography/itkStreamlineTrackingFilter.cpp b/Modules/DiffusionImaging/Tractography/itkStreamlineTrackingFilter.cpp
index 4aa8b875c8..fc16a6475c 100644
--- a/Modules/DiffusionImaging/Tractography/itkStreamlineTrackingFilter.cpp
+++ b/Modules/DiffusionImaging/Tractography/itkStreamlineTrackingFilter.cpp
@@ -1,718 +1,718 @@
 /*===================================================================
 
 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 __itkStreamlineTrackingFilter_txx
 #define __itkStreamlineTrackingFilter_txx
 
 #include <time.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "itkStreamlineTrackingFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 namespace itk {
 
 //#define QBALL_RECON_PI       M_PI
 
 template< class TTensorPixelType, class TPDPixelType>
 StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::StreamlineTrackingFilter():
     m_FaThreshold(0.2),
     m_StepSize(1),
     m_MaxLength(10000),
     m_SeedsPerVoxel(1),
     m_F(1.0),
     m_G(0.0),
     m_Interpolate(true),
     m_MinTractLength(0.0)
 {
     // At least 1 inputs is necessary for a vector image.
     // For images added one at a time we need at least six
     this->SetNumberOfRequiredInputs( 1 );
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 double StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::RoundToNearest(double num) {
     return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::BeforeThreadedGenerateData()
 {
     m_FiberPolyData = FiberPolyDataType::New();
     m_Points = vtkPoints::New();
     m_Cells = vtkCellArray::New();
 
     m_InputImage = static_cast< InputImageType * >( this->ProcessObject::GetInput(0) );
     m_ImageSize.resize(3);
     m_ImageSize[0] = m_InputImage->GetLargestPossibleRegion().GetSize()[0];
     m_ImageSize[1] = m_InputImage->GetLargestPossibleRegion().GetSize()[1];
     m_ImageSize[2] = m_InputImage->GetLargestPossibleRegion().GetSize()[2];
 
     if (m_ImageSize[0]<3 || m_ImageSize[1]<3 || m_ImageSize[2]<3)
         m_Interpolate = false;
 
     m_ImageSpacing.resize(3);
     m_ImageSpacing[0] = m_InputImage->GetSpacing()[0];
     m_ImageSpacing[1] = m_InputImage->GetSpacing()[1];
     m_ImageSpacing[2] = m_InputImage->GetSpacing()[2];
 
     float minSpacing;
     if(m_ImageSpacing[0]<m_ImageSpacing[1] && m_ImageSpacing[0]<m_ImageSpacing[2])
         minSpacing = m_ImageSpacing[0];
     else if (m_ImageSpacing[1] < m_ImageSpacing[2])
         minSpacing = m_ImageSpacing[1];
     else
         minSpacing = m_ImageSpacing[2];
     if (m_StepSize<0.1*minSpacing)
     {
         m_StepSize = 0.1*minSpacing;
         m_PointPistance = 0.5*minSpacing;
     }
 
     m_PolyDataContainer = itk::VectorContainer< int, FiberPolyDataType >::New();
     for (int i=0; i<this->GetNumberOfThreads(); i++)
     {
         FiberPolyDataType poly = FiberPolyDataType::New();
         m_PolyDataContainer->InsertElement(i, poly);
     }
 
     if (m_SeedImage.IsNull())
     {
         // initialize mask image
         m_SeedImage = ItkUcharImgType::New();
         m_SeedImage->SetSpacing( m_InputImage->GetSpacing() );
         m_SeedImage->SetOrigin( m_InputImage->GetOrigin() );
         m_SeedImage->SetDirection( m_InputImage->GetDirection() );
         m_SeedImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
         m_SeedImage->Allocate();
         m_SeedImage->FillBuffer(1);
     }
 
     if (m_MaskImage.IsNull())
     {
         // initialize mask image
         m_MaskImage = ItkUcharImgType::New();
         m_MaskImage->SetSpacing( m_InputImage->GetSpacing() );
         m_MaskImage->SetOrigin( m_InputImage->GetOrigin() );
         m_MaskImage->SetDirection( m_InputImage->GetDirection() );
         m_MaskImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
         m_MaskImage->Allocate();
         m_MaskImage->FillBuffer(1);
     }
 
     m_FaImage = ItkFloatImgType::New();
     m_FaImage->SetSpacing( m_InputImage->GetSpacing() );
     m_FaImage->SetOrigin( m_InputImage->GetOrigin() );
     m_FaImage->SetDirection( m_InputImage->GetDirection() );
     m_FaImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
     m_FaImage->Allocate();
     m_FaImage->FillBuffer(0.0);
 
     m_PdImage = ItkPDImgType::New();
     m_PdImage->SetSpacing( m_InputImage->GetSpacing() );
     m_PdImage->SetOrigin( m_InputImage->GetOrigin() );
     m_PdImage->SetDirection( m_InputImage->GetDirection() );
     m_PdImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
     m_PdImage->Allocate();
 
     m_EmaxImage = ItkFloatImgType::New();
     m_EmaxImage->SetSpacing( m_InputImage->GetSpacing() );
     m_EmaxImage->SetOrigin( m_InputImage->GetOrigin() );
     m_EmaxImage->SetDirection( m_InputImage->GetDirection() );
     m_EmaxImage->SetRegions( m_InputImage->GetLargestPossibleRegion() );
     m_EmaxImage->Allocate();
     m_EmaxImage->FillBuffer(1.0);
 
     typedef itk::DiffusionTensor3D<TTensorPixelType>    TensorType;
     typename TensorType::EigenValuesArrayType eigenvalues;
     typename TensorType::EigenVectorsMatrixType eigenvectors;
     for (int x=0; x<m_ImageSize[0]; x++)
         for (int y=0; y<m_ImageSize[1]; y++)
             for (int z=0; z<m_ImageSize[2]; z++)
             {
                 typename InputImageType::IndexType index;
                 index[0] = x; index[1] = y; index[2] = z;
                 typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index);
 
                 vnl_vector_fixed<double,3> dir;
                 tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
                 dir[0] = eigenvectors(2, 0);
                 dir[1] = eigenvectors(2, 1);
                 dir[2] = eigenvectors(2, 2);
                 dir.normalize();
                 m_PdImage->SetPixel(index, dir);
                 m_FaImage->SetPixel(index, tensor.GetFractionalAnisotropy());
                 m_EmaxImage->SetPixel(index, 2/eigenvalues[2]);
             }
 
     if (m_Interpolate)
         std::cout << "StreamlineTrackingFilter: using trilinear interpolation" << std::endl;
     else
     {
         if (m_MinCurvatureRadius<0.0)
             m_MinCurvatureRadius = 0.1*minSpacing;
 
         std::cout << "StreamlineTrackingFilter: using nearest neighbor interpolation" << std::endl;
     }
 
     if (m_MinCurvatureRadius<0.0)
         m_MinCurvatureRadius = 0.5*minSpacing;
 
     std::cout << "StreamlineTrackingFilter: Min. curvature radius: " << m_MinCurvatureRadius << std::endl;
     std::cout << "StreamlineTrackingFilter: FA threshold: " << m_FaThreshold << std::endl;
     std::cout << "StreamlineTrackingFilter: stepsize: " << m_StepSize << " mm" << std::endl;
     std::cout << "StreamlineTrackingFilter: f: " << m_F << std::endl;
     std::cout << "StreamlineTrackingFilter: g: " << m_G << std::endl;
     std::cout << "StreamlineTrackingFilter: starting streamline tracking" << std::endl;
 }
 
 template< class TTensorPixelType, class TPDPixelType>
 void StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
 ::CalculateNewPosition(itk::ContinuousIndex<double, 3>& pos, vnl_vector_fixed<double,3>& dir, typename InputImageType::IndexType& index)
 {
     if (true)
     {
         dir *= m_StepSize;
         pos[0] += dir[0]/m_ImageSpacing[0];
         pos[1] += dir[1]/m_ImageSpacing[1];
         pos[2] += dir[2]/m_ImageSpacing[2];
         index[0] = RoundToNearest(pos[0]);
         index[1] = RoundToNearest(pos[1]);
         index[2] = RoundToNearest(pos[2]);
     }
     else
     {
         dir[0] /= m_ImageSpacing[0];
         dir[1] /= m_ImageSpacing[1];
         dir[2] /= m_ImageSpacing[2];
 
         int smallest = 0;
         float x = 100000;
         if (dir[0]>0)
         {
             if (fabs(fabs(RoundToNearest(pos[0])-pos[0])-0.5)>mitk::eps)
                 x = fabs(pos[0]-RoundToNearest(pos[0])-0.5)/dir[0];
             else
                 x = fabs(pos[0]-std::ceil(pos[0])-0.5)/dir[0];
         }
         else if (dir[0]<0)
         {
             if (fabs(fabs(RoundToNearest(pos[0])-pos[0])-0.5)>mitk::eps)
                 x = -fabs(pos[0]-RoundToNearest(pos[0])+0.5)/dir[0];
             else
                 x = -fabs(pos[0]-std::floor(pos[0])+0.5)/dir[0];
         }
         float s = x;
 
         float y = 100000;
         if (dir[1]>0)
         {
             if (fabs(fabs(RoundToNearest(pos[1])-pos[1])-0.5)>mitk::eps)
                 y = fabs(pos[1]-RoundToNearest(pos[1])-0.5)/dir[1];
             else
                 y = fabs(pos[1]-std::ceil(pos[1])-0.5)/dir[1];
         }
         else if (dir[1]<0)
         {
             if (fabs(fabs(RoundToNearest(pos[1])-pos[1])-0.5)>mitk::eps)
                 y = -fabs(pos[1]-RoundToNearest(pos[1])+0.5)/dir[1];
             else
                 y = -fabs(pos[1]-std::floor(pos[1])+0.5)/dir[1];
         }
         if (s>y)
         {
             s=y;
             smallest = 1;
         }
 
         float z = 100000;
         if (dir[2]>0)
         {
             if (fabs(fabs(RoundToNearest(pos[2])-pos[2])-0.5)>mitk::eps)
                 z = fabs(pos[2]-RoundToNearest(pos[2])-0.5)/dir[2];
             else
                 z = fabs(pos[2]-std::ceil(pos[2])-0.5)/dir[2];
         }
         else if (dir[2]<0)
         {
             if (fabs(fabs(RoundToNearest(pos[2])-pos[2])-0.5)>mitk::eps)
                 z = -fabs(pos[2]-RoundToNearest(pos[2])+0.5)/dir[2];
             else
                 z = -fabs(pos[2]-std::floor(pos[2])+0.5)/dir[2];
         }
         if (s>z)
         {
             s=z;
             smallest = 2;
         }
 
 //        MITK_INFO << "---------------------------------------------";
 //        MITK_INFO << "s: " << s;
 //        MITK_INFO << "dir: " << dir;
 //        MITK_INFO << "old: " << pos[0] << ", " << pos[1] << ", " << pos[2];
 
         pos[0] += dir[0]*s;
         pos[1] += dir[1]*s;
         pos[2] += dir[2]*s;
 
         switch (smallest)
         {
         case 0:
             if (dir[0]<0)
                 index[0] = std::floor(pos[0]);
             else
                 index[0] = std::ceil(pos[0]);
             index[1] = RoundToNearest(pos[1]);
             index[2] = RoundToNearest(pos[2]);
             break;
 
         case 1:
             if (dir[1]<0)
                 index[1] = std::floor(pos[1]);
             else
                 index[1] = std::ceil(pos[1]);
             index[0] = RoundToNearest(pos[0]);
             index[2] = RoundToNearest(pos[2]);
             break;
 
         case 2:
             if (dir[2]<0)
                 index[2] = std::floor(pos[2]);
             else
                 index[2] = std::ceil(pos[2]);
             index[1] = RoundToNearest(pos[1]);
             index[0] = RoundToNearest(pos[0]);
         }
 
 //        float x = 100000;
 //        if (dir[0]>0)
 //            x = fabs(pos[0]-RoundToNearest(pos[0])-0.5)/dir[0];
 //        else if (dir[0]<0)
 //            x = -fabs(pos[0]-RoundToNearest(pos[0])+0.5)/dir[0];
 //        float s = x;
 
 //        float y = 100000;
 //        if (dir[1]>0)
 //            y = fabs(pos[1]-RoundToNearest(pos[1])-0.5)/dir[1];
 //        else if (dir[1]<0)
 //            y = -fabs(pos[1]-RoundToNearest(pos[1])+0.5)/dir[1];
 //        if (s>y)
 //            s=y;
 
 //        float z = 100000;
 //        if (dir[2]>0)
 //            z = fabs(pos[2]-RoundToNearest(pos[2])-0.5)/dir[2];
 //        else if (dir[2]<0)
 //            z = -fabs(pos[2]-RoundToNearest(pos[2])+0.5)/dir[2];
 
 //        if (s>z)
 //            s=z;
 //        s *= 1.001;
 
 //        pos[0] += dir[0]*s;
 //        pos[1] += dir[1]*s;
 //        pos[2] += dir[2]*s;
 
 //        index[0] = RoundToNearest(pos[0]);
 //        index[1] = RoundToNearest(pos[1]);
 //        index[2] = RoundToNearest(pos[2]);
 
 //        MITK_INFO << "new: " << pos[0] << ", " << pos[1] << ", " << pos[2];
     }
 }
 
 template< class TTensorPixelType, class TPDPixelType>
 bool StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
 ::IsValidPosition(itk::ContinuousIndex<double, 3>& pos, typename InputImageType::IndexType &index, vnl_vector_fixed< float, 8 >& interpWeights)
 {
-    if (m_MaskImage->GetPixel(index)==0 || !m_InputImage->GetLargestPossibleRegion().IsInside(index))
+    if (!m_InputImage->GetLargestPossibleRegion().IsInside(index) || m_MaskImage->GetPixel(index)==0)
         return false;
 
     if (m_Interpolate)
     {
         float frac_x = pos[0] - index[0];
         float frac_y = pos[1] - index[1];
         float frac_z = pos[2] - index[2];
 
         if (frac_x<0)
         {
             index[0] -= 1;
             frac_x += 1;
         }
         if (frac_y<0)
         {
             index[1] -= 1;
             frac_y += 1;
         }
         if (frac_z<0)
         {
             index[2] -= 1;
             frac_z += 1;
         }
 
         frac_x = 1-frac_x;
         frac_y = 1-frac_y;
         frac_z = 1-frac_z;
 
         // int coordinates inside image?
         if (index[0] < 0 || index[0] >= m_ImageSize[0]-1)
             return false;
         if (index[1] < 0 || index[1] >= m_ImageSize[1]-1)
             return false;
         if (index[2] < 0 || index[2] >= m_ImageSize[2]-1)
             return false;
 
         interpWeights[0] = (  frac_x)*(  frac_y)*(  frac_z);
         interpWeights[1] = (1-frac_x)*(  frac_y)*(  frac_z);
         interpWeights[2] = (  frac_x)*(1-frac_y)*(  frac_z);
         interpWeights[3] = (  frac_x)*(  frac_y)*(1-frac_z);
         interpWeights[4] = (1-frac_x)*(1-frac_y)*(  frac_z);
         interpWeights[5] = (  frac_x)*(1-frac_y)*(1-frac_z);
         interpWeights[6] = (1-frac_x)*(  frac_y)*(1-frac_z);
         interpWeights[7] = (1-frac_x)*(1-frac_y)*(1-frac_z);
 
         typename InputImageType::IndexType tmpIdx;
         float FA = m_FaImage->GetPixel(index) * interpWeights[0];
         tmpIdx = index; tmpIdx[0]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[1];
         tmpIdx = index; tmpIdx[1]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[2];
         tmpIdx = index; tmpIdx[2]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[3];
         tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[4];
         tmpIdx = index; tmpIdx[1]++; tmpIdx[2]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[5];
         tmpIdx = index; tmpIdx[2]++; tmpIdx[0]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[6];
         tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
         FA +=  m_FaImage->GetPixel(tmpIdx) * interpWeights[7];
 
         if (FA<m_FaThreshold)
             return false;
     }
     else if (m_FaImage->GetPixel(index)<m_FaThreshold)
         return false;
 
     return true;
 }
 
 template< class TTensorPixelType, class TPDPixelType>
 float StreamlineTrackingFilter< TTensorPixelType, TPDPixelType>
 ::FollowStreamline(itk::ContinuousIndex<double, 3> pos, int dirSign, vtkPoints* points, std::vector< vtkIdType >& ids)
 {
     float tractLength = 0;
     typedef itk::DiffusionTensor3D<TTensorPixelType>    TensorType;
     typename TensorType::EigenValuesArrayType eigenvalues;
     typename TensorType::EigenVectorsMatrixType eigenvectors;
     vnl_vector_fixed< float, 8 > interpWeights;
 
     typename InputImageType::IndexType index, indexOld;
     indexOld[0] = -1; indexOld[1] = -1; indexOld[2] = -1;
     itk::Point<double> worldPos;
     float distance = 0;
     float distanceInVoxel = 0;
 
     // starting index and direction
     index[0] = RoundToNearest(pos[0]);
     index[1] = RoundToNearest(pos[1]);
     index[2] = RoundToNearest(pos[2]);
     vnl_vector_fixed<double,3> dir = m_PdImage->GetPixel(index);
     dir *= dirSign;                     // reverse direction
     vnl_vector_fixed<double,3> dirOld = dir;
     if (dir.magnitude()<mitk::eps)
         return tractLength;
 
     for (int step=0; step< m_MaxLength/2; step++)
     {
         // get new position
         CalculateNewPosition(pos, dir, index);
         distance += m_StepSize;
         tractLength +=  m_StepSize;
         distanceInVoxel += m_StepSize;
 
         // is new position valid (inside image, above FA threshold etc.)
         if (!IsValidPosition(pos, index, interpWeights))   // if not add last point and end streamline
         {
             m_InputImage->TransformContinuousIndexToPhysicalPoint( pos, worldPos );
             ids.push_back(points->InsertNextPoint(worldPos.GetDataPointer()));
             return tractLength;
         }
         else if (distance>=m_PointPistance)
         {
             m_InputImage->TransformContinuousIndexToPhysicalPoint( pos, worldPos );
             ids.push_back(points->InsertNextPoint(worldPos.GetDataPointer()));
             distance = 0;
         }
 
         if (!m_Interpolate)                         // use nearest neighbour interpolation
         {
             if (indexOld!=index)                    // did we enter a new voxel? if yes, calculate new direction
             {
                 dir = m_PdImage->GetPixel(index);   // get principal direction
 
                 typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index);
                 float scale = m_EmaxImage->GetPixel(index);
                 dir[0] = m_F*dir[0] + (1-m_F)*( (1-m_G)*dirOld[0] + scale*m_G*(tensor[0]*dirOld[0] + tensor[1]*dirOld[1] + tensor[2]*dirOld[2]));
                 dir[1] = m_F*dir[1] + (1-m_F)*( (1-m_G)*dirOld[1] + scale*m_G*(tensor[1]*dirOld[0] + tensor[3]*dirOld[1] + tensor[4]*dirOld[2]));
                 dir[2] = m_F*dir[2] + (1-m_F)*( (1-m_G)*dirOld[2] + scale*m_G*(tensor[2]*dirOld[0] + tensor[4]*dirOld[1] + tensor[5]*dirOld[2]));
                 dir.normalize();
 
                 float angle = dot_product(dirOld, dir);
                 if (angle<0)
                 {
                     dir *= -1;
                     angle *= -1;
                 }
 
                 float r = m_StepSize/(2*std::asin(std::acos(angle)/2));
                 if (r<m_MinCurvatureRadius)
                     return tractLength;
 
                 if (dir.magnitude()<mitk::eps)
                     dir = dirOld;
                 else
                     dirOld = dir;
                 indexOld = index;
                 distanceInVoxel = 0;
             }
             else
                 dir = dirOld;
         }
         else // use trilinear interpolation (weights calculated in IsValidPosition())
         {
             typename InputImageType::PixelType tensor = m_InputImage->GetPixel(index) * interpWeights[0];
             typename InputImageType::IndexType tmpIdx = index; tmpIdx[0]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[1];
             tmpIdx = index; tmpIdx[1]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[2];
             tmpIdx = index; tmpIdx[2]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[3];
             tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[4];
             tmpIdx = index; tmpIdx[1]++; tmpIdx[2]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[5];
             tmpIdx = index; tmpIdx[2]++; tmpIdx[0]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[6];
             tmpIdx = index; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
             tensor +=  m_InputImage->GetPixel(tmpIdx) * interpWeights[7];
 
             tensor.ComputeEigenAnalysis(eigenvalues, eigenvectors);
             dir[0] = eigenvectors(2, 0);
             dir[1] = eigenvectors(2, 1);
             dir[2] = eigenvectors(2, 2);
             dir.normalize();
 
             float scale = 2/eigenvalues[2];
             dir[0] = m_F*dir[0] + (1-m_F)*( (1-m_G)*dirOld[0] + scale*m_G*(tensor[0]*dirOld[0] + tensor[1]*dirOld[1] + tensor[2]*dirOld[2]));
             dir[1] = m_F*dir[1] + (1-m_F)*( (1-m_G)*dirOld[1] + scale*m_G*(tensor[1]*dirOld[0] + tensor[3]*dirOld[1] + tensor[4]*dirOld[2]));
             dir[2] = m_F*dir[2] + (1-m_F)*( (1-m_G)*dirOld[2] + scale*m_G*(tensor[2]*dirOld[0] + tensor[4]*dirOld[1] + tensor[5]*dirOld[2]));
             dir.normalize();
 
             float angle = dot_product(dirOld, dir);
             if (angle<0)
             {
                 dir *= -1;
                 angle *= -1;
             }
 
             float r = m_StepSize/(2*std::asin(std::acos(angle)/2));
             if (r<m_MinCurvatureRadius)
                 return tractLength;
 
             if (dir.magnitude()<mitk::eps)
                 dir = dirOld;
             else
                 dirOld = dir;
 
             indexOld = index;
         }
     }
     return tractLength;
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                        int threadId)
 {
     FiberPolyDataType poly = m_PolyDataContainer->GetElement(threadId);
     vtkSmartPointer<vtkPoints> points = vtkPoints::New();
     vtkSmartPointer<vtkCellArray> Cells = vtkCellArray::New();
 
     typedef itk::DiffusionTensor3D<TTensorPixelType>        TensorType;
     typedef ImageRegionConstIterator< InputImageType >      InputIteratorType;
     typedef ImageRegionConstIterator< ItkUcharImgType >     MaskIteratorType;
     typedef ImageRegionConstIterator< ItkFloatImgType >     FloatIteratorType;
     typedef typename InputImageType::PixelType              InputTensorType;
 
     InputIteratorType   it(m_InputImage, outputRegionForThread );
     MaskIteratorType    mit(m_SeedImage, outputRegionForThread );
     FloatIteratorType   fit(m_FaImage, outputRegionForThread );
     MaskIteratorType    mit2(m_MaskImage, outputRegionForThread );
 
 
     it.GoToBegin();
     mit.GoToBegin();
     mit2.GoToBegin();
     fit.GoToBegin();
     itk::Point<double> worldPos;
     while( !it.IsAtEnd() )
     {
         if (mit.Value()==0 || fit.Value()<m_FaThreshold || mit2.Value()==0)
         {
             ++mit;
             ++mit2;
             ++it;
             ++fit;
             continue;
         }
 
         for (int s=0; s<m_SeedsPerVoxel; s++)
         {
             vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
             std::vector< vtkIdType > pointIDs;
             typename InputImageType::IndexType index = it.GetIndex();
             itk::ContinuousIndex<double, 3> start;
             unsigned int counter = 0;
 
             if (m_SeedsPerVoxel>1)
             {
                 start[0] = index[0]+(double)(rand()%99-49)/100;
                 start[1] = index[1]+(double)(rand()%99-49)/100;
                 start[2] = index[2]+(double)(rand()%99-49)/100;
             }
             else
             {
                 start[0] = index[0];
                 start[1] = index[1];
                 start[2] = index[2];
             }
 
             // forward tracking
             float tractLength = FollowStreamline(start, 1, points, pointIDs);
 
             // add ids to line
             counter += pointIDs.size();
             while (!pointIDs.empty())
             {
                 line->GetPointIds()->InsertNextId(pointIDs.back());
                 pointIDs.pop_back();
             }
 
             // insert start point
             m_InputImage->TransformContinuousIndexToPhysicalPoint( start, worldPos );
             line->GetPointIds()->InsertNextId(points->InsertNextPoint(worldPos.GetDataPointer()));
 
             // backward tracking
             tractLength += FollowStreamline(start, -1, points, pointIDs);
 
             counter += pointIDs.size();
 
             if (tractLength<m_MinTractLength || counter<2)
                 continue;
 
             // add ids to line
             for (int i=0; i<pointIDs.size(); i++)
                 line->GetPointIds()->InsertNextId(pointIDs.at(i));
 
             Cells->InsertNextCell(line);
         }
         ++mit;
         ++mit2;
         ++it;
         ++fit;
     }
     poly->SetPoints(points);
     poly->SetLines(Cells);
 
     std::cout << "Thread " << threadId << " finished tracking" << std::endl;
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 vtkSmartPointer< vtkPolyData > StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::AddPolyData(FiberPolyDataType poly1, FiberPolyDataType poly2)
 {
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = poly1->GetLines();
     vtkSmartPointer<vtkPoints> vNewPoints = poly1->GetPoints();
 
     vtkSmartPointer<vtkCellArray> vLines = poly2->GetLines();
     vLines->InitTraversal();
     for( int i=0; i<vLines->GetNumberOfCells(); i++ )
     {
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for( int j=0; j<numPoints; j++)
         {
             vtkIdType id = vNewPoints->InsertNextPoint(poly2->GetPoint(points[j]));
             container->GetPointIds()->InsertNextId(id);
         }
         vNewLines->InsertNextCell(container);
     }
 
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     return vNewPolyData;
 }
 template< class TTensorPixelType,
           class TPDPixelType>
 void StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::AfterThreadedGenerateData()
 {
     MITK_INFO << "Generating polydata ";
     m_FiberPolyData = m_PolyDataContainer->GetElement(0);
     for (int i=1; i<this->GetNumberOfThreads(); i++)
     {
         m_FiberPolyData = AddPolyData(m_FiberPolyData, m_PolyDataContainer->GetElement(i));
     }
     MITK_INFO << "done";
 }
 
 template< class TTensorPixelType,
           class TPDPixelType>
 void StreamlineTrackingFilter< TTensorPixelType,
 TPDPixelType>
 ::PrintSelf(std::ostream& os, Indent indent) const
 {
 }
 
 }
 #endif // __itkDiffusionQballPrincipleDirectionsImageFilter_txx
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
index fbb9f9eb44..7ffc32adae 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkGibbsTrackingView.cpp
@@ -1,747 +1,747 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkGibbsTrackingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QDir>
 
 // MITK
 #include <mitkImageCast.h>
 #include <mitkImageToItk.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkProgressBar.h>
 #include <mitkFiberBundleXWriter.h>
 
 // ITK
 #include <itkGibbsTrackingFilter.h>
 #include <itkResampleImageFilter.h>
 #include <itksys/SystemTools.hxx>
 
 // MISC
 #include <tinyxml.h>
 
 
 QmitkTrackingWorker::QmitkTrackingWorker(QmitkGibbsTrackingView* view)
     : m_View(view)
 {
 
 }
 
 void QmitkTrackingWorker::run()
 {
     m_View->m_GlobalTracker = QmitkGibbsTrackingView::GibbsTrackingFilterType::New();
 
     m_View->m_GlobalTracker->SetQBallImage(m_View->m_ItkQBallImage);
     m_View->m_GlobalTracker->SetTensorImage(m_View->m_ItkTensorImage);
     m_View->m_GlobalTracker->SetMaskImage(m_View->m_MaskImage);
     m_View->m_GlobalTracker->SetStartTemperature((float)m_View->m_Controls->m_StartTempSlider->value()/100);
     m_View->m_GlobalTracker->SetEndTemperature((float)m_View->m_Controls->m_EndTempSlider->value()/10000);
     m_View->m_GlobalTracker->SetIterations(m_View->m_Iterations);
     m_View->m_GlobalTracker->SetParticleWeight((float)m_View->m_Controls->m_ParticleWeightSlider->value()/10000);
     m_View->m_GlobalTracker->SetParticleWidth((float)(m_View->m_Controls->m_ParticleWidthSlider->value())/10);
     m_View->m_GlobalTracker->SetParticleLength((float)(m_View->m_Controls->m_ParticleLengthSlider->value())/10);
     m_View->m_GlobalTracker->SetInexBalance((float)m_View->m_Controls->m_InExBalanceSlider->value()/10);
     m_View->m_GlobalTracker->SetMinFiberLength(m_View->m_Controls->m_FiberLengthSlider->value());
     m_View->m_GlobalTracker->SetCurvatureThreshold(cos((float)m_View->m_Controls->m_CurvatureThresholdSlider->value()*M_PI/180));
     m_View->m_GlobalTracker->SetRandomSeed(m_View->m_Controls->m_RandomSeedSlider->value());
 
     m_View->m_GlobalTracker->Update();
     m_View->m_TrackingThread.quit();
 }
 
 const std::string QmitkGibbsTrackingView::VIEW_ID =
         "org.mitk.views.gibbstracking";
 
 QmitkGibbsTrackingView::QmitkGibbsTrackingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_ThreadIsRunning(false)
     , m_GlobalTracker(NULL)
     , m_QBallImage(NULL)
     , m_MaskImage(NULL)
     , m_ImageNode(NULL)
     , m_ItkQBallImage(NULL)
     , m_ItkTensorImage(NULL)
     , m_FiberBundleNode(NULL)
     , m_MaskImageNode(NULL)
     , m_TrackingWorker(this)
     , m_Iterations(10000000)
     , m_LastStep(0)
 {
     m_TrackingWorker.moveToThread(&m_TrackingThread);
     connect(&m_TrackingThread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_TrackingThread, SIGNAL(started()), &m_TrackingWorker, SLOT(run()));
     connect(&m_TrackingThread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_TrackingThread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_TrackingTimer = new QTimer(this);
 }
 
 QmitkGibbsTrackingView::~QmitkGibbsTrackingView()
 {
     delete m_TrackingTimer;
 }
 
 // update tracking status and generate fiber bundle
 void QmitkGibbsTrackingView::TimerUpdate()
 {
     int currentStep = m_GlobalTracker->GetCurrentStep();
     mitk::ProgressBar::GetInstance()->Progress(currentStep-m_LastStep);
     UpdateTrackingStatus();
     GenerateFiberBundle();
     m_LastStep = currentStep;
 }
 
 // tell global tractography filter to stop after current step
 void QmitkGibbsTrackingView::StopGibbsTracking()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     //mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     m_GlobalTracker->SetAbortTracking(true);
     m_Controls->m_TrackingStop->setEnabled(false);
     m_Controls->m_TrackingStop->setText("Stopping Tractography ...");
 }
 
 // update gui elements and generate fiber bundle after tracking is finished
 void QmitkGibbsTrackingView::AfterThread()
 {
     m_ThreadIsRunning = false;
     m_TrackingTimer->stop();
 
     mitk::ProgressBar::GetInstance()->Progress(m_GlobalTracker->GetSteps()-m_LastStep+1);
     UpdateGUI();
     UpdateTrackingStatus();
 
     if(m_Controls->m_ParticleWeightSlider->value()==0)
     {
         m_Controls->m_ParticleWeightLabel->setText(QString::number(m_GlobalTracker->GetParticleWeight()));
         m_Controls->m_ParticleWeightSlider->setValue(m_GlobalTracker->GetParticleWeight()*10000);
     }
     if(m_Controls->m_ParticleWidthSlider->value()==0)
     {
         m_Controls->m_ParticleWidthLabel->setText(QString::number(m_GlobalTracker->GetParticleWidth()));
         m_Controls->m_ParticleWidthSlider->setValue(m_GlobalTracker->GetParticleWidth()*10);
     }
     if(m_Controls->m_ParticleLengthSlider->value()==0)
     {
         m_Controls->m_ParticleLengthLabel->setText(QString::number(m_GlobalTracker->GetParticleLength()));
         m_Controls->m_ParticleLengthSlider->setValue(m_GlobalTracker->GetParticleLength()*10);
     }
 
     GenerateFiberBundle();
     m_FiberBundleNode = NULL;
 }
 
 // start tracking timer and update gui elements before tracking is started
 void QmitkGibbsTrackingView::BeforeThread()
 {
     m_ThreadIsRunning = true;
     m_TrackingTime = QTime::currentTime();
     m_ElapsedTime = 0;
     m_TrackingTimer->start(1000);
     m_LastStep = 0;
 
     UpdateGUI();
 }
 
 // setup gui elements and signal/slot connections
 void QmitkGibbsTrackingView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkGibbsTrackingViewControls;
         m_Controls->setupUi( parent );
 
         AdvancedSettings();
 
         connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(TimerUpdate()) );
         connect( m_Controls->m_TrackingStop, SIGNAL(clicked()), this, SLOT(StopGibbsTracking()) );
         connect( m_Controls->m_TrackingStart, SIGNAL(clicked()), this, SLOT(StartGibbsTracking()) );
         connect( m_Controls->m_AdvancedSettingsCheckbox, SIGNAL(clicked()), this, SLOT(AdvancedSettings()) );
         connect( m_Controls->m_SaveTrackingParameters, SIGNAL(clicked()), this, SLOT(SaveTrackingParameters()) );
         connect( m_Controls->m_LoadTrackingParameters, SIGNAL(clicked()), this, SLOT(LoadTrackingParameters()) );
         connect( m_Controls->m_IterationsSlider, SIGNAL(valueChanged(int)), this, SLOT(SetIterations(int)) );
         connect( m_Controls->m_ParticleWidthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWidth(int)) );
         connect( m_Controls->m_ParticleLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleLength(int)) );
         connect( m_Controls->m_InExBalanceSlider, SIGNAL(valueChanged(int)), this, SLOT(SetInExBalance(int)) );
         connect( m_Controls->m_FiberLengthSlider, SIGNAL(valueChanged(int)), this, SLOT(SetFiberLength(int)) );
         connect( m_Controls->m_ParticleWeightSlider, SIGNAL(valueChanged(int)), this, SLOT(SetParticleWeight(int)) );
         connect( m_Controls->m_StartTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetStartTemp(int)) );
         connect( m_Controls->m_EndTempSlider, SIGNAL(valueChanged(int)), this, SLOT(SetEndTemp(int)) );
         connect( m_Controls->m_CurvatureThresholdSlider, SIGNAL(valueChanged(int)), this, SLOT(SetCurvatureThreshold(int)) );
         connect( m_Controls->m_RandomSeedSlider, SIGNAL(valueChanged(int)), this, SLOT(SetRandomSeed(int)) );
         connect( m_Controls->m_OutputFileButton, SIGNAL(clicked()), this, SLOT(SetOutputFile()) );
     }
 }
 
 void QmitkGibbsTrackingView::SetInExBalance(int value)
 {
     m_Controls->m_InExBalanceLabel->setText(QString::number((float)value/10));
 }
 
 void QmitkGibbsTrackingView::SetFiberLength(int value)
 {
     m_Controls->m_FiberLengthLabel->setText(QString::number(value)+"mm");
 }
 
 void QmitkGibbsTrackingView::SetRandomSeed(int value)
 {
     if (value>=0)
         m_Controls->m_RandomSeedLabel->setText(QString::number(value));
     else
         m_Controls->m_RandomSeedLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleWeight(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWeightLabel->setText(QString::number((float)value/10000));
     else
         m_Controls->m_ParticleWeightLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetStartTemp(int value)
 {
     m_Controls->m_StartTempLabel->setText(QString::number((float)value/100));
 }
 
 void QmitkGibbsTrackingView::SetEndTemp(int value)
 {
     m_Controls->m_EndTempLabel->setText(QString::number((float)value/10000));
 }
 
 void QmitkGibbsTrackingView::SetParticleWidth(int value)
 {
     if (value>0)
         m_Controls->m_ParticleWidthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleWidthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetParticleLength(int value)
 {
     if (value>0)
         m_Controls->m_ParticleLengthLabel->setText(QString::number((float)value/10)+" mm");
     else
         m_Controls->m_ParticleLengthLabel->setText("auto");
 }
 
 void QmitkGibbsTrackingView::SetCurvatureThreshold(int value)
 {
     m_Controls->m_CurvatureThresholdLabel->setText(QString::number(value)+"°");
 }
 
 void QmitkGibbsTrackingView::SetIterations(int value)
 {
     switch(value)
     {
     case 0:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^4");
         m_Iterations = 10000;
         break;
     case 1:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         m_Iterations = 50000;
         break;
     case 2:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^5");
         m_Iterations = 100000;
         break;
     case 3:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         m_Iterations = 500000;
         break;
     case 4:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^6");
         m_Iterations = 1000000;
         break;
     case 5:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         m_Iterations = 5000000;
         break;
     case 6:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^7");
         m_Iterations = 10000000;
         break;
     case 7:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         m_Iterations = 50000000;
         break;
     case 8:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^8");
         m_Iterations = 100000000;
         break;
     case 9:
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         m_Iterations = 500000000;
         break;
     case 10:
         m_Controls->m_IterationsLabel->setText("Iterations: 1x10^9");
         m_Iterations = 1000000000;
         break;
     }
 
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetAvailable(QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkGibbsTrackingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 // called if datamanager selection changes
 void QmitkGibbsTrackingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     if (m_ThreadIsRunning)
         return;
 
     m_ImageNode = NULL;
     m_MaskImageNode = NULL;
 
     // iterate all selected objects
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if( node.IsNotNull() && dynamic_cast<mitk::QBallImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::TensorImage*>(node->GetData()) )
             m_ImageNode = node;
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
     }
 
     UpdateGUI();
 }
 
 // update gui elements displaying trackings status
 void QmitkGibbsTrackingView::UpdateTrackingStatus()
 {
     if (m_GlobalTracker.IsNull())
         return;
 
     m_ElapsedTime += m_TrackingTime.elapsed()/1000;
     m_TrackingTime.restart();
     unsigned long hours = m_ElapsedTime/3600;
     unsigned long minutes = (m_ElapsedTime%3600)/60;
     unsigned long seconds = m_ElapsedTime%60;
 
     m_Controls->m_ProposalAcceptance->setText(QString::number(m_GlobalTracker->GetProposalAcceptance()*100)+"%");
 
     m_Controls->m_TrackingTimeLabel->setText( QString::number(hours)+QString("h ")+QString::number(minutes)+QString("m ")+QString::number(seconds)+QString("s") );
     m_Controls->m_NumConnectionsLabel->setText( QString::number(m_GlobalTracker->GetNumConnections()) );
     m_Controls->m_NumParticlesLabel->setText( QString::number(m_GlobalTracker->GetNumParticles()) );
     m_Controls->m_CurrentStepLabel->setText( QString::number(100*(float)(m_GlobalTracker->GetCurrentStep()-1)/m_GlobalTracker->GetSteps())+"%" );
     m_Controls->m_AcceptedFibersLabel->setText( QString::number(m_GlobalTracker->GetNumAcceptedFibers()) );
 }
 
 // update gui elements (enable/disable elements and set tooltips)
 void QmitkGibbsTrackingView::UpdateGUI()
 {
     if (m_ImageNode.IsNotNull())
         m_Controls->m_QballImageLabel->setText(m_ImageNode->GetName().c_str());
     else
         m_Controls->m_QballImageLabel->setText("-");
     if (m_MaskImageNode.IsNotNull())
         m_Controls->m_MaskImageLabel->setText(m_MaskImageNode->GetName().c_str());
     else
         m_Controls->m_MaskImageLabel->setText("-");
 
     if (!m_ThreadIsRunning && m_ImageNode.IsNotNull())
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(true);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("Start tractography. No further change of parameters possible.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else if (!m_ThreadIsRunning)
     {
         m_Controls->m_TrackingStop->setEnabled(false);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(true);
         m_Controls->m_IterationsSlider->setEnabled(true);
         m_Controls->m_AdvancedFrame->setEnabled(true);
         m_Controls->m_TrackingStop->setText("Stop Tractography");
         m_Controls->m_TrackingStart->setToolTip("No Q-Ball image selected.");
         m_Controls->m_TrackingStop->setToolTip("");
     }
     else
     {
         m_Controls->m_TrackingStop->setEnabled(true);
         m_Controls->m_TrackingStart->setEnabled(false);
         m_Controls->m_LoadTrackingParameters->setEnabled(false);
         m_Controls->m_IterationsSlider->setEnabled(false);
         m_Controls->m_AdvancedFrame->setEnabled(false);
         m_Controls->m_AdvancedFrame->setVisible(false);
         m_Controls->m_AdvancedSettingsCheckbox->setChecked(false);
         m_Controls->m_TrackingStart->setToolTip("Tracking in progress.");
         m_Controls->m_TrackingStop->setToolTip("Stop tracking and display results.");
     }
 }
 
 // show/hide advanced settings frame
 void QmitkGibbsTrackingView::AdvancedSettings()
 {
     m_Controls->m_AdvancedFrame->setVisible(m_Controls->m_AdvancedSettingsCheckbox->isChecked());
 }
 
 // set mask image data node
 void QmitkGibbsTrackingView::SetMask()
 {
     std::vector<mitk::DataNode*> nodes = GetDataManagerSelection();
     if (nodes.empty())
     {
         m_MaskImageNode = NULL;
         m_Controls->m_MaskImageLabel->setText("-");
         return;
     }
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin();
          it != nodes.end();
          ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if (node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_MaskImageNode = node;
             m_Controls->m_MaskImageLabel->setText(node->GetName().c_str());
             return;
         }
     }
 }
 
 // cast image to float
 template<class InputImageType>
 void QmitkGibbsTrackingView::CastToFloat(InputImageType* image, mitk::Image::Pointer outImage)
 {
     typedef itk::CastImageFilter<InputImageType, ItkFloatImageType> ItkCastFilter;
     typename ItkCastFilter::Pointer itkCaster = ItkCastFilter::New();
     itkCaster->SetInput(image);
     itkCaster->Update();
     outImage->InitializeByItk(itkCaster->GetOutput());
     outImage->SetVolume(itkCaster->GetOutput()->GetBufferPointer());
 }
 
 // check for mask and qbi and start tracking thread
 void QmitkGibbsTrackingView::StartGibbsTracking()
 {
     if(m_ThreadIsRunning)
     {
         MITK_WARN("QmitkGibbsTrackingView")<<"Thread already running!";
         return;
     }
 
     if (m_ImageNode.IsNull())
     {
         QMessageBox::information( NULL, "Warning", "Please load and select a qball image before starting image processing.");
         return;
     }
 
     if (dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData()))
         m_QBallImage = dynamic_cast<mitk::QBallImage*>(m_ImageNode->GetData());
     else if (dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData()))
         m_TensorImage = dynamic_cast<mitk::TensorImage*>(m_ImageNode->GetData());
 
     if (m_QBallImage.IsNull() && m_TensorImage.IsNull())
         return;
 
     // cast qbi to itk
     m_ItkTensorImage = NULL;
     m_ItkQBallImage = NULL;
     m_MaskImage = NULL;
 
     if (m_QBallImage.IsNotNull())
     {
         m_ItkQBallImage = ItkQBallImgType::New();
         mitk::CastToItkImage<ItkQBallImgType>(m_QBallImage, m_ItkQBallImage);
     }
     else
     {
         m_ItkTensorImage = ItkTensorImage::New();
         mitk::CastToItkImage<ItkTensorImage>(m_TensorImage, m_ItkTensorImage);
     }
 
     // mask image found?
     // catch exceptions thrown by the itkAccess macros
     try{
         if(m_MaskImageNode.IsNotNull())
         {
             if (dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()))
                 mitk::CastToItkImage<ItkFloatImageType>(dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData()), m_MaskImage);
         }
     }
     catch(...){};
 
     unsigned int steps = m_Iterations/10000;
     if (steps<10)
         steps = 10;
 
     m_LastStep = 1;
     mitk::ProgressBar::GetInstance()->AddStepsToDo(steps);
 
     // start worker thread
     m_TrackingThread.start(QThread::LowestPriority);
 }
 
 // generate mitkFiberBundle from tracking filter output
 void QmitkGibbsTrackingView::GenerateFiberBundle()
 {
     if (m_GlobalTracker.IsNull() || (!(m_Controls->m_VisualizationCheckbox->isChecked() || m_Controls->m_VisualizeOnceButton->isChecked()) && m_ThreadIsRunning))
         return;
 
     if (m_Controls->m_VisualizeOnceButton->isChecked())
         m_Controls->m_VisualizeOnceButton->setChecked(false);
 
     vtkSmartPointer<vtkPolyData> fiberBundle = m_GlobalTracker->GetFiberBundle();
     if ( m_GlobalTracker->GetNumAcceptedFibers()==0 )
         return;
     m_FiberBundle = mitk::FiberBundleX::New(fiberBundle);
 
     if (m_FiberBundleNode.IsNotNull()){
         GetDefaultDataStorage()->Remove(m_FiberBundleNode);
         m_FiberBundleNode = 0;
     }
     m_FiberBundleNode = mitk::DataNode::New();
     m_FiberBundleNode->SetData(m_FiberBundle);
 
     QString name(m_ImageNode->GetName().c_str());
-    name += "_FiberBundle";
+    name += "_Gibbs";
     m_FiberBundleNode->SetName(name.toStdString());
     m_FiberBundleNode->SetVisibility(true);
 
     if (!m_OutputFileName.isEmpty())
     {
         QString filename = m_OutputFileName;
         mitk::FiberBundleXWriter::Pointer writer = mitk::FiberBundleXWriter::New();
         writer->SetFileName(filename.toStdString());
         writer->SetInputFiberBundleX(m_FiberBundle.GetPointer());
         try
         {
             writer->Update();
             QMessageBox::information(NULL, "Fiber bundle saved to", filename);
         }
         catch (itk::ExceptionObject &ex)
         {
             QMessageBox::information(NULL, "Fiber bundle could not be saved", QString("%1\n%2\n%3\n%4\n%5\n%6").arg(ex.GetNameOfClass()).arg(ex.GetFile()).arg(ex.GetLine()).arg(ex.GetLocation()).arg(ex.what()).arg(ex.GetDescription()));
 
             if(m_ImageNode.IsNull())
                 GetDataStorage()->Add(m_FiberBundleNode);
             else
                 GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
         }
     }
     else {
         if(m_ImageNode.IsNull())
             GetDataStorage()->Add(m_FiberBundleNode);
         else
             GetDataStorage()->Add(m_FiberBundleNode, m_ImageNode);
     }
 }
 
 void QmitkGibbsTrackingView::SetOutputFile()
 {
     // SELECT FOLDER DIALOG
     m_OutputFileName = QFileDialog::getSaveFileName(0,
                                                     tr("Set file name"),
                                                     QDir::currentPath()+"/FiberBundle.fib",
                                                     tr("Fiber Bundle (*.fib)") );
     if (m_OutputFileName.isEmpty())
         m_Controls->m_OutputFileLabel->setText("N/A");
     else
         m_Controls->m_OutputFileLabel->setText(m_OutputFileName);
 }
 
 // save current tracking paramters as xml file (.gtp)
 void QmitkGibbsTrackingView::SaveTrackingParameters()
 {
     TiXmlDocument documentXML;
     TiXmlDeclaration* declXML = new TiXmlDeclaration( "1.0", "", "" );
     documentXML.LinkEndChild( declXML );
 
     TiXmlElement* mainXML = new TiXmlElement("global_tracking_parameter_file");
     mainXML->SetAttribute("file_version",  "0.1");
     documentXML.LinkEndChild(mainXML);
 
     TiXmlElement* paramXML = new TiXmlElement("parameter_set");
     paramXML->SetAttribute("iterations", QString::number(m_Iterations).toStdString());
     paramXML->SetAttribute("particle_length", QString::number((float)m_Controls->m_ParticleLengthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_width", QString::number((float)m_Controls->m_ParticleWidthSlider->value()/10).toStdString());
     paramXML->SetAttribute("particle_weight", QString::number((float)m_Controls->m_ParticleWeightSlider->value()/10000).toStdString());
     paramXML->SetAttribute("temp_start", QString::number((float)m_Controls->m_StartTempSlider->value()/100).toStdString());
     paramXML->SetAttribute("temp_end", QString::number((float)m_Controls->m_EndTempSlider->value()/10000).toStdString());
     paramXML->SetAttribute("inexbalance", QString::number((float)m_Controls->m_InExBalanceSlider->value()/10).toStdString());
     paramXML->SetAttribute("fiber_length", QString::number(m_Controls->m_FiberLengthSlider->value()).toStdString());
     paramXML->SetAttribute("curvature_threshold", QString::number(m_Controls->m_CurvatureThresholdSlider->value()).toStdString());
     mainXML->LinkEndChild(paramXML);
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 QDir::currentPath()+"/param.gtp",
                 tr("Global Tracking Parameters (*.gtp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".gtp"))
         filename += ".gtp";
     documentXML.SaveFile( filename.toStdString() );
 }
 
 void QmitkGibbsTrackingView::UpdateIteraionsGUI(unsigned long iterations)
 {
     switch(iterations)
     {
     case 10000:
         m_Controls->m_IterationsSlider->setValue(0);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^4");
         break;
     case 50000:
         m_Controls->m_IterationsSlider->setValue(1);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^4");
         break;
     case 100000:
         m_Controls->m_IterationsSlider->setValue(2);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^5");
         break;
     case 500000:
         m_Controls->m_IterationsSlider->setValue(3);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^5");
         break;
     case 1000000:
         m_Controls->m_IterationsSlider->setValue(4);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^6");
         break;
     case 5000000:
         m_Controls->m_IterationsSlider->setValue(5);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^6");
         break;
     case 10000000:
         m_Controls->m_IterationsSlider->setValue(6);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^7");
         break;
     case 50000000:
         m_Controls->m_IterationsSlider->setValue(7);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^7");
         break;
     case 100000000:
         m_Controls->m_IterationsSlider->setValue(8);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^8");
         break;
     case 500000000:
         m_Controls->m_IterationsSlider->setValue(9);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^8");
         break;
     case 1000000000:
         m_Controls->m_IterationsSlider->setValue(10);
         m_Controls->m_IterationsLabel->setText("Iterations: 10^9");
         break;
     case 5000000000:
         m_Controls->m_IterationsSlider->setValue(11);
         m_Controls->m_IterationsLabel->setText("Iterations: 5x10^9");
         break;
     }
 }
 
 // load current tracking paramters from xml file (.gtp)
 void QmitkGibbsTrackingView::LoadTrackingParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QDir::currentPath(), tr("Global Tracking Parameters (*.gtp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     TiXmlDocument doc( filename.toStdString() );
     doc.LoadFile();
 
     TiXmlHandle hDoc(&doc);
     TiXmlElement* pElem;
     TiXmlHandle hRoot(0);
 
     pElem = hDoc.FirstChildElement().Element();
     hRoot = TiXmlHandle(pElem);
     pElem = hRoot.FirstChildElement("parameter_set").Element();
 
     QString iterations(pElem->Attribute("iterations"));
     m_Iterations = iterations.toULong();
     UpdateIteraionsGUI(m_Iterations);
 
     QString particleLength(pElem->Attribute("particle_length"));
     float pLength = particleLength.toFloat();
     QString particleWidth(pElem->Attribute("particle_width"));
     float pWidth = particleWidth.toFloat();
 
     if (pLength==0)
         m_Controls->m_ParticleLengthLabel->setText("auto");
     else
         m_Controls->m_ParticleLengthLabel->setText(particleLength+" mm");
     if (pWidth==0)
         m_Controls->m_ParticleWidthLabel->setText("auto");
     else
         m_Controls->m_ParticleWidthLabel->setText(particleWidth+" mm");
 
     m_Controls->m_ParticleWidthSlider->setValue(pWidth*10);
     m_Controls->m_ParticleLengthSlider->setValue(pLength*10);
 
     QString partWeight(pElem->Attribute("particle_weight"));
     m_Controls->m_ParticleWeightSlider->setValue(partWeight.toFloat()*10000);
     m_Controls->m_ParticleWeightLabel->setText(partWeight);
 
     QString startTemp(pElem->Attribute("temp_start"));
     m_Controls->m_StartTempSlider->setValue(startTemp.toFloat()*100);
     m_Controls->m_StartTempLabel->setText(startTemp);
 
     QString endTemp(pElem->Attribute("temp_end"));
     m_Controls->m_EndTempSlider->setValue(endTemp.toFloat()*10000);
     m_Controls->m_EndTempLabel->setText(endTemp);
 
     QString inExBalance(pElem->Attribute("inexbalance"));
     m_Controls->m_InExBalanceSlider->setValue(inExBalance.toFloat()*10);
     m_Controls->m_InExBalanceLabel->setText(inExBalance);
 
     QString fiberLength(pElem->Attribute("fiber_length"));
     m_Controls->m_FiberLengthSlider->setValue(fiberLength.toInt());
     m_Controls->m_FiberLengthLabel->setText(fiberLength+"mm");
 
     QString curvThres(pElem->Attribute("curvature_threshold"));
     m_Controls->m_CurvatureThresholdSlider->setValue(curvThres.toInt());
     m_Controls->m_CurvatureThresholdLabel->setText(curvThres+"°");
 }