diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
index 565642074f..e99edd4cad 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.cpp
@@ -1,253 +1,254 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Coindex[1]right (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 "itkTractDensityImageFilter.h"
 
 // VTK
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkCell.h>
 
 // misc
 #include <math.h>
 #include <boost/progress.hpp>
 
 namespace itk{
 
 template< class OutputImageType >
 TractDensityImageFilter< OutputImageType >::TractDensityImageFilter()
     : m_InvertImage(false)
     , m_FiberBundle(NULL)
     , m_UpsamplingFactor(1)
     , m_InputImage(NULL)
     , m_BinaryOutput(false)
     , m_UseImageGeometry(false)
     , m_OutputAbsoluteValues(false)
     , m_UseTrilinearInterpolation(false)
     , m_DoFiberResampling(true)
     , m_WorkOnFiberCopy(true)
+    , m_MaxDensity(0)
 {
 
 }
 
 template< class OutputImageType >
 TractDensityImageFilter< OutputImageType >::~TractDensityImageFilter()
 {
 }
 
 template< class OutputImageType >
 itk::Point<float, 3> TractDensityImageFilter< OutputImageType >::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class OutputImageType >
 void TractDensityImageFilter< OutputImageType >::GenerateData()
 {
     // generate upsampled image
     mitk::BaseGeometry::Pointer geometry = m_FiberBundle->GetGeometry();
     typename OutputImageType::Pointer outImage = this->GetOutput();
 
     // calculate new image parameters
     itk::Vector<double,3> newSpacing;
     mitk::Point3D newOrigin;
     itk::Matrix<double, 3, 3> newDirection;
     ImageRegion<3> upsampledRegion;
     if (m_UseImageGeometry && !m_InputImage.IsNull())
     {
         MITK_INFO << "TractDensityImageFilter: using image geometry";
         newSpacing = m_InputImage->GetSpacing()/m_UpsamplingFactor;
         upsampledRegion = m_InputImage->GetLargestPossibleRegion();
         newOrigin = m_InputImage->GetOrigin();
         typename OutputImageType::RegionType::SizeType size = upsampledRegion.GetSize();
         size[0] *= m_UpsamplingFactor;
         size[1] *= m_UpsamplingFactor;
         size[2] *= m_UpsamplingFactor;
         upsampledRegion.SetSize(size);
         newDirection = m_InputImage->GetDirection();
     }
     else
     {
         MITK_INFO << "TractDensityImageFilter: using fiber bundle geometry";
         newSpacing = geometry->GetSpacing()/m_UpsamplingFactor;
         newOrigin = geometry->GetOrigin();
         mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
 
         // we retrieve the origin from a vtk-polydata (corner-based) and hance have to translate it to an image geometry
         // i.e. center-based
         newOrigin[0] += bounds.GetElement(0) + 0.5 * newSpacing[0];
         newOrigin[1] += bounds.GetElement(2) + 0.5 * newSpacing[1];
         newOrigin[2] += bounds.GetElement(4) + 0.5 * newSpacing[2];
 
         for (int i=0; i<3; i++)
             for (int j=0; j<3; j++)
                 newDirection[j][i] = geometry->GetMatrixColumn(i)[j];
         upsampledRegion.SetSize(0, ceil( geometry->GetExtent(0)*m_UpsamplingFactor ) );
         upsampledRegion.SetSize(1, ceil( geometry->GetExtent(1)*m_UpsamplingFactor ) );
         upsampledRegion.SetSize(2, ceil( geometry->GetExtent(2)*m_UpsamplingFactor ) );
     }
     typename OutputImageType::RegionType::SizeType upsampledSize = upsampledRegion.GetSize();
 
     // apply new image parameters
     outImage->SetSpacing( newSpacing );
     outImage->SetOrigin( newOrigin );
     outImage->SetDirection( newDirection );
     outImage->SetLargestPossibleRegion( upsampledRegion );
     outImage->SetBufferedRegion( upsampledRegion );
     outImage->SetRequestedRegion( upsampledRegion );
     outImage->Allocate();
     outImage->FillBuffer(0.0);
 
     int w = upsampledSize[0];
     int h = upsampledSize[1];
     int d = upsampledSize[2];
 
     // set/initialize output
     OutPixelType* outImageBufferPointer = (OutPixelType*)outImage->GetBufferPointer();
 
     // resample fiber bundle
     float minSpacing = 1;
     if(newSpacing[0]<newSpacing[1] && newSpacing[0]<newSpacing[2])
         minSpacing = newSpacing[0];
     else if (newSpacing[1] < newSpacing[2])
         minSpacing = newSpacing[1];
     else
         minSpacing = newSpacing[2];
 
     MITK_INFO << "TractDensityImageFilter: resampling fibers to ensure sufficient voxel coverage";
     if (m_DoFiberResampling)
     {
       if (m_WorkOnFiberCopy)
         m_FiberBundle = m_FiberBundle->GetDeepCopy();
       m_FiberBundle->ResampleSpline(minSpacing/10);
     }
 
     MITK_INFO << "TractDensityImageFilter: starting image generation";
 
     vtkSmartPointer<vtkPolyData> fiberPolyData = m_FiberBundle->GetFiberPolyData();
     vtkSmartPointer<vtkCellArray> vLines = fiberPolyData->GetLines();
     vLines->InitTraversal();
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers);
     for( int i=0; i<numFibers; i++ )
     {
         ++disp;
         vtkIdType   numPoints(0);
         vtkIdType*  points(NULL);
         vLines->GetNextCell ( numPoints, points );
         float weight = m_FiberBundle->GetFiberWeight(i);
 
         // fill output image
         for( int j=0; j<numPoints; j++)
         {
             itk::Point<float, 3> vertex = GetItkPoint(fiberPolyData->GetPoint(points[j]));
             itk::Index<3> index;
             itk::ContinuousIndex<float, 3> contIndex;
             outImage->TransformPhysicalPointToIndex(vertex, index);
             outImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
             if (!m_UseTrilinearInterpolation && outImage->GetLargestPossibleRegion().IsInside(index))
             {
                 if (m_BinaryOutput)
                     outImage->SetPixel(index, 1);
                 else
                     outImage->SetPixel(index, outImage->GetPixel(index)+0.01*weight);
                 continue;
             }
 
             float frac_x = contIndex[0] - index[0];
             float frac_y = contIndex[1] - index[1];
             float frac_z = contIndex[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] >= w-1)
                 continue;
             if (index[1] < 0 || index[1] >= h-1)
                 continue;
             if (index[2] < 0 || index[2] >= d-1)
                 continue;
 
             if (m_BinaryOutput)
             {
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]+h))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]  ))] = 1;
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] = 1;
             }
             else
             {
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]  ))] += (  frac_x)*(  frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]  ))] += (  frac_x)*(1-frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]  + h*index[2]+h))] += (  frac_x)*(  frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]   + w*(index[1]+1+ h*index[2]+h))] += (  frac_x)*(1-frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]  ))] += (1-frac_x)*(  frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]  + h*index[2]+h))] += (1-frac_x)*(  frac_y)*(1-frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]  ))] += (1-frac_x)*(1-frac_y)*(  frac_z);
                 outImageBufferPointer[( index[0]+1 + w*(index[1]+1+ h*index[2]+h))] += (1-frac_x)*(1-frac_y)*(1-frac_z);
             }
         }
     }
 
+    m_MaxDensity = 0;
+    for (int i=0; i<w*h*d; i++)
+        if (m_MaxDensity < outImageBufferPointer[i])
+            m_MaxDensity = outImageBufferPointer[i];
     if (!m_OutputAbsoluteValues && !m_BinaryOutput)
     {
         MITK_INFO << "TractDensityImageFilter: max-normalizing output image";
-        OutPixelType max = 0;
-        for (int i=0; i<w*h*d; i++)
-            if (max < outImageBufferPointer[i])
-                max = outImageBufferPointer[i];
-        if (max>0)
+        if (m_MaxDensity>0)
             for (int i=0; i<w*h*d; i++)
             {
-                outImageBufferPointer[i] /= max;
+                outImageBufferPointer[i] /= m_MaxDensity;
             }
     }
     if (m_InvertImage)
     {
         MITK_INFO << "TractDensityImageFilter: inverting image";
         for (int i=0; i<w*h*d; i++)
             outImageBufferPointer[i] = 1-outImageBufferPointer[i];
     }
     MITK_INFO << "TractDensityImageFilter: finished processing";
 }
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
index d4232a9f4b..236fa38a1e 100644
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractDensityImageFilter.h
@@ -1,89 +1,91 @@
 /*===================================================================
 
 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 __itkTractDensityImageFilter_h__
 #define __itkTractDensityImageFilter_h__
 
 #include <itkImageSource.h>
 #include <itkImage.h>
 #include <itkVectorContainer.h>
 #include <itkRGBAPixel.h>
 #include <mitkFiberBundle.h>
 
 namespace itk{
 
 /**
 * \brief Generates tract density images from input fiberbundles (Calamante 2010).   */
 
 template< class OutputImageType >
 class TractDensityImageFilter : public ImageSource< OutputImageType >
 {
 
 public:
   typedef TractDensityImageFilter Self;
   typedef ProcessObject Superclass;
   typedef SmartPointer< Self > Pointer;
   typedef SmartPointer< const Self > ConstPointer;
 
   typedef typename OutputImageType::PixelType OutPixelType;
 
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
   itkTypeMacro( TractDensityImageFilter, ImageSource )
 
   itkSetMacro( UpsamplingFactor, float)                         ///< use higher resolution for ouput image
   itkGetMacro( UpsamplingFactor, float)                         ///< use higher resolution for ouput image
   itkSetMacro( InvertImage, bool)                               ///< voxelvalue = 1-voxelvalue
   itkGetMacro( InvertImage, bool)                               ///< voxelvalue = 1-voxelvalue
   itkSetMacro( BinaryOutput, bool)                              ///< generate binary fiber envelope
   itkGetMacro( BinaryOutput, bool)                              ///< generate binary fiber envelope
   itkSetMacro( OutputAbsoluteValues, bool)                      ///< output absolute values of the number of fibers per voxel
   itkGetMacro( OutputAbsoluteValues, bool)                      ///< output absolute values of the number of fibers per voxel
   itkSetMacro( UseImageGeometry, bool)                          ///< use input image geometry to initialize output image
   itkGetMacro( UseImageGeometry, bool)                          ///< use input image geometry to initialize output image
   itkSetMacro( FiberBundle, mitk::FiberBundle::Pointer)        ///< input fiber bundle
   itkSetMacro( InputImage, typename OutputImageType::Pointer)   ///< use input image geometry to initialize output image
   itkSetMacro( UseTrilinearInterpolation, bool )
   itkSetMacro( DoFiberResampling, bool )
   itkSetMacro( WorkOnFiberCopy, bool )
+  itkGetMacro( MaxDensity, OutPixelType)
 
   void GenerateData();
 
 protected:
 
   itk::Point<float, 3> GetItkPoint(double point[3]);
 
   TractDensityImageFilter();
   virtual ~TractDensityImageFilter();
 
   typename OutputImageType::Pointer m_InputImage;           ///< use input image geometry to initialize output image
   mitk::FiberBundle::Pointer        m_FiberBundle;          ///< input fiber bundle
   float                             m_UpsamplingFactor;     ///< use higher resolution for ouput image
   bool                              m_InvertImage;          ///< voxelvalue = 1-voxelvalue
   bool                              m_BinaryOutput;         ///< generate binary fiber envelope
   bool                              m_UseImageGeometry;     ///< use input image geometry to initialize output image
   bool                              m_OutputAbsoluteValues; ///< do not normalize image values to 0-1
   bool                              m_UseTrilinearInterpolation;
   bool                              m_DoFiberResampling;
   bool                              m_WorkOnFiberCopy;
+  OutPixelType                      m_MaxDensity;
 };
 
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractDensityImageFilter.cpp"
 #endif
 
 #endif // __itkTractDensityImageFilter_h__
diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
index 684260fd65..43fcaa0b7d 100755
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkTractsToDWIImageFilter.cpp
@@ -1,1685 +1,1723 @@
 /*===================================================================
 
 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 "itkTractsToDWIImageFilter.h"
 #include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkCropImageFilter.h>
 #include <mitkAstroStickModel.h>
 #include <vtkTransform.h>
 #include <iostream>
 #include <fstream>
 #include <exception>
 #include <itkImageDuplicator.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkTractDensityImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractsToVectorImageFilter.h>
 #include <itkInvertIntensityImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <itkExtractImageFilter.h>
 #include <itkResampleDwiImageFilter.h>
 #include <boost/algorithm/string/replace.hpp>
 
 namespace itk
 {
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
     : m_FiberBundle(NULL)
     , m_StatusText("")
     , m_UseConstantRandSeed(false)
     , m_RandGen(itk::Statistics::MersenneTwisterRandomVariateGenerator::New())
   {
     m_RandGen->SetSeed();
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::~TractsToDWIImageFilter()
   {
 
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::DoubleDwiType::Pointer TractsToDWIImageFilter< PixelType >::
   SimulateKspaceAcquisition( std::vector< DoubleDwiType::Pointer >& images )
   {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]);
     Vector< double, 2 > sliceSpacing;
     sliceSpacing[0] = m_WorkingSpacing[0];
     sliceSpacing[1] = m_WorkingSpacing[1];
 
     DoubleDwiType::PixelType nullPix; nullPix.SetSize(images.at(0)->GetVectorLength()); nullPix.Fill(0.0);
     auto magnitudeDwiImage = DoubleDwiType::New();
     magnitudeDwiImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     magnitudeDwiImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     magnitudeDwiImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     magnitudeDwiImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     magnitudeDwiImage->SetVectorLength( images.at(0)->GetVectorLength() );
     magnitudeDwiImage->Allocate();
     magnitudeDwiImage->FillBuffer(nullPix);
 
     m_PhaseImage = DoubleDwiType::New();
     m_PhaseImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_PhaseImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     m_PhaseImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_PhaseImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_PhaseImage->SetVectorLength( images.at(0)->GetVectorLength() );
     m_PhaseImage->Allocate();
     m_PhaseImage->FillBuffer(nullPix);
 
     m_KspaceImage = DoubleDwiType::New();
     m_KspaceImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_KspaceImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     m_KspaceImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_KspaceImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_KspaceImage->SetVectorLength( m_Parameters.m_SignalGen.m_NumberOfCoils );
     m_KspaceImage->Allocate();
     m_KspaceImage->FillBuffer(nullPix);
 
     std::vector< unsigned int > spikeVolume;
     for (unsigned int i=0; i<m_Parameters.m_SignalGen.m_Spikes; i++)
       spikeVolume.push_back(m_RandGen->GetIntegerVariate()%(images.at(0)->GetVectorLength()));
     std::sort (spikeVolume.begin(), spikeVolume.end());
     std::reverse (spikeVolume.begin(), spikeVolume.end());
 
     // calculate coil positions
     double a = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0)*m_Parameters.m_SignalGen.m_ImageSpacing[0];
     double b = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)*m_Parameters.m_SignalGen.m_ImageSpacing[1];
     double c = m_Parameters.m_SignalGen.m_ImageRegion.GetSize(2)*m_Parameters.m_SignalGen.m_ImageSpacing[2];
     double diagonal = sqrt(a*a+b*b)/1000;   // image diagonal in m
 
     m_CoilPointset = mitk::PointSet::New();
     std::vector< itk::Vector<double, 3> > coilPositions;
     itk::Vector<double, 3> pos; pos.Fill(0.0); pos[1] = -diagonal/2;
     itk::Vector<double, 3> center;
     center[0] = a/2-m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
     center[1] = b/2-m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
     center[2] = c/2-m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
     {
       coilPositions.push_back(pos);
       m_CoilPointset->InsertPoint(c, pos*1000 + m_Parameters.m_SignalGen.m_ImageOrigin.GetVectorFromOrigin() + center );
 
       double rz = 360.0/m_Parameters.m_SignalGen.m_NumberOfCoils * M_PI/180;
       vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
       rotZ[0][0] = cos(rz);
       rotZ[1][1] = rotZ[0][0];
       rotZ[0][1] = -sin(rz);
       rotZ[1][0] = -rotZ[0][1];
 
       pos.SetVnlVector(rotZ*pos.GetVnlVector());
     }
 
     PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
     PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
     unsigned long lastTick = 0;
 
     boost::progress_display disp(images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
     for (unsigned int g=0; g<images.at(0)->GetVectorLength(); g++)
     {
       std::vector< unsigned int > spikeSlice;
       while (!spikeVolume.empty() && spikeVolume.back()==g)
       {
         spikeSlice.push_back(m_RandGen->GetIntegerVariate()%images.at(0)->GetLargestPossibleRegion().GetSize(2));
         spikeVolume.pop_back();
       }
       std::sort (spikeSlice.begin(), spikeSlice.end());
       std::reverse (spikeSlice.begin(), spikeSlice.end());
 
       for (unsigned int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
       {
         std::vector< SliceType::Pointer > compartmentSlices;
         std::vector< double > t2Vector;
         std::vector< double > t1Vector;
 
         for (unsigned int i=0; i<images.size(); i++)
         {
           DiffusionSignalModel<double>* signalModel;
           if (i<numFiberCompartments)
             signalModel = m_Parameters.m_FiberModelList.at(i);
           else
             signalModel = m_Parameters.m_NonFiberModelList.at(i-numFiberCompartments);
 
           auto slice = SliceType::New();
           slice->SetLargestPossibleRegion( sliceRegion );
           slice->SetBufferedRegion( sliceRegion );
           slice->SetRequestedRegion( sliceRegion );
           slice->SetSpacing(sliceSpacing);
           slice->Allocate();
           slice->FillBuffer(0.0);
 
           // extract slice from channel g
           for (unsigned int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
             for (unsigned int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
             {
               SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
               slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
             }
 
           compartmentSlices.push_back(slice);
           t2Vector.push_back(signalModel->GetT2());
           t1Vector.push_back(signalModel->GetT1());
         }
 
         int numSpikes = 0;
         while (!spikeSlice.empty() && spikeSlice.back()==z)
         {
           numSpikes++;
           spikeSlice.pop_back();
         }
         int spikeCoil = m_RandGen->GetIntegerVariate()%m_Parameters.m_SignalGen.m_NumberOfCoils;
 
         if (this->GetAbortGenerateData())
           return NULL;
 
 #pragma omp parallel for
         for (int c=0; c<m_Parameters.m_SignalGen.m_NumberOfCoils; c++)
         {
           // create k-sapce (inverse fourier transform slices)
           auto idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
           idft->SetCompartmentImages(compartmentSlices);
           idft->SetT2(t2Vector);
           idft->SetT1(t1Vector);
           idft->SetUseConstantRandSeed(m_UseConstantRandSeed);
           idft->SetParameters(&m_Parameters);
           idft->SetZ((double)z-(double)( images.at(0)->GetLargestPossibleRegion().GetSize(2)
                                         -images.at(0)->GetLargestPossibleRegion().GetSize(2)%2 ) / 2.0);
           idft->SetZidx(z);
           idft->SetCoilPosition(coilPositions.at(c));
           idft->SetFiberBundle(m_FiberBundleWorkingCopy);
           idft->SetTranslation(m_Translations.at(g));
           idft->SetRotation(m_Rotations.at(g));
           idft->SetDiffusionGradientDirection(m_Parameters.m_SignalGen.GetGradientDirection(g));
           if (c==spikeCoil)
             idft->SetSpikesPerSlice(numSpikes);
           idft->Update();
 
 #pragma omp critical
           if (c==spikeCoil && numSpikes>0)
           {
             m_SpikeLog += "Volume " + boost::lexical_cast<std::string>(g) + " Coil " + boost::lexical_cast<std::string>(c) + "\n";
             m_SpikeLog += idft->GetSpikeLog();
           }
 
           ComplexSliceType::Pointer fSlice;
           fSlice = idft->GetOutput();
 
           // fourier transform slice
           ComplexSliceType::Pointer newSlice;
           auto dft = itk::DftImageFilter< SliceType::PixelType >::New();
           dft->SetInput(fSlice);
           dft->SetParameters(m_Parameters);
           dft->Update();
           newSlice = dft->GetOutput();
 
           // put slice back into channel g
           for (unsigned int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
             for (unsigned int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
             {
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
               ComplexSliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
               ComplexSliceType::PixelType cPix = newSlice->GetPixel(index2D);
               double magn = sqrt(cPix.real()*cPix.real()+cPix.imag()*cPix.imag());
               double phase = 0;
               if (cPix.real()!=0)
                 phase = atan( cPix.imag()/cPix.real() );
 
 
               DoubleDwiType::PixelType dwiPix = magnitudeDwiImage->GetPixel(index3D);
               DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
 
               if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
               {
                 dwiPix[g] += magn*magn;
                 phasePix[g] += phase*phase;
               }
               else
               {
                 dwiPix[g] = magn;
                 phasePix[g] = phase;
               }
 
 #pragma omp critical
               {
                 magnitudeDwiImage->SetPixel(index3D, dwiPix);
                 m_PhaseImage->SetPixel(index3D, phasePix);
 
                 // k-space image
                 if (g==0)
                 {
                   DoubleDwiType::PixelType kspacePix = m_KspaceImage->GetPixel(index3D);
                   kspacePix[c] = idft->GetKSpaceImage()->GetPixel(index2D);
                   m_KspaceImage->SetPixel(index3D, kspacePix);
                 }
               }
             }
         }
 
         if (m_Parameters.m_SignalGen.m_NumberOfCoils>1)
         {
 #ifdef WIN32
 #pragma omp parallel for
 #else
 #pragma omp parallel for collapse(2)
 #endif
           for (int y=0; y<magnitudeDwiImage->GetLargestPossibleRegion().GetSize(1); y++)
             for (int x=0; x<magnitudeDwiImage->GetLargestPossibleRegion().GetSize(0); x++)
             {
               DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
               DoubleDwiType::PixelType magPix = magnitudeDwiImage->GetPixel(index3D);
               magPix[g] = sqrt(magPix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
               DoubleDwiType::PixelType phasePix = m_PhaseImage->GetPixel(index3D);
               phasePix[g] = sqrt(phasePix[g]/m_Parameters.m_SignalGen.m_NumberOfCoils);
 
 #pragma omp critical
               {
                 magnitudeDwiImage->SetPixel(index3D, magPix);
                 m_PhaseImage->SetPixel(index3D, phasePix);
               }
             }
         }
 
         ++disp;
         unsigned long newTick = 50*disp.count()/disp.expected_count();
         for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
           PrintToLog("*", false, false, false);
         lastTick = newTick;
       }
     }
     PrintToLog("\n", false);
     return magnitudeDwiImage;
   }
 
   template< class PixelType >
   TractsToDWIImageFilter< PixelType >::ItkDoubleImgType::Pointer TractsToDWIImageFilter< PixelType >::
   NormalizeInsideMask(ItkDoubleImgType::Pointer image)
   {
     double max = itk::NumericTraits< double >::min();
     double min = itk::NumericTraits< double >::max();
 
     itk::ImageRegionIterator< ItkDoubleImgType > it(image, image->GetLargestPossibleRegion());
     while(!it.IsAtEnd())
     {
       if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull() && m_Parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
       {
         it.Set(0.0);
         ++it;
         continue;
       }
       //        if (it.Get()>900)
       //            it.Set(900);
 
       if (it.Get()>max)
         max = it.Get();
       if (it.Get()<min)
         min = it.Get();
       ++it;
     }
     auto scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
     scaler->SetInput(image);
     scaler->SetShift(-min);
     scaler->SetScale(1.0/(max-min));
     scaler->Update();
     return scaler->GetOutput();
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::CheckVolumeFractionImages()
   {
     m_UseRelativeNonFiberVolumeFractions = false;
 
     // check for fiber volume fraction maps
     int fibVolImages = 0;
     for (int i=0; i<m_Parameters.m_FiberModelList.size(); i++)
     {
       if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage().IsNotNull())
       {
         PrintToLog("Using volume fraction map for fiber compartment " + boost::lexical_cast<std::string>(i+1));
         fibVolImages++;
       }
     }
 
     // check for non-fiber volume fraction maps
     int nonfibVolImages = 0;
     for (int i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
     {
       if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNotNull())
       {
         PrintToLog("Using volume fraction map for non-fiber compartment " + boost::lexical_cast<std::string>(i+1));
         nonfibVolImages++;
       }
     }
 
     // not all fiber compartments are using volume fraction maps
     // --> non-fiber volume fractions are assumed to be relative to the
     // non-fiber volume and not absolute voxel-volume fractions.
     // this means if two non-fiber compartments are used but only one of them
     // has an associated volume fraction map, the repesctive other volume fraction map
     // can be determined as inverse (1-val) of the present volume fraction map-
     if ( fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages==1 && m_Parameters.m_NonFiberModelList.size()==2)
     {
       PrintToLog("Calculating missing non-fiber volume fraction image by inverting the other.\n"
                  "Assuming non-fiber volume fraction images to contain values relative to the"
                  " remaining non-fiber volume, not absolute values.");
 
       auto inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
       inverter->SetMaximum(1.0);
       if ( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNull()
            && m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNotNull() )
       {
         // m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(
         // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() ) );
         inverter->SetInput( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage() );
         inverter->Update();
         m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(inverter->GetOutput());
       }
       else if ( m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage().IsNull()
                 && m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage().IsNotNull() )
       {
         // m_Parameters.m_NonFiberModelList[0]->SetVolumeFractionImage(
         // NormalizeInsideMask( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() ) );
         inverter->SetInput( m_Parameters.m_NonFiberModelList[0]->GetVolumeFractionImage() );
         inverter->Update();
         m_Parameters.m_NonFiberModelList[1]->SetVolumeFractionImage(inverter->GetOutput());
       }
       else
       {
         itkExceptionMacro("Something went wrong in automatically calculating the missing non-fiber volume fraction image!"
                           " Did you use two non fiber compartments but only one volume fraction image?"
                           " Then it should work and this error is really strange.");
       }
       m_UseRelativeNonFiberVolumeFractions = true;
 
       nonfibVolImages++;
     }
 
     // Up to two fiber compartments are allowed without volume fraction maps since the volume fractions can then be determined automatically
     if (m_Parameters.m_FiberModelList.size()>2
         && fibVolImages!=m_Parameters.m_FiberModelList.size())
       itkExceptionMacro("More than two fiber compartment selected but no corresponding volume fraction maps set!");
 
     // One non-fiber compartment is allowed without volume fraction map since the volume fraction can then be determined automatically
     if (m_Parameters.m_NonFiberModelList.size()>1
         && nonfibVolImages!=m_Parameters.m_NonFiberModelList.size())
       itkExceptionMacro("More than one non-fiber compartment selected but no volume fraction maps set!");
 
     if (fibVolImages<m_Parameters.m_FiberModelList.size() && nonfibVolImages>0)
     {
       PrintToLog("Not all fiber compartments are using an associated volume fraction image.\n"
                  "Assuming non-fiber volume fraction images to contain values relative to the"
                  " remaining non-fiber volume, not absolute values.");
       m_UseRelativeNonFiberVolumeFractions = true;
 
       //        itk::ImageFileWriter<ItkDoubleImgType>::Pointer wr = itk::ImageFileWriter<ItkDoubleImgType>::New();
       //        wr->SetInput(m_Parameters.m_NonFiberModelList[1]->GetVolumeFractionImage());
       //        wr->SetFileName("/local/volumefraction.nrrd");
       //        wr->Update();
     }
 
     // initialize the images that store the output volume fraction of each compartment
     m_VolumeFractions.clear();
     for (int i=0; i<m_Parameters.m_FiberModelList.size()+m_Parameters.m_NonFiberModelList.size(); i++)
     {
       auto doubleImg = ItkDoubleImgType::New();
       doubleImg->SetSpacing( m_WorkingSpacing );
       doubleImg->SetOrigin( m_WorkingOrigin );
       doubleImg->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       doubleImg->SetLargestPossibleRegion( m_WorkingImageRegion );
       doubleImg->SetBufferedRegion( m_WorkingImageRegion );
       doubleImg->SetRequestedRegion( m_WorkingImageRegion );
       doubleImg->Allocate();
       doubleImg->FillBuffer(0);
       m_VolumeFractions.push_back(doubleImg);
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::InitializeData()
   {
     m_Rotations.clear();
     m_Translations.clear();
     m_MotionLog = "";
     m_SpikeLog = "";
 
     // initialize output dwi image
     m_Parameters.m_SignalGen.m_CroppedRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_Parameters.m_SignalGen.m_CroppedRegion.SetSize( 1, m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1)
                                                       *m_Parameters.m_SignalGen.m_CroppingFactor);
 
     itk::Point<double,3> shiftedOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     shiftedOrigin[1] += (m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)
                          -m_Parameters.m_SignalGen.m_CroppedRegion.GetSize(1))*m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
 
     m_OutputImage = OutputImageType::New();
     m_OutputImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     m_OutputImage->SetOrigin( shiftedOrigin );
     m_OutputImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     m_OutputImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_CroppedRegion );
     m_OutputImage->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     m_OutputImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     temp.Fill(0.0);
     m_OutputImage->FillBuffer(temp);
 
     // Apply in-plane upsampling for Gibbs ringing artifact
     double upsampling = 1;
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
       upsampling = 2;
     m_WorkingSpacing = m_Parameters.m_SignalGen.m_ImageSpacing;
     m_WorkingSpacing[0] /= upsampling;
     m_WorkingSpacing[1] /= upsampling;
     m_WorkingImageRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_WorkingImageRegion.SetSize(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[0]*upsampling);
     m_WorkingImageRegion.SetSize(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[1]*upsampling);
     m_WorkingOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     m_WorkingOrigin[0] -= m_Parameters.m_SignalGen.m_ImageSpacing[0]/2;
     m_WorkingOrigin[0] += m_WorkingSpacing[0]/2;
     m_WorkingOrigin[1] -= m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     m_WorkingOrigin[1] += m_WorkingSpacing[1]/2;
     m_WorkingOrigin[2] -= m_Parameters.m_SignalGen.m_ImageSpacing[2]/2;
     m_WorkingOrigin[2] += m_WorkingSpacing[2]/2;
     m_VoxelVolume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
 
     // generate double images to store the individual compartment signals
     m_CompartmentImages.clear();
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
     for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
     {
       auto doubleDwi = DoubleDwiType::New();
       doubleDwi->SetSpacing( m_WorkingSpacing );
       doubleDwi->SetOrigin( m_WorkingOrigin );
       doubleDwi->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       doubleDwi->SetLargestPossibleRegion( m_WorkingImageRegion );
       doubleDwi->SetBufferedRegion( m_WorkingImageRegion );
       doubleDwi->SetRequestedRegion( m_WorkingImageRegion );
       doubleDwi->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
       doubleDwi->Allocate();
       DoubleDwiType::PixelType pix;
       pix.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
       pix.Fill(0.0);
       doubleDwi->FillBuffer(pix);
       m_CompartmentImages.push_back(doubleDwi);
     }
 
     if (m_FiberBundle.IsNull() && m_InputImage.IsNotNull())
     {
       m_CompartmentImages.clear();
 
       m_Parameters.m_SignalGen.m_DoAddMotion = false;
       m_Parameters.m_SignalGen.m_DoSimulateRelaxation = false;
 
       PrintToLog("Simulating acquisition for input diffusion-weighted image.", false);
       auto caster = itk::CastImageFilter< OutputImageType, DoubleDwiType >::New();
       caster->SetInput(m_InputImage);
       caster->Update();
 
       if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
       {
         PrintToLog("Upsampling input diffusion-weighted image for Gibbs ringing simulation.", false);
 
         auto resampler = itk::ResampleDwiImageFilter< double >::New();
         resampler->SetInput(caster->GetOutput());
         itk::Vector< double, 3 > samplingFactor;
         samplingFactor[0] = upsampling;
         samplingFactor[1] = upsampling;
         samplingFactor[2] = 1;
         resampler->SetSamplingFactor(samplingFactor);
         resampler->SetInterpolation(itk::ResampleDwiImageFilter< double >::Interpolate_WindowedSinc);
         resampler->Update();
         m_CompartmentImages.push_back(resampler->GetOutput());
       }
       else
         m_CompartmentImages.push_back(caster->GetOutput());
 
       for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
       {
         m_Rotation.Fill(0.0);
         m_Translation.Fill(0.0);
         m_Rotations.push_back(m_Rotation);
         m_Translations.push_back(m_Translation);
       }
     }
 
     // resample mask image and frequency map to fit upsampled geometry
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
     {
       if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull())
       {
         // rescale mask image (otherwise there are problems with the resampling)
         auto rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
         rescaler->SetInput(0,m_Parameters.m_SignalGen.m_MaskImage);
         rescaler->SetOutputMaximum(100);
         rescaler->SetOutputMinimum(0);
         rescaler->Update();
 
         // resample mask image
         auto resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
         resampler->SetInput(rescaler->GetOutput());
         resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
         resampler->SetSize(m_WorkingImageRegion.GetSize());
         resampler->SetOutputSpacing(m_WorkingSpacing);
         resampler->SetOutputOrigin(m_WorkingOrigin);
         auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
         resampler->SetInterpolator(nn_interpolator);
         resampler->Update();
         m_Parameters.m_SignalGen.m_MaskImage = resampler->GetOutput();
       }
       // resample frequency map
       if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
       {
         auto resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         resampler->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
         resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_FrequencyMap);
         resampler->SetSize(m_WorkingImageRegion.GetSize());
         resampler->SetOutputSpacing(m_WorkingSpacing);
         resampler->SetOutputOrigin(m_WorkingOrigin);
         auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::New();
         resampler->SetInterpolator(nn_interpolator);
         resampler->Update();
         m_Parameters.m_SignalGen.m_FrequencyMap = resampler->GetOutput();
       }
     }
 
     m_MaskImageSet = true;
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNull())
     {
       // no input tissue mask is set -> create default
       PrintToLog("No tissue mask set", false);
       m_Parameters.m_SignalGen.m_MaskImage = ItkUcharImgType::New();
       m_Parameters.m_SignalGen.m_MaskImage->SetSpacing( m_WorkingSpacing );
       m_Parameters.m_SignalGen.m_MaskImage->SetOrigin( m_WorkingOrigin );
       m_Parameters.m_SignalGen.m_MaskImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
       m_Parameters.m_SignalGen.m_MaskImage->SetLargestPossibleRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->SetBufferedRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->SetRequestedRegion( m_WorkingImageRegion );
       m_Parameters.m_SignalGen.m_MaskImage->Allocate();
       m_Parameters.m_SignalGen.m_MaskImage->FillBuffer(100);
       m_MaskImageSet = false;
     }
     else
     {
       if (m_Parameters.m_SignalGen.m_MaskImage->GetLargestPossibleRegion()!=m_WorkingImageRegion)
       {
         itkExceptionMacro("Mask image and specified DWI geometry are not matching!");
       }
       PrintToLog("Using tissue mask", false);
     }
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
       if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
       {
         PrintToLog("Random motion artifacts:", false);
         PrintToLog("Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
         PrintToLog("Maximum translation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
       }
       else
       {
         PrintToLog("Linear motion artifacts:", false);
         PrintToLog("Maximum rotation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°", false);
         PrintToLog("Maximum translation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm", false);
       }
     }
     if ( m_Parameters.m_SignalGen.m_MotionVolumes.empty() )
     {
       // no motion in first volume
       m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
 
       // motion in all other volumes
       while ( m_Parameters.m_SignalGen.m_MotionVolumes.size() < m_Parameters.m_SignalGen.GetNumVolumes() )
       {
         m_Parameters.m_SignalGen.m_MotionVolumes.push_back(true);
       }
     }
     // we need to know for every volume if there is motion. if this information is missing, then set corresponding fal to false
     while ( m_Parameters.m_SignalGen.m_MotionVolumes.size()<m_Parameters.m_SignalGen.GetNumVolumes() )
     {
       m_Parameters.m_SignalGen.m_MotionVolumes.push_back(false);
     }
 
     m_NumMotionVolumes = 0;
     for (int i=0; i<m_Parameters.m_SignalGen.GetNumVolumes(); i++)
     {
       if (m_Parameters.m_SignalGen.m_MotionVolumes[i])
       {
         m_NumMotionVolumes++;
       }
     }
     m_MotionCounter = 0;
 
     // creat image to hold transformed mask (motion artifact)
     m_TransformedMaskImage = ItkUcharImgType::New();
     auto duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(m_Parameters.m_SignalGen.m_MaskImage);
     duplicator->Update();
     m_TransformedMaskImage = duplicator->GetOutput();
 
     // second upsampling needed for motion artifacts
     ImageRegion<3>      upsampledImageRegion = m_WorkingImageRegion;
     DoubleVectorType    upsampledSpacing = m_WorkingSpacing;
     upsampledSpacing[0] /= 4;
     upsampledSpacing[1] /= 4;
     upsampledSpacing[2] /= 4;
     upsampledImageRegion.SetSize(0, m_WorkingImageRegion.GetSize()[0]*4);
     upsampledImageRegion.SetSize(1, m_WorkingImageRegion.GetSize()[1]*4);
     upsampledImageRegion.SetSize(2, m_WorkingImageRegion.GetSize()[2]*4);
     itk::Point<double,3> upsampledOrigin = m_WorkingOrigin;
     upsampledOrigin[0] -= m_WorkingSpacing[0]/2;
     upsampledOrigin[0] += upsampledSpacing[0]/2;
     upsampledOrigin[1] -= m_WorkingSpacing[1]/2;
     upsampledOrigin[1] += upsampledSpacing[1]/2;
     upsampledOrigin[2] -= m_WorkingSpacing[2]/2;
     upsampledOrigin[2] += upsampledSpacing[2]/2;
 
     m_UpsampledMaskImage = ItkUcharImgType::New();
     auto upsampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
     upsampler->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetSize(upsampledImageRegion.GetSize());
     upsampler->SetOutputSpacing(upsampledSpacing);
     upsampler->SetOutputOrigin(upsampledOrigin);
 
     auto nn_interpolator = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
     upsampler->SetInterpolator(nn_interpolator);
     upsampler->Update();
     m_UpsampledMaskImage = upsampler->GetOutput();
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::InitializeFiberData()
   {
     // resample fiber bundle for sufficient voxel coverage
     PrintToLog("Resampling fibers ...");
     m_SegmentVolume = 0.0001;
     float minSpacing = 1;
     if( m_WorkingSpacing[0]<m_WorkingSpacing[1]
         && m_WorkingSpacing[0]<m_WorkingSpacing[2])
     {
       minSpacing = m_WorkingSpacing[0];
     }
     else if (m_WorkingSpacing[1] < m_WorkingSpacing[2])
     {
       minSpacing = m_WorkingSpacing[1];
     }
     else
     {
       minSpacing = m_WorkingSpacing[2];
     }
 
     // working copy is needed because we need to resample the fibers but do not want to change the original bundle
     m_FiberBundleWorkingCopy = m_FiberBundle->GetDeepCopy();
     double volumeAccuracy = 10;
     m_FiberBundleWorkingCopy->ResampleSpline(minSpacing/volumeAccuracy);
     m_mmRadius = m_Parameters.m_SignalGen.m_AxonRadius/1000;
-
-    if (m_mmRadius>0) { m_SegmentVolume = M_PI*m_mmRadius*m_mmRadius*minSpacing/volumeAccuracy; }
+    
+    auto caster = itk::CastImageFilter< itk::Image<unsigned char, 3>, itk::Image<float, 3> >::New();
+    caster->SetInput(m_TransformedMaskImage);
+    caster->Update();
+      
+    auto density_calculator = itk::TractDensityImageFilter< itk::Image<float, 3> >::New();
+    density_calculator->SetFiberBundle(m_FiberBundleWorkingCopy);
+    density_calculator->SetInputImage(caster->GetOutput());
+    density_calculator->SetBinaryOutput(false);
+    density_calculator->SetUseImageGeometry(true);
+    density_calculator->SetDoFiberResampling(false);
+    density_calculator->SetOutputAbsoluteValues(true);
+    density_calculator->SetWorkOnFiberCopy(false);
+    density_calculator->Update();
+    float max_density = density_calculator->GetMaxDensity();
+    
+    if (m_mmRadius>0) 
+    { 
+      m_SegmentVolume = M_PI*m_mmRadius*m_mmRadius*minSpacing/volumeAccuracy; 
+      stringstream stream;
+      stream << fixed << setprecision(2) << max_density * 100 * m_SegmentVolume;
+      string s = stream.str();
+      PrintToLog("\nMax. fiber volume: " + s + "mm².", false, true, true);
+    }
+    else
+    {
+      stringstream stream;
+      stream << fixed << setprecision(2) << max_density * 100 * m_SegmentVolume;
+      string s = stream.str();
+      PrintToLog("\nMax. fiber volume: " + s + "mm² (before rescaling to voxel volume).", false, true, true);
+    }
+    float voxel_volume = m_WorkingSpacing[0]*m_WorkingSpacing[1]*m_WorkingSpacing[2];
+    float new_seg_vol = voxel_volume/(max_density * 100.0);
+    float new_fib_radius = 1000*std::sqrt(new_seg_vol*volumeAccuracy/(minSpacing*M_PI));
+    stringstream stream;
+    stream << fixed << setprecision(2) << new_fib_radius;
+    string s = stream.str();
+    PrintToLog("\nA full fiber voxel corresponds to a fiber radius of ~" + s + "µm, given the current fiber configuration.", false, true, true);
+    
     // a second fiber bundle is needed to store the transformed version of the m_FiberBundleWorkingCopy
     m_FiberBundleTransformed = m_FiberBundleWorkingCopy;
   }
 
 
   template< class PixelType >
   bool TractsToDWIImageFilter< PixelType >::PrepareLogFile()
   {
     assert( ! m_Logfile.is_open() );
 
     std::string filePath;
     std::string fileName;
 
     // Get directory name:
     if (m_Parameters.m_Misc.m_OutputPath.size() > 0)
     {
       filePath = m_Parameters.m_Misc.m_OutputPath;
       if( *(--(filePath.cend())) != '/')
       {
         filePath.push_back('/');
       }
     }
     else
     {
       filePath = mitk::IOUtil::GetTempPath() + '/';
     }
     // check if directory exists, else use /tmp/:
     if( itksys::SystemTools::FileIsDirectory( filePath ) )
     {
       while( *(--(filePath.cend())) == '/')
       {
         filePath.pop_back();
       }
       filePath = filePath + '/';
     }
     else
     {
       filePath = mitk::IOUtil::GetTempPath() + '/';
     }
 
     // Get file name:
     if( ! m_Parameters.m_Misc.m_ResultNode->GetName().empty() )
     {
       fileName = m_Parameters.m_Misc.m_ResultNode->GetName();
     }
     else
     {
       fileName = "";
     }
 
     if( ! m_Parameters.m_Misc.m_OutputPrefix.empty() )
     {
       fileName = m_Parameters.m_Misc.m_OutputPrefix + fileName;
     }
     else
     {
       fileName = "fiberfox";
     }
 
     // check if file already exists and DO NOT overwrite existing files:
     std::string NameTest = fileName;
     int c = 0;
     while( itksys::SystemTools::FileExists( filePath + '/' + fileName + ".log" )
            && c <= std::numeric_limits<int>::max() )
     {
       fileName = NameTest + "_" + boost::lexical_cast<std::string>(c);
       ++c;
     }
 
     try
     {
       m_Logfile.open( ( filePath + '/' + fileName + ".log" ).c_str() );
     }
     catch (const std::ios_base::failure &fail)
     {
       MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Exception " << fail.what()
                  << " while trying to open file" << filePath << '/' << fileName << ".log";
       return false;
     }
 
     if ( m_Logfile.is_open() )
     {
       PrintToLog( "Logfile: " + filePath + '/' + fileName + ".log", false );
       return true;
     }
     else
     {
       m_StatusText += "Logfile could not be opened!\n";
       MITK_ERROR << "itkTractsToDWIImageFilter.cpp: Logfile could not be opened!";
       return false;
     }
   }
 
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::GenerateData()
   {
     // prepare logfile
     if ( ! PrepareLogFile() )
     {
       this->SetAbortGenerateData( true );
       return;
     }
 
     m_TimeProbe.Start();
 
     // check input data
     if (m_FiberBundle.IsNull() && m_InputImage.IsNull())
       itkExceptionMacro("Input fiber bundle and input diffusion-weighted image is NULL!");
 
     if (m_Parameters.m_FiberModelList.empty() && m_InputImage.IsNull())
       itkExceptionMacro("No diffusion model for fiber compartments defined and input diffusion-weighted"
                         " image is NULL! At least one fiber compartment is necessary to simulate diffusion.");
 
     if (m_Parameters.m_NonFiberModelList.empty() && m_InputImage.IsNull())
       itkExceptionMacro("No diffusion model for non-fiber compartments defined and input diffusion-weighted"
                         " image is NULL! At least one non-fiber compartment is necessary to simulate diffusion.");
 
     int baselineIndex = m_Parameters.m_SignalGen.GetFirstBaselineIndex();
     if (baselineIndex<0) { itkExceptionMacro("No baseline index found!"); }
 
     if (!m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition)  // No upsampling of input image needed if no k-space simulation is performed
     {
       m_Parameters.m_SignalGen.m_DoAddGibbsRinging = false;
     }
 
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
     { m_RandGen->SetSeed(0); }
     else { m_RandGen->SetSeed(); }
 
     InitializeData();
     if ( m_FiberBundle.IsNotNull() )    // if no fiber bundle is found, we directly proceed to the k-space acquisition simulation
     {
       CheckVolumeFractionImages();
       InitializeFiberData();
 
       int numFiberCompartments = m_Parameters.m_FiberModelList.size();
       int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
       double maxVolume = 0;
       unsigned long lastTick = 0;
       int signalModelSeed = m_RandGen->GetIntegerVariate();
 
       PrintToLog("\n", false, false);
       PrintToLog("Generating " + boost::lexical_cast<std::string>(numFiberCompartments+numNonFiberCompartments)
                  + "-compartment diffusion-weighted signal.");
            
       std::vector< int > bVals = m_Parameters.m_SignalGen.GetBvalues();
       PrintToLog("b-values: ", false, false, true);
       for (auto v : bVals)
         PrintToLog(boost::lexical_cast<std::string>(v) + " ", false, false, true);
       PrintToLog("\n", false, false, true);
       PrintToLog("\n", false, false, true);
 
       int numFibers = m_FiberBundleWorkingCopy->GetNumFibers();
       boost::progress_display disp(numFibers*m_Parameters.m_SignalGen.GetNumVolumes());
 
       PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
       PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
 
       for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
       {
         // move fibers
         SimulateMotion(g);
 
         // Set signal model random generator seeds to get same configuration in each voxel
         for (int i=0; i<m_Parameters.m_FiberModelList.size(); i++)
           m_Parameters.m_FiberModelList.at(i)->SetSeed(signalModelSeed);
         for (int i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
           m_Parameters.m_NonFiberModelList.at(i)->SetSeed(signalModelSeed);
 
         // storing voxel-wise intra-axonal volume in mm³
         auto intraAxonalVolumeImage = ItkDoubleImgType::New();
         intraAxonalVolumeImage->SetSpacing( m_WorkingSpacing );
         intraAxonalVolumeImage->SetOrigin( m_WorkingOrigin );
         intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         intraAxonalVolumeImage->SetLargestPossibleRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->SetBufferedRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->SetRequestedRegion( m_WorkingImageRegion );
         intraAxonalVolumeImage->Allocate();
         intraAxonalVolumeImage->FillBuffer(0);
         maxVolume = 0;
 
         vtkPolyData* fiberPolyData = m_FiberBundleTransformed->GetFiberPolyData();
         // generate fiber signal (if there are any fiber models present)
         if (!m_Parameters.m_FiberModelList.empty())
           for( int i=0; i<numFibers; i++ )
           {
             float fiberWeight = m_FiberBundleTransformed->GetFiberWeight(i);
             vtkCell* cell = fiberPolyData->GetCell(i);
             int numPoints = cell->GetNumberOfPoints();
             vtkPoints* points = cell->GetPoints();
 
             if (numPoints<2)
               continue;
 
             for( int j=0; j<numPoints; j++)
             {
               if (this->GetAbortGenerateData())
               {
                 PrintToLog("\n", false, false);
                 PrintToLog("Simulation aborted");
                 return;
               }
 
               double* temp = points->GetPoint(j);
               itk::Point<float, 3> vertex = GetItkPoint(temp);
               itk::Vector<double> v = GetItkVector(temp);
 
               itk::Vector<double, 3> dir(3);
               if (j<numPoints-1) { dir = GetItkVector(points->GetPoint(j+1))-v; }
               else { dir = v-GetItkVector(points->GetPoint(j-1)); }
 
               if ( dir.GetSquaredNorm()<0.0001 || dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2] )
               {
                 continue;
               }
 
               itk::Index<3> idx;
               itk::ContinuousIndex<float, 3> contIndex;
               m_TransformedMaskImage->TransformPhysicalPointToIndex(vertex, idx);
               m_TransformedMaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
               if (!m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(idx) || m_TransformedMaskImage->GetPixel(idx)<=0)
               {
                 continue;
               }
 
               // generate signal for each fiber compartment
               for (int k=0; k<numFiberCompartments; k++)
               {
                 m_Parameters.m_FiberModelList[k]->SetFiberDirection(dir);
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(k)->GetPixel(idx);
                 pix[g] += fiberWeight*m_SegmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g);
 
                 m_CompartmentImages.at(k)->SetPixel(idx, pix);
               }
 
               // update fiber volume image
               double vol = intraAxonalVolumeImage->GetPixel(idx) + m_SegmentVolume*fiberWeight;
               intraAxonalVolumeImage->SetPixel(idx, vol);
 
               // we assume that the first volume is always unweighted!
               if (vol>maxVolume) { maxVolume = vol; }
             }
 
             // progress report
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
             {
               PrintToLog("*", false, false, false);
             }
             lastTick = newTick;
           }
 
         // generate non-fiber signal
         ImageRegionIterator<ItkUcharImgType> it3(m_TransformedMaskImage, m_TransformedMaskImage->GetLargestPossibleRegion());
         double fact = 1;    // density correction factor in mm³
         if (m_Parameters.m_SignalGen.m_AxonRadius<0.0001 || maxVolume>m_VoxelVolume)    // the fullest voxel is always completely full
           fact = m_VoxelVolume/maxVolume;
+        
         while(!it3.IsAtEnd())
         {
           if (it3.Get()>0)
           {
             DoubleDwiType::IndexType index = it3.GetIndex();
             itk::Point<double, 3> point;
             m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, point);
             if ( m_Parameters.m_SignalGen.m_DoAddMotion && g>=0
                  && m_Parameters.m_SignalGen.m_MotionVolumes[g] )
             {
               if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
               {
                 point = m_FiberBundleWorkingCopy->TransformPoint( point.GetVnlVector(), -m_Rotation[0], -m_Rotation[1], -m_Rotation[2],
                                                                   -m_Translation[0], -m_Translation[1], -m_Translation[2] );
               }
               else
               {
                 point = m_FiberBundleWorkingCopy->TransformPoint( point.GetVnlVector(),
                     -m_Rotation[0]*m_MotionCounter, -m_Rotation[1]*m_MotionCounter, -m_Rotation[2]*m_MotionCounter,
                     -m_Translation[0]*m_MotionCounter, -m_Translation[1]*m_MotionCounter, -m_Translation[2]*m_MotionCounter );
               }
             }
 
             double iAxVolume = intraAxonalVolumeImage->GetPixel(index);
 
             // if volume fraction image is set use it, otherwise use scaling factor to obtain one full fiber voxel
             double fact2 = fact;
             if ( m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage()!=nullptr
                  && iAxVolume>0.0001 )
             {
               double val = InterpolateValue(point, m_Parameters.m_FiberModelList[0]->GetVolumeFractionImage());
               if (val>=0) { fact2 = m_VoxelVolume*val/iAxVolume; }
             }
 
             // adjust intra-axonal image value
             for (int i=0; i<numFiberCompartments; i++)
             {
               DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
               pix[g] *= fact2;
               m_CompartmentImages.at(i)->SetPixel(index, pix);
             }
 
             // simulate other compartments
             SimulateExtraAxonalSignal(index, iAxVolume*fact2, g);
           }
           ++it3;
         }
       }
 
       PrintToLog("\n", false);
       if (this->GetAbortGenerateData())
       {
         PrintToLog("\n", false, false);
         PrintToLog("Simulation aborted");
         return;
       }
     }
 
     DoubleDwiType::Pointer doubleOutImage;
     double signalScale = m_Parameters.m_SignalGen.m_SignalScale;
     if ( m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition ) // do k-space stuff
     {
       PrintToLog("\n", false, false);
       PrintToLog("Simulating k-space acquisition using "
                  +boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_NumberOfCoils)
                  +" coil(s)");
 
       switch (m_Parameters.m_SignalGen.m_AcquisitionType)
       {
         case SignalGenerationParameters::SingleShotEpi:
         {
           PrintToLog("Acquisition type: single shot EPI", false);
           break;
         }
         case SignalGenerationParameters::SpinEcho:
         {
           PrintToLog("Acquisition type: classic spin echo with cartesian k-space trajectory", false);
           break;
         }
         default:
         {
           PrintToLog("Acquisition type: single shot EPI", false);
           break;
         }
       }
 
       if (m_Parameters.m_SignalGen.m_NoiseVariance>0)
         PrintToLog("Simulating complex Gaussian noise", false);
       if (m_Parameters.m_SignalGen.m_DoSimulateRelaxation)
         PrintToLog("Simulating signal relaxation", false);
       if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
         PrintToLog("Simulating distortions", false);
       if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
         PrintToLog("Simulating ringing artifacts", false);
       if (m_Parameters.m_SignalGen.m_EddyStrength>0)
         PrintToLog("Simulating eddy currents", false);
       if (m_Parameters.m_SignalGen.m_Spikes>0)
         PrintToLog("Simulating spikes", false);
       if (m_Parameters.m_SignalGen.m_CroppingFactor<1.0)
         PrintToLog("Simulating aliasing artifacts", false);
       if (m_Parameters.m_SignalGen.m_KspaceLineOffset>0)
         PrintToLog("Simulating ghosts", false);
 
       doubleOutImage = SimulateKspaceAcquisition(m_CompartmentImages);
       signalScale = 1; // already scaled in SimulateKspaceAcquisition()
     }
     else    // don't do k-space stuff, just sum compartments
     {
       PrintToLog("Summing compartments");
       doubleOutImage = m_CompartmentImages.at(0);
 
       for (unsigned int i=1; i<m_CompartmentImages.size(); i++)
       {
         auto adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
         adder->SetInput1(doubleOutImage);
         adder->SetInput2(m_CompartmentImages.at(i));
         adder->Update();
         doubleOutImage = adder->GetOutput();
       }
     }
     if (this->GetAbortGenerateData())
     {
       PrintToLog("\n", false, false);
       PrintToLog("Simulation aborted");
       return;
     }
 
     PrintToLog("Finalizing image");
     if (signalScale>1)
       PrintToLog(" Scaling signal", false);
     if (m_Parameters.m_NoiseModel)
       PrintToLog(" Adding noise", false);
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (m_OutputImage, m_OutputImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     boost::progress_display disp2(m_OutputImage->GetLargestPossibleRegion().GetNumberOfPixels());
 
     PrintToLog("0%   10   20   30   40   50   60   70   80   90   100%", false, true, false);
     PrintToLog("|----|----|----|----|----|----|----|----|----|----|\n*", false, false, false);
     int lastTick = 0;
 
     while(!it4.IsAtEnd())
     {
       if (this->GetAbortGenerateData())
       {
         PrintToLog("\n", false, false);
         PrintToLog("Simulation aborted");
         return;
       }
 
       ++disp2;
       unsigned long newTick = 50*disp2.count()/disp2.expected_count();
       for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
         PrintToLog("*", false, false, false);
       lastTick = newTick;
 
       typename OutputImageType::IndexType index = it4.GetIndex();
       signal = doubleOutImage->GetPixel(index)*signalScale;
 
       if (m_Parameters.m_NoiseModel)
         m_Parameters.m_NoiseModel->AddNoise(signal);
 
       for (unsigned int i=0; i<signal.Size(); i++)
       {
         if (signal[i]>0)
           signal[i] = floor(signal[i]+0.5);
         else
           signal[i] = ceil(signal[i]-0.5);
 
         if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]>window)
           window = signal[i];
         if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]<min)
           min = signal[i];
       }
       it4.Set(signal);
       ++it4;
     }
     window -= min;
     unsigned int level = window/2 + min;
     m_LevelWindow.SetLevelWindow(level, window);
     this->SetNthOutput(0, m_OutputImage);
 
     PrintToLog("\n", false);
     PrintToLog("Finished simulation");
     m_TimeProbe.Stop();
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
       PrintToLog("\nHead motion log:", false);
       PrintToLog(m_MotionLog, false, false);
     }
 
     if (m_Parameters.m_SignalGen.m_Spikes>0)
     {
       PrintToLog("\nSpike log:", false);
       PrintToLog(m_SpikeLog, false, false);
     }
 
     if (m_Logfile.is_open()) m_Logfile.close();
   }
 
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::PrintToLog(string m, bool addTime, bool linebreak, bool stdOut)
   {
     // timestamp
     if (addTime)
     {
       m_Logfile << this->GetTime() << " > ";
       m_StatusText += this->GetTime() + " > ";
       if (stdOut)
         std::cout << this->GetTime() << " > ";
     }
 
     // message
     if (m_Logfile.is_open())
       m_Logfile << m;
     m_StatusText += m;
     if (stdOut)
       std::cout << m;
 
     // new line
     if (linebreak)
     {
       if (m_Logfile.is_open())
         m_Logfile << "\n";
       m_StatusText += "\n";
       if (stdOut)
         std::cout << "\n";
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::SimulateMotion(int g)
   {
     // is motion artifact enabled?
     // is the current volume g affected by motion?
     if ( m_Parameters.m_SignalGen.m_DoAddMotion
          && m_Parameters.m_SignalGen.m_MotionVolumes[g]
          && g<m_Parameters.m_SignalGen.GetNumVolumes() )
     {
       if ( m_Parameters.m_SignalGen.m_DoRandomizeMotion )
       {
         // either undo last transform or work on fresh copy of untransformed fibers
         m_FiberBundleTransformed = m_FiberBundleWorkingCopy->GetDeepCopy();
 
         m_Rotation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[0]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[0];
         m_Rotation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[1]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[1];
         m_Rotation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[2]*2)
                         -m_Parameters.m_SignalGen.m_Rotation[2];
 
         m_Translation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[0]*2)
                            -m_Parameters.m_SignalGen.m_Translation[0];
         m_Translation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[1]*2)
                            -m_Parameters.m_SignalGen.m_Translation[1];
         m_Translation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[2]*2)
                            -m_Parameters.m_SignalGen.m_Translation[2];
       }
       else
       {
         m_Rotation = m_Parameters.m_SignalGen.m_Rotation / m_NumMotionVolumes;
         m_Translation = m_Parameters.m_SignalGen.m_Translation / m_NumMotionVolumes;
         m_MotionCounter++;
       }
 
       // move mask image
       if (m_MaskImageSet)
       {
         ImageRegionIterator<ItkUcharImgType> maskIt(m_UpsampledMaskImage, m_UpsampledMaskImage->GetLargestPossibleRegion());
         m_TransformedMaskImage->FillBuffer(0);
 
         while(!maskIt.IsAtEnd())
         {
           if (maskIt.Get()<=0)
           {
             ++maskIt;
             continue;
           }
 
           DoubleDwiType::IndexType index = maskIt.GetIndex();
           itk::Point<double, 3> point;
           m_UpsampledMaskImage->TransformIndexToPhysicalPoint(index, point);
           if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
           {
             point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
                 m_Rotation[0],m_Rotation[1],m_Rotation[2],
                 m_Translation[0],m_Translation[1],m_Translation[2]);
           }
           else
           {
             point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
                 m_Rotation[0]*m_MotionCounter,m_Rotation[1]*m_MotionCounter,m_Rotation[2]*m_MotionCounter,
                 m_Translation[0]*m_MotionCounter,m_Translation[1]*m_MotionCounter,m_Translation[2]*m_MotionCounter);
           }
 
           m_TransformedMaskImage->TransformPhysicalPointToIndex(point, index);
 
           if (m_TransformedMaskImage->GetLargestPossibleRegion().IsInside(index))
           { m_TransformedMaskImage->SetPixel(index,100); }
           ++maskIt;
         }
       }
 
       if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
       {
         m_Rotations.push_back(m_Rotation);
         m_Translations.push_back(m_Translation);
 
         m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
             + "," + boost::lexical_cast<std::string>(m_Rotation[1])
             + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
         m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
             + "," + boost::lexical_cast<std::string>(m_Translation[1])
             + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
       }
       else
       {
         m_Rotations.push_back(m_Rotation*m_MotionCounter);
         m_Translations.push_back(m_Translation*m_MotionCounter);
 
         m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Rotation[1]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Rotation[2]*m_MotionCounter) + ";";
 
         m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Translation[1]*m_MotionCounter)
             + "," + boost::lexical_cast<std::string>(m_Translation[2]*m_MotionCounter) + "\n";
       }
 
       m_FiberBundleTransformed->TransformFibers(m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
     }
     else
     {
       m_Rotation.Fill(0.0);
       m_Translation.Fill(0.0);
       m_Rotations.push_back(m_Rotation);
       m_Translations.push_back(m_Translation);
 
       m_MotionLog += boost::lexical_cast<std::string>(g) + " rotation: " + boost::lexical_cast<std::string>(m_Rotation[0])
           + "," + boost::lexical_cast<std::string>(m_Rotation[1])
           + "," + boost::lexical_cast<std::string>(m_Rotation[2]) + ";";
 
       m_MotionLog += " translation: " + boost::lexical_cast<std::string>(m_Translation[0])
           + "," + boost::lexical_cast<std::string>(m_Translation[1])
           + "," + boost::lexical_cast<std::string>(m_Translation[2]) + "\n";
     }
   }
 
   template< class PixelType >
   void TractsToDWIImageFilter< PixelType >::
   SimulateExtraAxonalSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g)
   {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
     if (intraAxonalVolume>0.0001 && m_Parameters.m_SignalGen.m_DoDisablePartialVolume)  // only fiber in voxel
     {
       DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
       if (g>=0)
         pix[g] *= m_VoxelVolume/intraAxonalVolume;
       else
         pix *= m_VoxelVolume/intraAxonalVolume;
       m_CompartmentImages.at(0)->SetPixel(index, pix);
       if (g==0)
         m_VolumeFractions.at(0)->SetPixel(index, 1);
       for (int i=1; i<numFiberCompartments; i++)
       {
         DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
         if (g>=0)
           pix[g] = 0.0;
         else
           pix.Fill(0.0);
         m_CompartmentImages.at(i)->SetPixel(index, pix);
       }
     }
     else
     {
       if (g==0)
       {
         m_VolumeFractions.at(0)->SetPixel(index, intraAxonalVolume/m_VoxelVolume);
       }
 
       // get non-transformed point (remove headmotion tranformation)
       // this point can then be transformed to each of the original images, regardless of their geometry
       itk::Point<double, 3> point;
       m_TransformedMaskImage->TransformIndexToPhysicalPoint(index, point);
 
       if ( m_Parameters.m_SignalGen.m_DoAddMotion && g>=0
            && m_Parameters.m_SignalGen.m_MotionVolumes[g] )
       {
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
           point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
               -m_Rotation[0],-m_Rotation[1],-m_Rotation[2],
               -m_Translation[0],-m_Translation[1],-m_Translation[2]);
         }
         else
         {
           point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(),
               -m_Rotation[0]*m_MotionCounter,-m_Rotation[1]*m_MotionCounter,-m_Rotation[2]*m_MotionCounter,
               -m_Translation[0]*m_MotionCounter,-m_Translation[1]*m_MotionCounter,-m_Translation[2]*m_MotionCounter);
         }
       }
 
       if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)
       {
         int maxVolumeIndex = 0;
         double maxWeight = 0;
         for (int i=0; i<numNonFiberCompartments; i++)
         {
           double weight = 0;
           if (numNonFiberCompartments>1)
           {
             double val = InterpolateValue(point, m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
             if (val<0)
               continue;
             else
               weight = val;
           }
 
           if (weight>maxWeight)
           {
             maxWeight = weight;
             maxVolumeIndex = i;
           }
         }
 
         DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(maxVolumeIndex+numFiberCompartments);
         DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
 
         if (g>=0)
           pix[g] += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement(g)*m_VoxelVolume;
         else
           pix += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement()*m_VoxelVolume;
         doubleDwi->SetPixel(index, pix);
         if (g==0)
           m_VolumeFractions.at(maxVolumeIndex+numFiberCompartments)->SetPixel(index, 1);
       }
       else
       {
         double extraAxonalVolume = m_VoxelVolume-intraAxonalVolume;    // non-fiber volume
         if (extraAxonalVolume<0)
         {
           if (extraAxonalVolume<-0.001)
             MITK_ERROR << "Corrupted intra-axonal signal voxel detected. Fiber volume larger voxel volume! " << m_VoxelVolume << "<" << intraAxonalVolume;
           extraAxonalVolume = 0;
         }
         double interAxonalVolume = 0;
         if (numFiberCompartments>1)
           interAxonalVolume = extraAxonalVolume * intraAxonalVolume/m_VoxelVolume;   // inter-axonal fraction of non fiber compartment
         double other = extraAxonalVolume - interAxonalVolume;        // rest of compartment
         if (other<0)
         {
           if (other<-0.001)
             MITK_ERROR << "Corrupted signal voxel detected. Fiber volume larger voxel volume!";
           other = 0;
         }
 
         // adjust non-fiber and intra-axonal signal
         for (int i=1; i<numFiberCompartments; i++)
         {
           double weight = interAxonalVolume;
           DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
           if (intraAxonalVolume>0)    // remove scaling by intra-axonal volume from inter-axonal compartment
           {
             if (g>=0)
               pix[g] /= intraAxonalVolume;
             else
               pix /= intraAxonalVolume;
           }
 
           if (m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage()!=nullptr)
           {
             double val = InterpolateValue(point, m_Parameters.m_FiberModelList[i]->GetVolumeFractionImage());
             if (val<0)
               continue;
             else
               weight = val*m_VoxelVolume;
           }
 
           if (g>=0)
             pix[g] *= weight;
           else
             pix *= weight;
           m_CompartmentImages.at(i)->SetPixel(index, pix);
           if (g==0)
             m_VolumeFractions.at(i)->SetPixel(index, weight/m_VoxelVolume);
         }
 
         for (int i=0; i<numNonFiberCompartments; i++)
         {
           double weight = other;
           DoubleDwiType::PixelType pix = m_CompartmentImages.at(i+numFiberCompartments)->GetPixel(index);
           if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()!=nullptr)
           {
             double val = InterpolateValue(point, m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
             if (val<0)
               continue;
             else
               weight = val*m_VoxelVolume;
 
             if (m_UseRelativeNonFiberVolumeFractions)
               weight *= other/m_VoxelVolume;
           }
 
           if (g>=0)
             pix[g] += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement(g)*weight;
           else
             pix += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement()*weight;
           m_CompartmentImages.at(i+numFiberCompartments)->SetPixel(index, pix);
           if (g==0)
             m_VolumeFractions.at(i+numFiberCompartments)->SetPixel(index, weight/m_VoxelVolume);
         }
       }
     }
   }
 
   template< class PixelType >
   double TractsToDWIImageFilter< PixelType >::
   InterpolateValue(itk::Point<float, 3> itkP, ItkDoubleImgType::Pointer img)
   {
     itk::Index<3> idx;
     itk::ContinuousIndex< double, 3> cIdx;
     img->TransformPhysicalPointToIndex(itkP, idx);
     img->TransformPhysicalPointToContinuousIndex(itkP, cIdx);
 
     double pix = -1;
     if ( img->GetLargestPossibleRegion().IsInside(idx) )
       pix = img->GetPixel(idx);
     else
       return pix;
 
     double frac_x = cIdx[0] - idx[0];
     double frac_y = cIdx[1] - idx[1];
     double frac_z = cIdx[2] - idx[2];
     if (frac_x<0)
     {
       idx[0] -= 1;
       frac_x += 1;
     }
     if (frac_y<0)
     {
       idx[1] -= 1;
       frac_y += 1;
     }
     if (frac_z<0)
     {
       idx[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 (idx[0] >= 0 && idx[0] < img->GetLargestPossibleRegion().GetSize(0)-1 &&
         idx[1] >= 0 && idx[1] < img->GetLargestPossibleRegion().GetSize(1)-1 &&
         idx[2] >= 0 && idx[2] < img->GetLargestPossibleRegion().GetSize(2)-1)
     {
       vnl_vector_fixed<double, 8> interpWeights;
       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);
 
       pix = img->GetPixel(idx) * interpWeights[0];
       ItkDoubleImgType::IndexType tmpIdx = idx; tmpIdx[0]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[1];
       tmpIdx = idx; tmpIdx[1]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[2];
       tmpIdx = idx; tmpIdx[2]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[3];
       tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[4];
       tmpIdx = idx; tmpIdx[1]++; tmpIdx[2]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[5];
       tmpIdx = idx; tmpIdx[2]++; tmpIdx[0]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[6];
       tmpIdx = idx; tmpIdx[0]++; tmpIdx[1]++; tmpIdx[2]++;
       pix +=  img->GetPixel(tmpIdx) * interpWeights[7];
     }
 
     return pix;
   }
 
   template< class PixelType >
   itk::Point<float, 3> TractsToDWIImageFilter< PixelType >::GetItkPoint(double point[3])
   {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
   }
 
   template< class PixelType >
   itk::Vector<double, 3> TractsToDWIImageFilter< PixelType >::GetItkVector(double point[3])
   {
     itk::Vector<double, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
   }
 
   template< class PixelType >
   vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(double point[3])
   {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
   }
 
   template< class PixelType >
   vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(Vector<float,3>& vector)
   {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
   }
 
   template< class PixelType >
   double TractsToDWIImageFilter< PixelType >::RoundToNearest(double num) {
     return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
   }
 
   template< class PixelType >
   std::string TractsToDWIImageFilter< PixelType >::GetTime()
   {
     m_TimeProbe.Stop();
     unsigned long total = RoundToNearest(m_TimeProbe.GetTotal());
     unsigned long hours = total/3600;
     unsigned long minutes = (total%3600)/60;
     unsigned long seconds = total%60;
     std::string out = "";
     out.append(boost::lexical_cast<std::string>(hours));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(minutes));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(seconds));
     m_TimeProbe.Start();
     return out;
   }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
index 80ef2c1f12..16dd39451c 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
@@ -1,3453 +1,3447 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberfoxViewControls</class>
  <widget class="QWidget" name="QmitkFiberfoxViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>524</width>
     <height>2652</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="3" column="0">
     <widget class="QCommandLinkButton" name="m_LoadParametersButton">
      <property name="text">
       <string>Load Parameters</string>
      </property>
      <property name="icon">
       <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
        <normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</iconset>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Fiber Definition</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_8">
        <item row="7" column="0">
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="m_FiberGenMessage">
          <property name="styleSheet">
           <string notr="true">color: rgb(255, 0, 0);</string>
          </property>
          <property name="text">
           <string>Please select an image or an existing fiber bundle to draw the fiber fiducials. If you can't provide a suitable image, generate one using the &quot;Signal Generation&quot; tab.</string>
          </property>
          <property name="textFormat">
           <enum>Qt::AutoText</enum>
          </property>
          <property name="alignment">
           <set>Qt::AlignJustify|Qt::AlignVCenter</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QGroupBox" name="groupBox_7">
          <property name="title">
           <string>Fiducial Options</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_16">
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_ConstantRadiusBox">
             <property name="toolTip">
              <string>All fiducials are treated as circles with the same radius as the first fiducial. </string>
             </property>
             <property name="text">
              <string>Use Constant Fiducial Radius</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QCommandLinkButton" name="m_AlignOnGrid">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="toolTip">
              <string>Align selected fiducials with voxel grid. Shifts selected fiducials to nearest voxel center.</string>
             </property>
             <property name="text">
              <string>Align With Grid</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="6" column="0" colspan="2">
         <widget class="QGroupBox" name="groupBox_4">
          <property name="title">
           <string>Operations</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <item row="5" column="0">
            <widget class="QCommandLinkButton" name="m_JoinBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Join Bundles</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/plus.ico</normaloff>:/QmitkDiffusionImaging/general_icons/plus.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QFrame" name="frame_4">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_12">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="1" column="2">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_18">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Y</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QDoubleSpinBox" name="m_XrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around x-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_22">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Axis:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="2">
               <widget class="QDoubleSpinBox" name="m_YrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around y-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_21">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Translation:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="3">
               <widget class="QDoubleSpinBox" name="m_ZtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the z-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="2">
               <widget class="QDoubleSpinBox" name="m_YtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the y-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_17">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>X</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_20">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Rotation:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="3">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_19">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Z</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="3">
               <widget class="QDoubleSpinBox" name="m_ZrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around z-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QDoubleSpinBox" name="m_XtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the x-axis.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_24">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Scaling:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="4" column="1">
               <widget class="QDoubleSpinBox" name="m_XscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the x-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="2">
               <widget class="QDoubleSpinBox" name="m_YscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the y-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="3">
               <widget class="QDoubleSpinBox" name="m_ZscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the z-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QCommandLinkButton" name="m_CopyBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Copy Bundles</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/copy2.ico</normaloff>:/QmitkDiffusionImaging/general_icons/copy2.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCommandLinkButton" name="m_TransformBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Transform Selection</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/refresh.ico</normaloff>:/QmitkDiffusionImaging/general_icons/refresh.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_IncludeFiducials">
             <property name="toolTip">
              <string>If checked, the fiducials belonging to the modified bundle are also modified.</string>
             </property>
             <property name="text">
              <string>Include Fiducials</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QGroupBox" name="groupBox_8">
          <property name="title">
           <string>Fiber Options</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_15">
           <item row="2" column="0">
            <widget class="QFrame" name="frame_5">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_9">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="2" column="0">
               <widget class="QFrame" name="m_AdvancedFiberOptionsFrame">
                <property name="frameShape">
                 <enum>QFrame::NoFrame</enum>
                </property>
                <property name="frameShadow">
                 <enum>QFrame::Raised</enum>
                </property>
                <layout class="QGridLayout" name="gridLayout_21">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_5">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Tension:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_8">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Fiber Sampling:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_TensionBox">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="3" column="1">
                  <widget class="QDoubleSpinBox" name="m_BiasBox">
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="3" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_7">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Bias:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_6">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Continuity:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="1">
                  <widget class="QDoubleSpinBox" name="m_ContinuityBox">
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QDoubleSpinBox" name="m_FiberSamplingBox">
                   <property name="toolTip">
                    <string>Distance of fiber sampling points (in mm)</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>1.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QFrame" name="frame_2">
                <property name="frameShape">
                 <enum>QFrame::NoFrame</enum>
                </property>
                <property name="frameShadow">
                 <enum>QFrame::Raised</enum>
                </property>
                <layout class="QGridLayout" name="gridLayout_25">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <property name="verticalSpacing">
                  <number>6</number>
                 </property>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_4">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>#Fibers:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QSpinBox" name="m_FiberDensityBox">
                   <property name="toolTip">
                    <string>Specify number of fibers to generate for the selected bundle.</string>
                   </property>
                   <property name="minimum">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <number>1000000</number>
                   </property>
                   <property name="singleStep">
                    <number>100</number>
                   </property>
                   <property name="value">
                    <number>100</number>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCommandLinkButton" name="m_GenerateFibersButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Generate Fibers</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QFrame" name="frame_3">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="1">
               <widget class="QComboBox" name="m_DistributionBox">
                <property name="toolTip">
                 <string>Select fiber distribution inside of the fiducials.</string>
                </property>
                <item>
                 <property name="text">
                  <string>Uniform</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Gaussian</string>
                 </property>
                </item>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_9">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Fiber Distribution:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QDoubleSpinBox" name="m_VarianceBox">
                <property name="toolTip">
                 <string>Variance of the gaussian</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.001000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QFrame" name="frame_8">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_22">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QCheckBox" name="m_RealTimeFibers">
                <property name="toolTip">
                 <string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
                </property>
                <property name="text">
                 <string>Real Time Fibers</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QCheckBox" name="m_AdvancedOptionsBox">
                <property name="toolTip">
                 <string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
                </property>
                <property name="text">
                 <string>Advanced Options</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="frame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_3">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QPushButton" name="m_CircleButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Draw elliptical fiducial.</string>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/circle.png</normaloff>:/QmitkDiffusionImaging/circle.png</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QPushButton" name="m_FlipButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip fiber waypoints of selcted fiducial around one axis.</string>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/refresh.xpm</normaloff>:/QmitkDiffusionImaging/refresh.xpm</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <spacer name="horizontalSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Signal Generation</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="10" column="0">
         <widget class="QGroupBox" name="groupBox_6">
          <property name="title">
           <string>Extra-axonal Compartments</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_14">
           <item row="18" column="0">
            <widget class="QFrame" name="m_Comp4FractionFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_30">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_9">
                <property name="text">
                 <string>Volume Fraction:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp4VolumeFraction">
                <property name="toolTip">
                 <string/>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QComboBox" name="m_Compartment3Box">
             <property name="toolTip">
              <string>Select signal model for extra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>Ball Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Astrosticks Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Dot Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="8" column="0">
            <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget1" native="true"/>
           </item>
           <item row="10" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget3" native="true"/>
           </item>
           <item row="16" column="0">
            <widget class="QmitkDotModelParametersWidget" name="m_DotWidget2" native="true"/>
           </item>
           <item row="9" column="0">
            <widget class="QmitkDotModelParametersWidget" name="m_DotWidget1" native="true"/>
           </item>
           <item row="12" column="0">
            <widget class="Line" name="line_2">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="11" column="0">
            <widget class="QFrame" name="m_Comp3FractionFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_29">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_8">
                <property name="text">
                 <string>Volume Fraction:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp3VolumeFraction">
                <property name="toolTip">
                 <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="14" column="0">
            <widget class="QmitkBallModelParametersWidget" name="m_BallWidget2" native="true"/>
           </item>
           <item row="7" column="0">
            <widget class="QmitkBallModelParametersWidget" name="m_BallWidget1" native="true"/>
           </item>
           <item row="15" column="0">
            <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget2" native="true"/>
           </item>
           <item row="13" column="0">
            <widget class="QComboBox" name="m_Compartment4Box">
             <property name="toolTip">
              <string>Select signal model for extra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>--</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Ball Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Astrosticks Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Dot Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="17" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget4" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item row="13" column="0">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="7" column="0">
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Image Settings</string>
          </property>
          <layout class="QGridLayout" name="gridLayout">
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_AdvancedOptionsBox_2">
             <property name="text">
              <string>Advanced Options</string>
             </property>
            </widget>
           </item>
           <item row="5" column="0">
            <widget class="QFrame" name="m_TensorsToDWIFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_24">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="spacing">
               <number>6</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel">
                <property name="text">
                 <string>Gradient Directions:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_NumGradientsBox">
                <property name="toolTip">
                 <string>Number of gradient directions distributed over the half sphere.</string>
                </property>
                <property name="minimum">
                 <number>0</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>30</number>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;b-Value&lt;span style=&quot; font-style:italic;&quot;&gt; [s/mm&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:super;&quot;&gt;2&lt;/span&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;]&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QSpinBox" name="m_BvalueBox">
                <property name="toolTip">
                 <string>b-value in s/mm²</string>
                </property>
                <property name="minimum">
                 <number>0</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>100</number>
                </property>
                <property name="value">
                 <number>1000</number>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="m_GeometryMessage">
             <property name="styleSheet">
              <string notr="true">color: rgb(255, 0, 0);</string>
             </property>
             <property name="text">
              <string>Using  geometry of selected image!</string>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QLabel" name="m_DiffusionPropsMessage">
             <property name="styleSheet">
              <string notr="true">color: rgb(255, 0, 0);</string>
             </property>
             <property name="text">
              <string>Using  gradients of selected DWI!</string>
             </property>
            </widget>
           </item>
           <item row="7" column="0">
            <widget class="QFrame" name="m_AdvancedSignalOptionsFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_23">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <item row="2" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_13">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Number of Channels:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="6" column="1">
               <widget class="QSpinBox" name="m_TRbox">
                <property name="toolTip">
                 <string>TR in milliseconds</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>999999999</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>4000</number>
                </property>
               </widget>
              </item>
              <item row="12" column="0">
               <widget class="QCheckBox" name="m_ReversePhaseBox">
                <property name="toolTip">
                 <string>Output one image per compartment containing the corresponding volume fractions per voxel.</string>
                </property>
                <property name="text">
                 <string>Reverse Phase Encoding Direction</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_5">
                <property name="text">
                 <string>Signal Scale:</string>
                </property>
               </widget>
              </item>
-             <item row="11" column="1">
-              <widget class="QSpinBox" name="m_FiberRadius">
-               <property name="toolTip">
-                <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
-               </property>
-               <property name="minimum">
-                <number>0</number>
-               </property>
-               <property name="maximum">
-                <number>1000</number>
-               </property>
-               <property name="value">
-                <number>0</number>
-               </property>
-              </widget>
-             </item>
              <item row="7" column="1">
               <widget class="QDoubleSpinBox" name="m_LineReadoutTimeBox">
                <property name="toolTip">
                 <string>Dwell time (time to read one line in k-space) in ms.</string>
                </property>
                <property name="maximum">
                 <double>100.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="1">
               <widget class="QSpinBox" name="m_TEbox">
                <property name="toolTip">
                 <string>TE in milliseconds</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>999999999</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>100</number>
                </property>
               </widget>
              </item>
              <item row="11" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_4">
                <property name="text">
                 <string>Fiber Radius:</string>
                </property>
               </widget>
              </item>
              <item row="8" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_32">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Partial Fourier:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="14" column="0">
               <widget class="QCheckBox" name="m_EnforcePureFiberVoxelsBox">
                <property name="toolTip">
                 <string>Disable partial volume. Treat voxel content as fiber-only if at least one fiber is present.</string>
                </property>
                <property name="text">
                 <string>Disable Partial Volume Effects</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_34">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Coil Sensitivity:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="8" column="1">
               <widget class="QDoubleSpinBox" name="m_PartialFourier">
                <property name="toolTip">
                 <string>Partial fourier factor (0.5-1)</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.500000000000000</double>
                </property>
                <property name="maximum">
                 <double>1.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="15" column="0">
               <widget class="QCheckBox" name="m_VolumeFractionsBox">
                <property name="toolTip">
                 <string>Output phase image and volume fraction maps.</string>
                </property>
                <property name="text">
                 <string>Output Additional Images</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="9" column="1">
               <widget class="QSpinBox" name="m_T2starBox">
                <property name="toolTip">
                 <string>Relaxation time due to magnetic field inhomogeneities (T2', in milliseconds).</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>50</number>
                </property>
               </widget>
              </item>
              <item row="6" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_14">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Repetition Time &lt;span style=&quot; font-style:italic;&quot;&gt;TR&lt;/span&gt;: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QComboBox" name="m_CoilSensBox">
                <item>
                 <property name="text">
                  <string>Constant</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Linear</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Exponential</string>
                 </property>
                </item>
               </widget>
              </item>
              <item row="7" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_15">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Dwell Time:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="9" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_12">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; Relaxation: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="13" column="0">
               <widget class="QCheckBox" name="m_RelaxationBox">
                <property name="toolTip">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;, &lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; and &lt;span style=&quot; font-style:italic;&quot;&gt;T2&lt;/span&gt; will have no effect if unchecked.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="text">
                 <string>Simulate Signal Relaxation</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_33">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Echo Time &lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;:  &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QSpinBox" name="m_SignalScaleBox">
                <property name="toolTip">
                 <string>TE in milliseconds</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>100</number>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QSpinBox" name="m_NumCoilsBox">
                <property name="toolTip">
                 <string>Number of coil elements used for the acquisiton.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>128</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>1</number>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_6">
                <property name="text">
                 <string>Acquisition Type:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QComboBox" name="m_AcquisitionTypeBox">
                <item>
                 <property name="text">
                  <string>Single Shot EPI</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Spin Echo</string>
                 </property>
                </item>
               </widget>
              </item>
+             <item row="11" column="1">
+              <widget class="QDoubleSpinBox" name="m_FiberRadius">
+               <property name="toolTip">
+                <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
+               </property>
+               <property name="maximum">
+                <double>9999.000000000000000</double>
+               </property>
+              </widget>
+             </item>
             </layout>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QFrame" name="m_GeometryFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_7">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="2" column="2">
               <widget class="QDoubleSpinBox" name="m_SpacingY">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="label_2">
                <property name="text">
                 <string>Image Spacing:</string>
                </property>
               </widget>
              </item>
              <item row="2" column="3">
               <widget class="QDoubleSpinBox" name="m_SpacingZ">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QDoubleSpinBox" name="m_SpacingX">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="label">
                <property name="text">
                 <string>Image Dimensions:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_SizeX">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>20</number>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QSpinBox" name="m_SizeY">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>20</number>
                </property>
               </widget>
              </item>
              <item row="0" column="3">
               <widget class="QSpinBox" name="m_SizeZ">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>3</number>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="9" column="0">
         <widget class="QGroupBox" name="groupBox_5">
          <property name="title">
           <string>Inter-axonal Compartment</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_17">
           <item row="0" column="0">
            <widget class="QComboBox" name="m_Compartment2Box">
             <property name="toolTip">
              <string>Select signal model for intra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>--</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Stick Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Zeppelin Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Tensor Model</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget2" native="true"/>
           </item>
           <item row="2" column="0">
            <widget class="QmitkStickModelParametersWidget" name="m_StickWidget2" native="true"/>
           </item>
           <item row="3" column="0">
            <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget2" native="true"/>
           </item>
           <item row="4" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget2" native="true"/>
           </item>
           <item row="5" column="0">
            <widget class="QFrame" name="m_Comp2FractionFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_27">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_7">
                <property name="text">
                 <string>Volume Fraction:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp2VolumeFraction">
                <property name="toolTip">
                 <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QCommandLinkButton" name="m_AbortSimulationButton">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="toolTip">
           <string>Stop current simulation.</string>
          </property>
          <property name="text">
           <string>Abort Simulation</string>
          </property>
          <property name="icon">
           <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
            <normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</iconset>
          </property>
         </widget>
        </item>
        <item row="0" column="0" rowspan="2">
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
           <string>Data</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_10">
           <item row="4" column="2">
            <widget class="QFrame" name="frame_6">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_20">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="spacing">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLineEdit" name="m_SavePathEdit">
                <property name="text">
                 <string>-</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QToolButton" name="m_OutputPathButton">
                <property name="text">
                 <string>...</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="2" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_MaskComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a binary image to define the area of signal generation. Outside of the mask image only noise will be actively generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
           <item row="0" column="0" rowspan="2" colspan="2">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_16">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Fiber Bundle:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_10">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Save path:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_3">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Tissue Mask:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_FiberBundleComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a fiber bundle to generate the white matter signal from. You can either use the fiber definition tab to manually define an input fiber bundle or you can also use any existing bundle, e.g. yielded by a tractography algorithm.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_11">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Template Image:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="3" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TemplateComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The parameters for the simulation (e.g. spacing, size, diffuison-weighted gradients, b-value) are adopted from this image.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QTextEdit" name="m_SimulationStatusText">
          <property name="font">
           <font>
            <pointsize>8</pointsize>
           </font>
          </property>
          <property name="readOnly">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="12" column="0">
         <widget class="QGroupBox" name="groupBox_3">
          <property name="title">
           <string>Noise and other Artifacts</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_6">
           <item row="12" column="0">
            <widget class="QCheckBox" name="m_AddDistortions">
             <property name="text">
              <string>Add Distortions</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCheckBox" name="m_AddSpikes">
             <property name="text">
              <string>Add Spikes</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="20" column="0">
            <widget class="QFrame" name="m_EddyFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_8">
              <property name="fieldGrowthPolicy">
               <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_26">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Gradient:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_EddyGradientStrength">
                <property name="toolTip">
                 <string>Eddy current induced magnetic field gradient (in mT/m).</string>
                </property>
                <property name="decimals">
                 <number>4</number>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.001000000000000</double>
                </property>
                <property name="value">
                 <double>0.010000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="15" column="0">
            <widget class="QCheckBox" name="m_AddMotion">
             <property name="text">
              <string>Add Motion Artifacts</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="5" column="0">
            <widget class="Line" name="line_8">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="7" column="0">
            <widget class="QFrame" name="m_GhostFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_6">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_23">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>K-Space Line Offset:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_kOffsetBox">
                <property name="toolTip">
                 <string>A larger offset increases the inensity of the ghost image.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="maximum">
                 <double>1.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>0.250000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_AddNoise">
             <property name="text">
              <string>Add Noise</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QFrame" name="m_SpikeFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_9">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_2">
                <property name="text">
                 <string>Num. Spikes:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_SpikeNumBox">
                <property name="toolTip">
                 <string>The number of randomly occurring signal spikes.</string>
                </property>
                <property name="value">
                 <number>1</number>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_SpikeScaleBox">
                <property name="toolTip">
                 <string>Spike amplitude relative to the largest signal amplitude of the corresponding k-space slice.</string>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_NoiseLabel_4">
                <property name="text">
                 <string>Scale:</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="16" column="0">
            <widget class="QFrame" name="m_MotionArtifactFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_18">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>6</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <item row="0" column="0">
               <widget class="QCheckBox" name="m_RandomMotion">
                <property name="toolTip">
                 <string>Toggle between random movement and linear movement.</string>
                </property>
                <property name="text">
                 <string>Randomize motion</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QGroupBox" name="m_RotationArtifactFrame">
                <property name="title">
                 <string>Rotation</string>
                </property>
                <layout class="QGridLayout" name="gridLayout_19">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>9</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_36">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Degree:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_29">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>x</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_28">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Axis:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxX">
                   <property name="toolTip">
                    <string>Maximum rotation around x-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-360.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="3">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxZ">
                   <property name="toolTip">
                    <string>Maximum rotation around z-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-360.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>15.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="2">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_30">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>y</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="3">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_31">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>z</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="2">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxY">
                   <property name="toolTip">
                    <string>Maximum rotation around y-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-360.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QGroupBox" name="m_TranslationArtifactFrame">
                <property name="title">
                 <string>Translation</string>
                </property>
                <layout class="QGridLayout" name="gridLayout_28">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_48">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Distance:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_51">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>x</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="2">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_52">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>y</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_47">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Axis:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="3">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_53">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>z</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxX">
                   <property name="toolTip">
                    <string>Maximum translation along x-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-1000.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="2">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxY">
                   <property name="toolTip">
                    <string>Maximum translation along y-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-1000.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="3">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxZ">
                   <property name="toolTip">
                    <string>Maximum translation along z-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>-1000.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QFrame" name="frame_7">
                <property name="frameShape">
                 <enum>QFrame::NoFrame</enum>
                </property>
                <property name="frameShadow">
                 <enum>QFrame::Raised</enum>
                </property>
                <layout class="QGridLayout" name="gridLayout_31">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="0" column="0">
                  <widget class="QLabel" name="label_3">
                   <property name="text">
                    <string>Motion volumes:</string>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QLineEdit" name="m_MotionVolumesBox">
                   <property name="toolTip">
                    <string>Type in the volume indices that should be affected by motion (e.g. &quot;0 3 7&quot; whithout quotation marks). Leave blank for motion in all volumes. Type in &quot;random&quot; to randomly select volumes for motion. A list of negative numbers (e.g. -1 -2 -3) excludes volumes (e.g. 1 2 3) selects all remaining volumes. </string>
                   </property>
                   <property name="text">
                    <string>random</string>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="22" column="0">
            <widget class="QCheckBox" name="m_AddGibbsRinging">
             <property name="toolTip">
              <string>Add ringing artifacts occuring at strong edges in the image.</string>
             </property>
             <property name="text">
              <string>Add Gibbs Ringing</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="Line" name="line_9">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="8" column="0">
            <widget class="Line" name="line_7">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="18" column="0">
            <widget class="Line" name="line_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="21" column="0">
            <widget class="Line" name="line">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_AddGhosts">
             <property name="text">
              <string>Add N/2 Ghosts</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="9" column="0">
            <widget class="QCheckBox" name="m_AddAliasing">
             <property name="text">
              <string>Add Aliasing</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="11" column="0">
            <widget class="Line" name="line_6">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="14" column="0">
            <widget class="Line" name="line_5">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="19" column="0">
            <widget class="QCheckBox" name="m_AddEddy">
             <property name="toolTip">
              <string/>
             </property>
             <property name="text">
              <string>Add Eddy Current Effects</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="10" column="0">
            <widget class="QFrame" name="m_AliasingFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_10">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_27">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Shrink FOV (%):</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_WrapBox">
                <property name="toolTip">
                 <string>Shrink FOV by this percentage.</string>
                </property>
                <property name="decimals">
                 <number>1</number>
                </property>
                <property name="minimum">
                 <double>0.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>90.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>25.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="13" column="0">
            <widget class="QFrame" name="m_DistortionsFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_7">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_25">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Frequency Map:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBox" name="m_FrequencyMapBox">
                <property name="toolTip">
                 <string>Select image specifying the frequency inhomogeneities (in Hz).</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QFrame" name="m_NoiseFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="1" column="0">
               <widget class="QLabel" name="m_NoiseLabel">
                <property name="text">
                 <string>Variance:</string>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_NoiseLevel">
                <property name="toolTip">
                 <string>Variance of selected noise distribution.</string>
                </property>
                <property name="decimals">
                 <number>10</number>
                </property>
                <property name="minimum">
                 <double>0.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>999999999.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.001000000000000</double>
                </property>
                <property name="value">
                 <double>50.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_5">
                <property name="text">
                 <string>Distribution:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QComboBox" name="m_NoiseDistributionBox">
                <property name="toolTip">
                 <string>Noise distribution</string>
                </property>
                <item>
                 <property name="text">
                  <string>Complex Gaussian</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Rician</string>
                 </property>
                </item>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QCommandLinkButton" name="m_GenerateImageButton">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="toolTip">
           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Start DWI generation from selected fiber bundle.&lt;/p&gt;&lt;p&gt;If no fiber bundle but an existing diffusion weighted image is selected, the enabled artifacts are added to this image.&lt;/p&gt;&lt;p&gt;If neither a fiber bundle nor a diffusion weighted image is selected, a grayscale image containing a simple gradient is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="text">
           <string>Start Simulation</string>
          </property>
          <property name="icon">
           <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
            <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
          </property>
         </widget>
        </item>
        <item row="8" column="0">
         <widget class="QGroupBox" name="m_IntraAxonalGroupBox">
          <property name="title">
           <string>Intra-axonal Compartment</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_13">
           <item row="3" column="0">
            <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget1" native="true"/>
           </item>
           <item row="1" column="0">
            <widget class="QmitkStickModelParametersWidget" name="m_StickWidget1" native="true"/>
           </item>
           <item row="4" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget1" native="true"/>
           </item>
           <item row="0" column="0">
            <widget class="QComboBox" name="m_Compartment1Box">
             <property name="toolTip">
              <string>Select signal model for intra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>Stick Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Zeppelin Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Tensor Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget1" native="true"/>
           </item>
           <item row="5" column="0">
            <widget class="QFrame" name="m_Comp1FractionFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_26">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_6">
                <property name="text">
                 <string>Volume Fraction:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_Comp1VolumeFraction">
                <property name="toolTip">
                 <string>Optional! If no volume fraction map for this compartment is set, the corresponding volume fractions are calculated from the input fibers.</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QCommandLinkButton" name="m_SaveParametersButton">
      <property name="text">
       <string>Save Parameters</string>
      </property>
      <property name="icon">
       <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
        <normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</iconset>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkTensorModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkTensorModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkStickModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkStickModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkZeppelinModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkZeppelinModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkBallModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkBallModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkAstrosticksModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkAstrosticksModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDotModelParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkDotModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkPrototypeSignalParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkPrototypeSignalParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDataStorageComboBoxWithSelectNone</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBoxWithSelectNone.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>m_CircleButton</tabstop>
   <tabstop>m_FlipButton</tabstop>
   <tabstop>m_RealTimeFibers</tabstop>
   <tabstop>m_AdvancedOptionsBox</tabstop>
   <tabstop>m_DistributionBox</tabstop>
   <tabstop>m_VarianceBox</tabstop>
   <tabstop>m_FiberDensityBox</tabstop>
   <tabstop>m_FiberSamplingBox</tabstop>
   <tabstop>m_TensionBox</tabstop>
   <tabstop>m_ContinuityBox</tabstop>
   <tabstop>m_BiasBox</tabstop>
   <tabstop>m_GenerateFibersButton</tabstop>
   <tabstop>m_ConstantRadiusBox</tabstop>
   <tabstop>m_AlignOnGrid</tabstop>
   <tabstop>m_XrotBox</tabstop>
   <tabstop>m_YrotBox</tabstop>
   <tabstop>m_ZrotBox</tabstop>
   <tabstop>m_XtransBox</tabstop>
   <tabstop>m_YtransBox</tabstop>
   <tabstop>m_ZtransBox</tabstop>
   <tabstop>m_XscaleBox</tabstop>
   <tabstop>m_YscaleBox</tabstop>
   <tabstop>m_ZscaleBox</tabstop>
   <tabstop>m_TransformBundlesButton</tabstop>
   <tabstop>m_CopyBundlesButton</tabstop>
   <tabstop>m_JoinBundlesButton</tabstop>
   <tabstop>m_IncludeFiducials</tabstop>
   <tabstop>m_FiberBundleComboBox</tabstop>
   <tabstop>m_MaskComboBox</tabstop>
   <tabstop>m_TemplateComboBox</tabstop>
   <tabstop>m_SavePathEdit</tabstop>
   <tabstop>m_OutputPathButton</tabstop>
   <tabstop>m_GenerateImageButton</tabstop>
   <tabstop>m_AbortSimulationButton</tabstop>
   <tabstop>m_SimulationStatusText</tabstop>
   <tabstop>m_SizeX</tabstop>
   <tabstop>m_SizeY</tabstop>
   <tabstop>m_SizeZ</tabstop>
   <tabstop>m_SpacingX</tabstop>
   <tabstop>m_SpacingY</tabstop>
   <tabstop>m_SpacingZ</tabstop>
   <tabstop>m_NumGradientsBox</tabstop>
   <tabstop>m_BvalueBox</tabstop>
   <tabstop>m_AdvancedOptionsBox_2</tabstop>
   <tabstop>m_SignalScaleBox</tabstop>
   <tabstop>m_TEbox</tabstop>
   <tabstop>m_TRbox</tabstop>
   <tabstop>m_LineReadoutTimeBox</tabstop>
   <tabstop>m_PartialFourier</tabstop>
   <tabstop>m_T2starBox</tabstop>
   <tabstop>m_FiberRadius</tabstop>
   <tabstop>m_ReversePhaseBox</tabstop>
   <tabstop>m_RelaxationBox</tabstop>
   <tabstop>m_EnforcePureFiberVoxelsBox</tabstop>
   <tabstop>m_VolumeFractionsBox</tabstop>
   <tabstop>m_Compartment1Box</tabstop>
   <tabstop>m_Comp1VolumeFraction</tabstop>
   <tabstop>m_Compartment2Box</tabstop>
   <tabstop>m_Comp2VolumeFraction</tabstop>
   <tabstop>m_Compartment3Box</tabstop>
   <tabstop>m_Comp3VolumeFraction</tabstop>
   <tabstop>m_Compartment4Box</tabstop>
   <tabstop>m_Comp4VolumeFraction</tabstop>
   <tabstop>m_AddNoise</tabstop>
   <tabstop>m_NoiseDistributionBox</tabstop>
   <tabstop>m_NoiseLevel</tabstop>
   <tabstop>m_AddSpikes</tabstop>
   <tabstop>m_SpikeNumBox</tabstop>
   <tabstop>m_SpikeScaleBox</tabstop>
   <tabstop>m_AddGhosts</tabstop>
   <tabstop>m_kOffsetBox</tabstop>
   <tabstop>m_AddAliasing</tabstop>
   <tabstop>m_WrapBox</tabstop>
   <tabstop>m_AddDistortions</tabstop>
   <tabstop>m_FrequencyMapBox</tabstop>
   <tabstop>m_AddMotion</tabstop>
   <tabstop>m_RandomMotion</tabstop>
   <tabstop>m_MaxRotationBoxX</tabstop>
   <tabstop>m_MaxRotationBoxY</tabstop>
   <tabstop>m_MaxRotationBoxZ</tabstop>
   <tabstop>m_MaxTranslationBoxX</tabstop>
   <tabstop>m_MaxTranslationBoxY</tabstop>
   <tabstop>m_MaxTranslationBoxZ</tabstop>
   <tabstop>m_AddEddy</tabstop>
   <tabstop>m_EddyGradientStrength</tabstop>
   <tabstop>m_AddGibbsRinging</tabstop>
   <tabstop>m_SaveParametersButton</tabstop>
   <tabstop>m_LoadParametersButton</tabstop>
   <tabstop>tabWidget</tabstop>
  </tabstops>
  <resources>
   <include location="../../resources/QmitkDiffusionImaging.qrc"/>
  </resources>
  <connections/>
 </ui>