diff --git a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
index ee1c3d3df1..4ebef7a526 100644
--- a/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Fiberfox/itkKspaceImageFilter.cpp
@@ -1,497 +1,498 @@
 /*===================================================================
 
 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 __itkKspaceImageFilter_txx
 #define __itkKspaceImageFilter_txx
 //#endif
 
 #include <ctime>
 #include <cstdio>
 #include <cstdlib>
 #include <math.h>
 
 #include "itkKspaceImageFilter.h"
 #include <itkImageRegionConstIterator.h>
 #include <itkImageRegionConstIteratorWithIndex.h>
 #include <itkImageRegionIterator.h>
 #include <mitkSingleShotEpi.h>
 #include <mitkConventionalSpinEcho.h>
 #include <mitkFastSpinEcho.h>
 #include <mitkDiffusionFunctionCollection.h>
 #include <itkImageFileWriter.h>
 
 namespace itk {
 
   template< class ScalarType >
   KspaceImageFilter< ScalarType >::KspaceImageFilter()
     : m_Z(0)
     , m_RandSeed(-1)
     , m_SpikesPerSlice(0)
     , m_IsBaseline(true)
   {
     m_DiffusionGradientDirection.Fill(0.0);
     m_CoilPosition.Fill(0.0);
   }
 
   template< class ScalarType >
   void KspaceImageFilter< ScalarType >
   ::BeforeThreadedGenerateData()
   {
     m_Spike = vcl_complex<ScalarType>(0,0);
     m_SpikeLog = "";
     m_TransX = -m_Translation[0];
     m_TransY = -m_Translation[1];
     m_TransZ = -m_Translation[2];
 
     kxMax = m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(0);
     kyMax = m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(1);
     xMax = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(0); // scanner coverage in x-direction
     yMax = m_CompartmentImages.at(0)->GetLargestPossibleRegion().GetSize(1); // scanner coverage in y-direction
     yMaxFov = yMax;
     if (m_Parameters->m_Misc.m_DoAddAliasing)
     {
       // actual FOV in y-direction (in x-direction FOV=xMax)
       yMaxFov = static_cast<int>(yMaxFov * m_Parameters->m_SignalGen.m_CroppingFactor);
     }
     yMaxFov_half = (yMaxFov-1)/2;
     numPix = kxMax*kyMax;
 
     float ringing_factor = static_cast<float>(m_Parameters->m_SignalGen.m_ZeroRinging)/100.0;
     ringing_lines_x = static_cast<int>(ceil(kxMax/2 * ringing_factor));
     ringing_lines_y = static_cast<int>(ceil(kyMax/2 * ringing_factor));
 
     // Adjust noise variance since it is the intended variance in physical space and not in k-space:
     float noiseVar = m_Parameters->m_SignalGen.m_PartialFourier*m_Parameters->m_SignalGen.m_NoiseVariance/(kyMax*kxMax);
 
     m_RandGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
     if (m_RandSeed>=0)  // always generate the same random numbers?
       m_RandGen->SetSeed(m_RandSeed);
     else
       m_RandGen->SetSeed();
 
     typename OutputImageType::Pointer outputImage = OutputImageType::New();
     itk::ImageRegion<2> region;
     region.SetSize(0, m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(0));
     region.SetSize(1, m_Parameters->m_SignalGen.m_CroppedRegion.GetSize(1));
     outputImage->SetLargestPossibleRegion( region );
     outputImage->SetBufferedRegion( region );
     outputImage->SetRequestedRegion( region );
     outputImage->Allocate();
     vcl_complex<ScalarType> zero = vcl_complex<ScalarType>(0, 0);
     outputImage->FillBuffer(zero);
     if (m_Parameters->m_SignalGen.m_NoiseVariance>0 && m_Parameters->m_Misc.m_DoAddNoise)
     {
       ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
       while( !oit.IsAtEnd() )
       {
         oit.Set(vcl_complex<ScalarType>(m_RandGen->GetNormalVariate(0, noiseVar), m_RandGen->GetNormalVariate(0, noiseVar)));
         ++oit;
       }
     }
 
     m_KSpaceImage = InputImageType::New();
     m_KSpaceImage->SetLargestPossibleRegion( region );
     m_KSpaceImage->SetBufferedRegion( region );
     m_KSpaceImage->SetRequestedRegion( region );
     m_KSpaceImage->Allocate();
     m_KSpaceImage->FillBuffer(0.0);
 
 //    m_TickImage = InputImageType::New();
 //    m_TickImage->SetLargestPossibleRegion( region );
 //    m_TickImage->SetBufferedRegion( region );
 //    m_TickImage->SetRequestedRegion( region );
 //    m_TickImage->Allocate();
 //    m_TickImage->FillBuffer(-1.0);
 
-    m_Gamma = 42576000*itk::Math::twopi;    // Gyromagnetic ratio in Hz/T (1.5T)
+    m_Gamma = 42576000*itk::Math::twopi;    // Gyromagnetic ratio in Hz/T
     if ( m_Parameters->m_SignalGen.m_EddyStrength>0 && m_DiffusionGradientDirection.GetNorm()>0.001)
     {
       m_DiffusionGradientDirection = m_DiffusionGradientDirection *  m_Parameters->m_SignalGen.m_EddyStrength/1000 *  m_Gamma;
       m_IsBaseline = false;
     }
     else {
       m_IsBaseline = true;
     }
 
     this->SetNthOutput(0, outputImage);
 
     for (int i=0; i<3; i++)
       for (int j=0; j<3; j++)
         m_Transform[i][j] = m_Parameters->m_SignalGen.m_ImageDirection[i][j] * m_Parameters->m_SignalGen.m_ImageSpacing[j]/1000;
 
     float a = m_Parameters->m_SignalGen.m_ImageRegion.GetSize(0)*m_Parameters->m_SignalGen.m_ImageSpacing[0];
     float b = m_Parameters->m_SignalGen.m_ImageRegion.GetSize(1)*m_Parameters->m_SignalGen.m_ImageSpacing[1];
     float diagonal = sqrt(a*a+b*b)/1000;   // image diagonal in m
 
     switch (m_Parameters->m_SignalGen.m_CoilSensitivityProfile)
     {
       case SignalGenerationParameters::COIL_CONSTANT:
       {
         m_CoilSensitivityFactor = 1;                    // same signal everywhere
         break;
       }
       case SignalGenerationParameters::COIL_LINEAR:
       {
         m_CoilSensitivityFactor = -1/diagonal;          // about 50% of the signal in the image center remaining
         break;
       }
       case SignalGenerationParameters::COIL_EXPONENTIAL:
       {
         m_CoilSensitivityFactor = -log(0.1)/diagonal;   // about 32% of the signal in the image center remaining
         break;
       }
     }
 
     switch (m_Parameters->m_SignalGen.m_AcquisitionType)
     {
       case SignalGenerationParameters::SingleShotEpi:
         m_ReadoutScheme = new mitk::SingleShotEpi(m_Parameters);
       break;
       case SignalGenerationParameters::ConventionalSpinEcho:
         m_ReadoutScheme = new mitk::ConventionalSpinEcho(m_Parameters);
       break;
       case SignalGenerationParameters::FastSpinEcho:
         m_ReadoutScheme = new mitk::FastSpinEcho(m_Parameters);
       break;
       default:
         m_ReadoutScheme = new mitk::SingleShotEpi(m_Parameters);
     }
 
     m_ReadoutScheme->AdjustEchoTime();
 
     m_MovedFmap = nullptr;
     if (m_Parameters->m_Misc.m_DoAddDistortions && m_Parameters->m_SignalGen.m_FrequencyMap.IsNotNull() && m_Parameters->m_SignalGen.m_DoAddMotion)
     {
       // we have to account for the head motion since this also moves our frequency map
       itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::Pointer   fmapInterpolator;
       fmapInterpolator = itk::LinearInterpolateImageFunction< itk::Image< float, 3 >, float >::New();
       fmapInterpolator->SetInputImage(m_Parameters->m_SignalGen.m_FrequencyMap);
 
       m_MovedFmap = itk::Image< ScalarType, 2 >::New();
       m_MovedFmap->SetLargestPossibleRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
       m_MovedFmap->SetBufferedRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
       m_MovedFmap->SetRequestedRegion( m_CompartmentImages.at(0)->GetLargestPossibleRegion() );
       m_MovedFmap->Allocate();
       m_MovedFmap->FillBuffer(0);
 
       ImageRegionIterator< InputImageType > it(m_MovedFmap, m_MovedFmap->GetLargestPossibleRegion() );
       while( !it.IsAtEnd() )
       {
         itk::Image<float, 3>::IndexType index;
         index[0] = it.GetIndex()[0];
         index[1] = it.GetIndex()[1];
         index[2] = m_Zidx;
 
         itk::Point<float, 3> point3D;
         m_Parameters->m_SignalGen.m_FrequencyMap->TransformIndexToPhysicalPoint(index, point3D);
         m_FiberBundle->TransformPoint<float>( point3D, m_RotationMatrix, m_TransX, m_TransY, m_TransZ );
         it.Set(mitk::imv::GetImageValue<float>(point3D, true, fmapInterpolator));
         ++it;
       }
     }
 
     // calculate T1 relaxation (independent of actual readout)
     m_T1Relax.clear();
     if ( m_Parameters->m_SignalGen.m_DoSimulateRelaxation)
       for (unsigned int i=0; i<m_CompartmentImages.size(); i++)
       {
         // account for T1 relaxation (how much magnetization is available since last excitation?)
         float relaxation = (1.0-std::exp(-m_Parameters->m_SignalGen.m_tRep/m_T1[i]));
 
         // account for inversion pulse and TI
         if (m_Parameters->m_SignalGen.m_tInv > 0)
           relaxation *= (1.0-std::exp(std::log(2) - m_Parameters->m_SignalGen.m_tInv/m_T1[i]));
 
         m_T1Relax.push_back(relaxation);
       }
   }
 
   template< class ScalarType >
   float KspaceImageFilter< ScalarType >::CoilSensitivity(VectorType& pos)
   {
     // *************************************************************************
     // Coil ring is moving with excited slice (FIX THIS SOMETIME)
     m_CoilPosition[2] = pos[2];
     // *************************************************************************
 
     switch (m_Parameters->m_SignalGen.m_CoilSensitivityProfile)
     {
       case SignalGenerationParameters::COIL_CONSTANT:
       return 1;
       case SignalGenerationParameters::COIL_LINEAR:
       {
         VectorType diff = pos-m_CoilPosition;
         float sens = diff.GetNorm()*m_CoilSensitivityFactor + 1;
         if (sens<0)
           sens = 0;
         return sens;
       }
       case SignalGenerationParameters::COIL_EXPONENTIAL:
       {
         VectorType diff = pos-m_CoilPosition;
         float dist = static_cast<float>(diff.GetNorm());
         return std::exp(-dist*m_CoilSensitivityFactor);
       }
       default:
       return 1;
     }
   }
 
   template< class ScalarType >
   void KspaceImageFilter< ScalarType >
   ::ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread, ThreadIdType )
   {
     typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
     ImageRegionIterator< OutputImageType > oit(outputImage, outputRegionForThread);
     typedef ImageRegionConstIterator< InputImageType > InputIteratorType;
 
     // precalculate shifts for DFT
     float x_shift = 0;
     float y_shift = 0;
     if (static_cast<int>(xMax)%2==1)
         x_shift = (xMax-1)/2;
     else
         x_shift = xMax/2;
     if (static_cast<int>(yMax)%2==1)
         y_shift = (yMax-1)/2;
     else
         y_shift = yMax/2;
 
     float kx_shift = 0;
     float ky_shift = 0;
     if (static_cast<int>(kxMax)%2==1)
         kx_shift = (kxMax-1)/2;
     else
         kx_shift = kxMax/2;
     if (static_cast<int>(kyMax)%2==1)
         ky_shift = (kyMax-1)/2;
     else
         ky_shift = kyMax/2;
 
     vcl_complex<ScalarType> zero = vcl_complex<ScalarType>(0, 0);
     while( !oit.IsAtEnd() )
     {
       int tick = oit.GetIndex()[1] * kxMax + oit.GetIndex()[0];
 
       // get current k-space index (depends on the chosen k-space readout scheme)
       itk::Index< 2 > kIdx = m_ReadoutScheme->GetActualKspaceIndex(tick);
 
       // we have to adjust the ticks to obtain correct times since the DFT is not completely symmetric in the even  number of lines case
       if (static_cast<int>(kyMax)%2 == 0 && !m_Parameters->m_SignalGen.m_ReversePhase)
       {
         tick += kxMax;
         tick %= static_cast<int>(numPix);
       }
 
       // partial fourier
       // two cases because we always want to skip the "later" parts of k-space
       // in "normal" phase direction, the higher k-space indices are acquired first
       // in reversed phase direction, the higher k-space indices are acquired later
       // if the image has an even number of lines, never skip line zero since it is missing on the other side (DFT not completely syymetric in even case)
       if ((m_Parameters->m_SignalGen.m_ReversePhase && kIdx[1]>std::ceil(kyMax*m_Parameters->m_SignalGen.m_PartialFourier)) ||
           (!m_Parameters->m_SignalGen.m_ReversePhase && kIdx[1]<std::floor(kyMax*(1.0 - m_Parameters->m_SignalGen.m_PartialFourier)) &&
            (kIdx[1]>0 || static_cast<int>(kyMax)%2 == 1)))
       {
         outputImage->SetPixel(kIdx, zero);
         ++oit;
         continue;
       }
 //      m_TickImage->SetPixel(kIdx, tick);
 
       // gibbs ringing by setting high frequencies to zero (alternative to using smaller k-space than input image space)
       if (m_Parameters->m_SignalGen.m_DoAddGibbsRinging && m_Parameters->m_SignalGen.m_ZeroRinging>0)
       {
         if (kIdx[0] < ringing_lines_x || kIdx[1] < ringing_lines_y ||
             kIdx[0] >= kxMax - ringing_lines_x || kIdx[1] >= kyMax - ringing_lines_y)
         {
           outputImage->SetPixel(kIdx, zero);
           ++oit;
           continue;
         }
       }
 
-      // time passes since application of the RF pulse
-      float tRf = m_ReadoutScheme->GetTimeFromRf(tick);
+      // time from maximum echo
+      float t = m_ReadoutScheme->GetTimeFromMaxEcho(tick);
 
       // calculate eddy current decay factor
       float eddyDecay = 0;
       if ( m_Parameters->m_Misc.m_DoAddEddyCurrents && m_Parameters->m_SignalGen.m_EddyStrength>0 && !m_IsBaseline)
       {
         // time passed since k-space readout started
         float tRead = m_ReadoutScheme->GetTimeFromLastDiffusionGradient(tick);
-        eddyDecay = std::exp(-tRead/m_Parameters->m_SignalGen.m_Tau ) * tRead/1000; // time in seconds here
+        eddyDecay = std::exp(-tRead/m_Parameters->m_SignalGen.m_Tau ) * t/1000; // time in seconds here
       }
 
       // calcualte signal relaxation factors
       std::vector< float > relaxFactor;
       if ( m_Parameters->m_SignalGen.m_DoSimulateRelaxation)
       {
-        // time from maximum echo
-        float t = m_ReadoutScheme->GetTimeFromMaxEcho(tick);
+        // time passes since application of the RF pulse
+        float tRf = m_ReadoutScheme->GetTimeFromRf(tick);
+
         for (unsigned int i=0; i<m_CompartmentImages.size(); i++)
         {
           // account for T2 relaxation (how much transverse magnetization is left since applicatiohn of RF pulse?)
           relaxFactor.push_back(m_T1Relax[i] * std::exp(-tRf/m_T2[i] -fabs(t)/ m_Parameters->m_SignalGen.m_tInhom));
         }
       }
 
       // shift k for DFT: (0 -- N) --> (-N/2 -- N/2)
       float kx = kIdx[0] - kx_shift;
       float ky = kIdx[1] - ky_shift;
 
       // add ghosting by adding gradient delay induced offset
       if (m_Parameters->m_Misc.m_DoAddGhosts)
       {
         if (kIdx[1]%2 == 1)
           kx -= m_Parameters->m_SignalGen.m_KspaceLineOffset;
         else
           kx += m_Parameters->m_SignalGen.m_KspaceLineOffset;
       }
 
       // pull stuff out of inner loop
-      tRf /= 1000; // time in seconds
+      t /= 1000; // time in seconds
       kx /= xMax;
       ky /= yMaxFov;
 
       // calculate signal s at k-space position (kx, ky)
       vcl_complex<ScalarType> s(0,0);
       InputIteratorType it(m_CompartmentImages[0], m_CompartmentImages[0]->GetLargestPossibleRegion() );
       while( !it.IsAtEnd() )
       {
         typename InputImageType::IndexType input_idx = it.GetIndex();
 
         // shift x,y for DFT: (0 -- N) --> (-N/2 -- N/2)
         float x = input_idx[0] - x_shift;
         float y = input_idx[1] - y_shift;
 
         // sum compartment signals and simulate relaxation
         ScalarType f_real = 0;
         for (unsigned int i=0; i<m_CompartmentImages.size(); i++)
           if ( m_Parameters->m_SignalGen.m_DoSimulateRelaxation)
             f_real += m_CompartmentImages[i]->GetPixel(input_idx) * relaxFactor[i];
           else
             f_real += m_CompartmentImages[i]->GetPixel(input_idx);
 
         // vector from image center to current position (in meter)
         // only necessary for eddy currents and non-constant coil sensitivity
         VectorType pos;
         if ((m_Parameters->m_Misc.m_DoAddEddyCurrents && m_Parameters->m_SignalGen.m_EddyStrength>0 && !m_IsBaseline) ||
             m_Parameters->m_SignalGen.m_CoilSensitivityProfile!=SignalGenerationParameters::COIL_CONSTANT)
         {
           pos[0] = x; pos[1] = y; pos[2] = m_Z;
           pos = m_Transform*pos;
         }
 
         if (m_Parameters->m_SignalGen.m_CoilSensitivityProfile!=SignalGenerationParameters::COIL_CONSTANT)
           f_real *= CoilSensitivity(pos);
 
         // simulate eddy currents and other distortions
-        float omega = 0;   // frequency offset
+        float phi = 0;   // phase shift
         if (  m_Parameters->m_Misc.m_DoAddEddyCurrents && m_Parameters->m_SignalGen.m_EddyStrength>0 && !m_IsBaseline)
         {
           // duration (tRead) already included in "eddyDecay"
-          omega += (m_DiffusionGradientDirection[0]*pos[0]+m_DiffusionGradientDirection[1]*pos[1]+m_DiffusionGradientDirection[2]*pos[2]) * eddyDecay;
+          phi += (m_DiffusionGradientDirection[0]*pos[0]+m_DiffusionGradientDirection[1]*pos[1]+m_DiffusionGradientDirection[2]*pos[2]) * eddyDecay;
         }
 
         // simulate distortions
         if (m_Parameters->m_Misc.m_DoAddDistortions)
         {
           if (m_MovedFmap.IsNotNull())    // if we have headmotion, use moved map
-            omega += m_MovedFmap->GetPixel(input_idx) * tRf;
+            phi += m_MovedFmap->GetPixel(input_idx) * t;
           else if (m_Parameters->m_SignalGen.m_FrequencyMap.IsNotNull())
           {
             itk::Image<float, 3>::IndexType index; index[0] = input_idx[0]; index[1] = input_idx[1]; index[2] = m_Zidx;
-            omega += m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(index) * tRf;
+            phi += m_Parameters->m_SignalGen.m_FrequencyMap->GetPixel(index) * t;
           }
         }
 
         // if signal comes from outside FOV, mirror it back (wrap-around artifact - aliasing
         if (m_Parameters->m_Misc.m_DoAddAliasing)
         {
           if (y<-yMaxFov_half)
             y += yMaxFov;
           else if (y>yMaxFov_half)
             y -= yMaxFov;
         }
 
         // actual DFT term
         vcl_complex<ScalarType> f(f_real * m_Parameters->m_SignalGen.m_SignalScale, 0);
-        s += f * std::exp( std::complex<ScalarType>(0, itk::Math::twopi * (kx*x + ky*y + omega )) );
+        s += f * std::exp( std::complex<ScalarType>(0, itk::Math::twopi * (kx*x + ky*y + phi )) );
 
         ++it;
       }
       s /= numPix;
 
       if (m_SpikesPerSlice>0 && sqrt(s.imag()*s.imag()+s.real()*s.real()) > sqrt(m_Spike.imag()*m_Spike.imag()+m_Spike.real()*m_Spike.real()) )
         m_Spike = s;
 
       s += outputImage->GetPixel(kIdx); // add precalculated noise
       outputImage->SetPixel(kIdx, s);
       m_KSpaceImage->SetPixel(kIdx, sqrt(s.imag()*s.imag()+s.real()*s.real()) );
 
       ++oit;
     }
   }
 
   template< class ScalarType >
   void KspaceImageFilter< ScalarType >
   ::AfterThreadedGenerateData()
   {
     typename OutputImageType::Pointer outputImage = static_cast< OutputImageType * >(this->ProcessObject::GetOutput(0));
     int kxMax = outputImage->GetLargestPossibleRegion().GetSize(0);  // k-space size in x-direction
     int kyMax = outputImage->GetLargestPossibleRegion().GetSize(1);  // k-space size in y-direction
 
     ImageRegionIterator< OutputImageType > oit(outputImage, outputImage->GetLargestPossibleRegion());
     while( !oit.IsAtEnd() ) // use hermitian k-space symmetry to fill empty k-space parts resulting from partial fourier acquisition
     {
       int tick = oit.GetIndex()[1] * kxMax + oit.GetIndex()[0];
       auto kIdx = m_ReadoutScheme->GetActualKspaceIndex(tick);
 
       if ((m_Parameters->m_SignalGen.m_ReversePhase && kIdx[1]>std::ceil(kyMax*m_Parameters->m_SignalGen.m_PartialFourier)) ||
           (!m_Parameters->m_SignalGen.m_ReversePhase && kIdx[1]<std::floor(kyMax*(1.0 - m_Parameters->m_SignalGen.m_PartialFourier)) &&
           (kIdx[1]>0 || static_cast<int>(kyMax)%2 == 1)))
       {
         // calculate symmetric index
         auto sym = m_ReadoutScheme->GetSymmetricIndex(kIdx);
 
         // use complex conjugate of symmetric index value at current index
         vcl_complex<ScalarType> s = outputImage->GetPixel(sym);
         s = vcl_complex<ScalarType>(s.real(), -s.imag());
         outputImage->SetPixel(kIdx, s);
 
         m_KSpaceImage->SetPixel(kIdx, sqrt(s.imag()*s.imag()+s.real()*s.real()) );
       }
       ++oit;
     }
 
     m_Spike *=  m_Parameters->m_SignalGen.m_SpikeAmplitude;
     itk::Index< 2 > spikeIdx;
     for (unsigned int i=0; i<m_SpikesPerSlice; i++)
     {
       spikeIdx[0] = m_RandGen->GetIntegerVariate()%kxMax;
       spikeIdx[1] = m_RandGen->GetIntegerVariate()%kyMax;
       outputImage->SetPixel(spikeIdx, m_Spike);
       m_SpikeLog += "[" + boost::lexical_cast<std::string>(spikeIdx[0]) + "," + boost::lexical_cast<std::string>(spikeIdx[1]) + "," + boost::lexical_cast<std::string>(m_Zidx) + "] Magnitude: " + boost::lexical_cast<std::string>(m_Spike.real()) + "+" + boost::lexical_cast<std::string>(m_Spike.imag()) + "i\n";
     }
     delete m_ReadoutScheme;
 
 //    typename itk::ImageFileWriter< InputImageType >::Pointer wr = itk::ImageFileWriter< InputImageType >::New();
 //    wr->SetInput(m_TickImage);
 //    wr->SetFileName("/home/neher/TimeFromRfImage.nii.gz");
 //    wr->Update();
   }
 }
 #endif
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
index 881b1f3cf8..9345aff4f1 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
@@ -1,336 +1,339 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef _MITK_FiberfoxParameters_H
 #define _MITK_FiberfoxParameters_H
 
 #include <itkImageRegion.h>
 #include <itkMatrix.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkDataNode.h>
 #include <mitkRicianNoiseModel.h>
 #include <mitkChiSquareNoiseModel.h>
 #include <mitkImage.h>
 #include <mitkDiffusionPropertyHelper.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkRawShModel.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
+#include <boost/property_tree/json_parser.hpp>
 #include <limits>
 #include <MitkFiberTrackingExports.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 
 namespace mitk
 {
   class MITKFIBERTRACKING_EXPORT FiberfoxParameters;
 
   /** Signal generation */
   class MITKFIBERTRACKING_EXPORT SignalGenerationParameters
   {
     friend FiberfoxParameters;
   public:
     typedef itk::Image<float, 3>                    ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>            ItkUcharImgType;
     typedef itk::Vector<double,3>                   GradientType;
     typedef std::vector<GradientType>               GradientListType;
 
     enum CoilSensitivityProfile : int {
       COIL_CONSTANT,
       COIL_LINEAR,
       COIL_EXPONENTIAL
     };
 
     enum AcquisitionType : int
     {
       SingleShotEpi,
       ConventionalSpinEcho,
       FastSpinEcho,
     };
 
     SignalGenerationParameters()
       : m_AcquisitionType(SignalGenerationParameters::SingleShotEpi)
       , m_SignalScale(100)
       , m_tEcho(100)
       , m_tRep(4000)
       , m_tInv(0)
       , m_tLine(1)
       , m_tInhom(50)
       , m_EchoTrainLength(8)
       , m_ReversePhase(false)
       , m_PartialFourier(1.0)
-      , m_NoiseVariance(0.001)
+      , m_NoiseVariance(0.001f)
       , m_NumberOfCoils(1)
       , m_CoilSensitivityProfile(SignalGenerationParameters::COIL_CONSTANT)
+      , m_CoilSensitivity(0.3f)
       , m_SimulateKspaceAcquisition(false)
       , m_AxonRadius(0)
       , m_DoDisablePartialVolume(false)
       , m_Spikes(0)
       , m_SpikeAmplitude(1)
       , m_KspaceLineOffset(0)
-      , m_EddyStrength(300)
+      , m_EddyStrength(0.002f)
       , m_Tau(70)
       , m_CroppingFactor(1)
       , m_Drift(0.06)
       , m_DoAddGibbsRinging(false)
       , m_ZeroRinging(0)
       , m_DoSimulateRelaxation(true)
       , m_DoAddMotion(false)
       , m_DoRandomizeMotion(true)
       , m_DoAddDrift(false)
       , m_FrequencyMap(nullptr)
       , m_MaskImage(nullptr)
       , m_Bvalue(1000)
     {
       m_ImageRegion.SetSize(0, 12);
       m_ImageRegion.SetSize(1, 12);
       m_ImageRegion.SetSize(2, 3);
       m_ImageSpacing.Fill(2.0);
       m_ImageOrigin.Fill(0.0);
       m_ImageDirection.SetIdentity();
       m_Translation.Fill(0.0);
       m_Rotation.Fill(0.0);
       SetNumWeightedVolumes(6);
     }
 
     /** input/output image specifications */
     itk::ImageRegion<3>                 m_CroppedRegion;            ///< Image size with reduced FOV.
     itk::ImageRegion<3>                 m_ImageRegion;              ///< Image size.
     itk::Vector<float,3>                m_ImageSpacing;             ///< Image voxel size.
     itk::Point<float,3>                 m_ImageOrigin;              ///< Image origin.
     itk::Matrix<double, 3, 3>           m_ImageDirection;           ///< Image rotation matrix.
 
     /** Other acquisitions parameters */
     AcquisitionType                     m_AcquisitionType;          ///< determines k-space trajectory and maximum echo position(s)
     float                               m_SignalScale;              ///< Scaling factor for output signal (before noise is added).
     float                               m_tEcho;                    ///< Echo time TE.
     float                               m_tRep;                     ///< Echo time TR.
     float                               m_tInv;                       ///< Inversion time
     float                               m_tLine;                    ///< k-space line readout time (dwell time).
     float                               m_tInhom;                   ///< T2'
     unsigned int                        m_EchoTrainLength;          ///< Only relevant for Fast Spin Echo sequence (number of k-space lines acquired with one RF pulse)
     bool                                m_ReversePhase;             ///< If true, the phase readout direction will be inverted (-y instead of y)
     float                               m_PartialFourier;           ///< Partial fourier factor (0.5-1)
     float                               m_NoiseVariance;            ///< Variance of complex gaussian noise
     unsigned int                        m_NumberOfCoils;            ///< Number of coils in multi-coil acquisition
     CoilSensitivityProfile              m_CoilSensitivityProfile;   ///< Choose between constant, linear or exponential sensitivity profile of the used coils
+    float                               m_CoilSensitivity;          ///< signal remaining in slice center
     bool                                m_SimulateKspaceAcquisition;///< Flag to enable/disable k-space acquisition simulation
     double                              m_AxonRadius;               ///< Determines compartment volume fractions (0 == automatic axon radius estimation)
     bool                                m_DoDisablePartialVolume;   ///< Disable partial volume effects. Each voxel is either all fiber or all non-fiber.
 
     /** Artifacts and other effects */
     unsigned int                        m_Spikes;                   ///< Number of spikes randomly appearing in the image
     float                               m_SpikeAmplitude;           ///< amplitude of spikes relative to the largest signal intensity (magnitude of complex)
     float                               m_KspaceLineOffset;         ///< Causes N/2 ghosts. Larger offset means stronger ghost.
     float                               m_EddyStrength;             ///< Strength of eddy current induced gradients in mT/m.
     float                               m_Tau;                      ///< Eddy current decay constant (in ms)
     float                               m_CroppingFactor;           ///< FOV size in y-direction is multiplied by this factor. Causes aliasing artifacts.
     float                               m_Drift;                    ///< Global signal decrease by the end of the acquisition.
     bool                                m_DoAddGibbsRinging;        ///< Add Gibbs ringing artifact
     int                                 m_ZeroRinging;              ///< If > 0, ringing is simulated by by setting the defined percentage of higher frequencies to 0 in k-space. Otherwise, the input to the k-space simulation is generated with twice the resolution and cropped during k-space simulation (much slower).
     bool                                m_DoSimulateRelaxation;     ///< Add T2 relaxation effects
     bool                                m_DoAddMotion;              ///< Enable motion artifacts.
     bool                                m_DoRandomizeMotion;        ///< Toggles between random and linear motion.
     bool                                m_DoAddDrift;               ///< Add quadratic signal drift.
     std::vector< bool >                 m_MotionVolumes;            ///< Indicates the image volumes that are affected by motion
     ///< with positive numbers, inverted logic with negative numbers.
     itk::Vector<float,3>                m_Translation;              ///< Maximum translational motion.
     itk::Vector<float,3>                m_Rotation;                 ///< Maximum rotational motion.
     ItkFloatImgType::Pointer            m_FrequencyMap;             ///< If != nullptr, distortions are added to the image using this frequency map.
     ItkUcharImgType::Pointer            m_MaskImage;                ///< Signal is only genrated inside of the mask image.
 
     std::vector< int > GetBaselineIndices();                 ///< Returns list of nun-diffusion-weighted image volume indices
     unsigned int GetFirstBaselineIndex();                    ///< Returns index of first non-diffusion-weighted image volume
     bool IsBaselineIndex(unsigned int idx);                  ///< Checks if image volume with given index is non-diffusion-weighted volume or not.
     unsigned int GetNumWeightedVolumes();                    ///< Get number of diffusion-weighted image volumes
     unsigned int GetNumBaselineVolumes();                    ///< Get number of non-diffusion-weighted image volumes
     unsigned int GetNumVolumes();                            ///< Get number of baseline and diffusion-weighted image volumes
     GradientListType GetGradientDirections();                ///< Return gradient direction container
     mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer GetItkGradientContainer();
     GradientType GetGradientDirection(unsigned int i);
     std::vector< int > GetBvalues();                         ///< Returns a vector with all unique b-values (determined by the gradient magnitudes)
     double GetBvalue();
     void ApplyDirectionMatrix();
 
   protected:
 
     unsigned int                        m_NumGradients;             ///< Number of diffusion-weighted image volumes.
     unsigned int                        m_NumBaseline;              ///< Number of non-diffusion-weighted image volumes.
     GradientListType                    m_GradientDirections;       ///< Total number of image volumes.
     double                              m_Bvalue;                   ///< Acquisition b-value
 
     void SetNumWeightedVolumes(int numGradients);            ///< Automaticall calls GenerateGradientHalfShell() afterwards.
     void SetGradienDirections(GradientListType gradientList);
     void SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList);
     void GenerateGradientHalfShell();                        ///< Generates half shell of gradient directions (with m_NumGradients non-zero directions)
   };
 
   /** Fiber generation */
   class MITKFIBERTRACKING_EXPORT FiberGenerationParameters
   {
   public:
 
     enum FiberDistribution
     {
       DISTRIBUTE_UNIFORM, // distribute fibers uniformly in the ROIs
       DISTRIBUTE_GAUSSIAN // distribute fibers using a 2D gaussian
     };
 
     typedef std::vector< std::vector< mitk::PlanarEllipse::Pointer > >    FiducialListType;
     typedef std::vector< std::vector< unsigned int > >                    FlipListType;
 
     FiberGenerationParameters()
       : m_Distribution(DISTRIBUTE_UNIFORM)
       , m_Density(100)
       , m_Variance(100)
       , m_Sampling(1)
       , m_Tension(0)
       , m_Continuity(0)
       , m_Bias(0)
     {
       m_Rotation.Fill(0.0);
       m_Translation.Fill(0.0);
       m_Scale.Fill(1.0);
     }
 
     FiberDistribution   m_Distribution;
     unsigned int        m_Density;
     double              m_Variance;
     double              m_Sampling;
     double              m_Tension;
     double              m_Continuity;
     double              m_Bias;
     mitk::Vector3D      m_Rotation;
     mitk::Vector3D      m_Translation;
     mitk::Vector3D      m_Scale;
     FlipListType        m_FlipList;        ///< contains flags indicating a flip of the 2D fiber x-coordinates (needed to resolve some unwanted fiber twisting)
     FiducialListType    m_Fiducials;       ///< container of the planar ellipses used as fiducials for the fiber generation process
   };
 
   /** GUI persistence, input, output, ... */
   class MITKFIBERTRACKING_EXPORT MiscFiberfoxParameters
   {
   public:
     MiscFiberfoxParameters()
       : m_ResultNode(DataNode::New())
       , m_ParentNode(nullptr)
       , m_SignalModelString("")
       , m_ArtifactModelString("")
       , m_OutputPath("/tmp/")
       , m_OutputPrefix("fiberfox")
       , m_AfterSimulationMessage("")
       , m_BvalsFile("")
       , m_BvecsFile("")
       , m_CheckOutputVolumeFractionsBox(false)
       , m_CheckAdvancedSignalOptionsBox(false)
       , m_DoAddNoise(false)
       , m_DoAddGhosts(false)
       , m_DoAddAliasing(false)
       , m_DoAddSpikes(false)
       , m_DoAddEddyCurrents(false)
       , m_DoAddDistortions(false)
       , m_MotionVolumesBox("random")
       , m_CheckRealTimeFibersBox(true)
       , m_CheckAdvancedFiberOptionsBox(false)
       , m_CheckConstantRadiusBox(false)
       , m_CheckIncludeFiducialsBox(true)
     {}
 
     DataNode::Pointer   m_ResultNode;                       ///< Stores resulting image.
     DataNode::Pointer   m_ParentNode;                       ///< Parent node of result node.
     std::string         m_SignalModelString;                ///< Appendet to the name of the result node
     std::string         m_ArtifactModelString;              ///< Appendet to the name of the result node
     std::string         m_OutputPath;                       ///< Image is automatically saved to the specified folder after simulation is finished.
     std::string         m_OutputPrefix;  /** Prefix for filename of output files and logfile. */
     std::string         m_AfterSimulationMessage;           ///< Store messages that are displayed after the simulation has finished (e.g. warnings, automatic parameter adjustments etc.)
     std::string         m_BvalsFile;
     std::string         m_BvecsFile;
 
     /** member variables that store the check-state of GUI checkboxes */
     // image generation
     bool                m_CheckOutputVolumeFractionsBox;
     bool                m_CheckAdvancedSignalOptionsBox;
     bool                m_DoAddNoise;
     bool                m_DoAddGhosts;
     bool                m_DoAddAliasing;
     bool                m_DoAddSpikes;
     bool                m_DoAddEddyCurrents;
     bool                m_DoAddDistortions;
     std::string         m_MotionVolumesBox;
     // fiber generation
     bool                m_CheckRealTimeFibersBox;
     bool                m_CheckAdvancedFiberOptionsBox;
     bool                m_CheckConstantRadiusBox;
     bool                m_CheckIncludeFiducialsBox;
   };
 
   /**
   * \brief Datastructure to manage the Fiberfox signal generation parameters.
   *
   */
   class MITKFIBERTRACKING_EXPORT FiberfoxParameters
   {
 
   public:
 
 
     typedef itk::Image<float, 3>                            ItkFloatImgType;
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
     typedef DiffusionSignalModel<double>                    DiffusionModelType;
     typedef std::vector< DiffusionModelType* >              DiffusionModelListType;
     typedef DiffusionNoiseModel<double>                     NoiseModelType;
 
     FiberfoxParameters();
     FiberfoxParameters(const FiberfoxParameters &params);
     ~FiberfoxParameters();
 
     /** Not templated parameters */
     FiberGenerationParameters           m_FiberGen;             ///< Fiber generation parameters
     SignalGenerationParameters          m_SignalGen;            ///< Signal generation parameters
     MiscFiberfoxParameters              m_Misc;                 ///< GUI realted and I/O parameters
 
     /** Templated parameters */
     DiffusionModelListType              m_FiberModelList;       ///< Intra- and inter-axonal compartments.
     DiffusionModelListType              m_NonFiberModelList;    ///< Extra-axonal compartments.
     std::shared_ptr< NoiseModelType >   m_NoiseModel;           ///< If != nullptr, noise is added to the image.
 
     void GenerateGradientHalfShell();
     void SetNumWeightedVolumes(int numGradients);            ///< Automaticall calls GenerateGradientHalfShell() afterwards.
     void SetGradienDirections(mitk::SignalGenerationParameters::GradientListType gradientList);
     void SetGradienDirections(mitk::DiffusionPropertyHelper::GradientDirectionsContainerType::Pointer gradientList);
     void SetBvalue(double Bvalue);
     void UpdateSignalModels();
     void ClearFiberParameters();
     void ClearSignalParameters();
     void ApplyDirectionMatrix();
 
     void PrintSelf();                           ///< Print parameters to stdout.
     void SaveParameters(std::string filename);  ///< Save image generation parameters to .ffp file.
     void LoadParameters(std::string filename, bool fix_seed=false);  ///< Load image generation parameters from .ffp file.
     template< class ParameterType >
     ParameterType ReadVal(boost::property_tree::ptree::value_type const& v, std::string tag, ParameterType defaultValue, bool essential=false);
     std::string                         m_MissingTags;
   };
 }
 
 #endif