diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
index d209a3b5df..a097c33135 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,1300 +1,1301 @@
 /*===================================================================
 
 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 <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>
 
 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 >::DoKspaceStuff( std::vector< DoubleDwiType::Pointer >& images )
 {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
     Vector< double, 2 > sliceSpacing;
     sliceSpacing[0] = m_UpsampledSpacing[0];
     sliceSpacing[1] = m_UpsampledSpacing[1];
 
     // frequency map slice
     SliceType::Pointer fMapSlice = NULL;
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
     {
         fMapSlice = SliceType::New();
         ImageRegion<2> region;
         region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
         region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
         fMapSlice->SetLargestPossibleRegion( region );
         fMapSlice->SetBufferedRegion( region );
         fMapSlice->SetRequestedRegion( region );
         fMapSlice->Allocate();
         fMapSlice->FillBuffer(0.0);
     }
 
     DoubleDwiType::Pointer newImage = DoubleDwiType::New();
     newImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     newImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     newImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     newImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetVectorLength( images.at(0)->GetVectorLength() );
     newImage->Allocate();
 
     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());
 
     m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
     m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
     unsigned long lastTick = 0;
 
     boost::progress_display disp(2*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;
 
             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);
 
                 SliceType::Pointer 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]);
 
                         if (fMapSlice.IsNotNull() && i==0)
                             fMapSlice->SetPixel(index2D, m_Parameters.m_SignalGen.m_FrequencyMap->GetPixel(index3D));
                     }
 
                 compartmentSlices.push_back(slice);
                 t2Vector.push_back(signalModel->GetT2());
             }
 
             if (this->GetAbortGenerateData())
                 return NULL;
 
             // create k-sapce (inverse fourier transform slices)
             itk::Size<2> outSize; outSize.SetElement(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0)); outSize.SetElement(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1));
             itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
             idft->SetCompartmentImages(compartmentSlices);
             idft->SetT2(t2Vector);
             idft->SetUseConstantRandSeed(m_UseConstantRandSeed);
             idft->SetParameters(m_Parameters);
             idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
             idft->SetDiffusionGradientDirection(m_Parameters.m_SignalGen.GetGradientDirection(g));
             idft->SetFrequencyMapSlice(fMapSlice);
             idft->SetOutSize(outSize);
             int numSpikes = 0;
             while (!spikeSlice.empty() && spikeSlice.back()==z)
             {
                 numSpikes++;
                 spikeSlice.pop_back();
             }
             idft->SetSpikesPerSlice(numSpikes);
             idft->Update();
 
             ComplexSliceType::Pointer fSlice;
             fSlice = idft->GetOutput();
 
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned  long tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
 
             // fourier transform slice
             SliceType::Pointer newSlice;
             itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
             dft->SetInput(fSlice);
             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;
                     SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
                     DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
                     pix3D[g] = newSlice->GetPixel(index2D);
                     newImage->SetPixel(index3D, pix3D);
                 }
             ++disp;
             newTick = 50*disp.count()/disp.expected_count();
             for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
         }
     }
     m_StatusText += "\n\n";
     return newImage;
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::GenerateData()
 {
     m_TimeProbe.Start();
     m_StatusText = "Starting simulation\n";
 
     // check input data
     if (m_FiberBundle.IsNull())
         itkExceptionMacro("Input fiber bundle is NULL!");
 
     if (m_Parameters.m_FiberModelList.empty())
         itkExceptionMacro("No diffusion model for fiber compartments defined!");
 
     if (m_Parameters.m_NonFiberModelList.empty())
         itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
 
     int baselineIndex = m_Parameters.m_SignalGen.GetFirstBaselineIndex();
     if (baselineIndex<0)
         itkExceptionMacro("No baseline index found!");
 
     if (!m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition)
         m_Parameters.m_SignalGen.m_DoAddGibbsRinging = false;
 
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
         m_RandGen->SetSeed(0);
     else
         m_RandGen->SetSeed();
 
     // initialize output dwi image
     ImageRegion<3> croppedRegion = m_Parameters.m_SignalGen.m_ImageRegion; croppedRegion.SetSize(1, 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)-croppedRegion.GetSize(1))*m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     outImage->SetOrigin( shiftedOrigin );
     outImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     outImage->SetLargestPossibleRegion( croppedRegion );
     outImage->SetBufferedRegion( croppedRegion );
     outImage->SetRequestedRegion( croppedRegion );
     outImage->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     outImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     temp.Fill(0.0);
     outImage->FillBuffer(temp);
 
     // ADJUST GEOMETRY FOR FURTHER PROCESSING
     // is input slize size a power of two?
     unsigned int x=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0); unsigned int y=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     ItkDoubleImgType::SizeType pad; pad[0]=x%2; pad[1]=y%2; pad[2]=0;
     m_Parameters.m_SignalGen.m_ImageRegion.SetSize(0, x+pad[0]);
     m_Parameters.m_SignalGen.m_ImageRegion.SetSize(1, y+pad[1]);
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull() && (pad[0]>0 || pad[1]>0))
     {
         itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         zeroPadder->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
         zeroPadder->SetConstant(0);
         zeroPadder->SetPadUpperBound(pad);
         zeroPadder->Update();
         m_Parameters.m_SignalGen.m_FrequencyMap = zeroPadder->GetOutput();
     }
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull() && (pad[0]>0 || pad[1]>0))
     {
         itk::ConstantPadImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
         zeroPadder->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
         zeroPadder->SetConstant(0);
         zeroPadder->SetPadUpperBound(pad);
         zeroPadder->Update();
         m_Parameters.m_SignalGen.m_MaskImage = zeroPadder->GetOutput();
     }
 
     // Apply in-plane upsampling for Gibbs ringing artifact
     double upsampling = 1;
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
         upsampling = 2;
     m_UpsampledSpacing = m_Parameters.m_SignalGen.m_ImageSpacing;
     m_UpsampledSpacing[0] /= upsampling;
     m_UpsampledSpacing[1] /= upsampling;
     m_UpsampledImageRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_UpsampledImageRegion.SetSize(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[0]*upsampling);
     m_UpsampledImageRegion.SetSize(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[1]*upsampling);
     m_UpsampledOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     m_UpsampledOrigin[0] -= m_Parameters.m_SignalGen.m_ImageSpacing[0]/2; m_UpsampledOrigin[0] += m_UpsampledSpacing[0]/2;
     m_UpsampledOrigin[1] -= m_Parameters.m_SignalGen.m_ImageSpacing[1]/2; m_UpsampledOrigin[1] += m_UpsampledSpacing[1]/2;
     m_UpsampledOrigin[2] -= m_Parameters.m_SignalGen.m_ImageSpacing[2]/2; m_UpsampledOrigin[2] += m_UpsampledSpacing[2]/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++)
     {
         DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
         doubleDwi->SetSpacing( m_UpsampledSpacing );
         doubleDwi->SetOrigin( m_UpsampledOrigin );
         doubleDwi->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
         doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
         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);
     }
 
     // initialize output volume fraction images
     m_VolumeFractions.clear();
     for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
     {
         ItkDoubleImgType::Pointer doubleImg = ItkDoubleImgType::New();
         doubleImg->SetSpacing( m_UpsampledSpacing );
         doubleImg->SetOrigin( m_UpsampledOrigin );
         doubleImg->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         doubleImg->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleImg->SetBufferedRegion( m_UpsampledImageRegion );
         doubleImg->SetRequestedRegion( m_UpsampledImageRegion );
         doubleImg->Allocate();
         doubleImg->FillBuffer(0);
         m_VolumeFractions.push_back(doubleImg);
     }
 
     // get volume fraction images
     ItkDoubleImgType::Pointer sumImage = ItkDoubleImgType::New();
     bool foundVolumeFractionImage = false;
 
     for (int i=0; i<numNonFiberCompartments; i++)  // look if a volume fraction image is set
     {
         if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNotNull())
         {
             foundVolumeFractionImage = true;
 
             itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
             zeroPadder->SetInput(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
             zeroPadder->SetConstant(0);
             zeroPadder->SetPadUpperBound(pad);
             zeroPadder->Update();
             m_Parameters.m_NonFiberModelList[i]->SetVolumeFractionImage(zeroPadder->GetOutput());
 
             sumImage->SetSpacing( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetSpacing() );
             sumImage->SetOrigin( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetOrigin() );
             sumImage->SetDirection( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetDirection() );
             sumImage->SetLargestPossibleRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->SetBufferedRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->SetRequestedRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->Allocate();
             sumImage->FillBuffer(0);
             break;
         }
     }
     if (!foundVolumeFractionImage)
     {
         sumImage->SetSpacing( m_UpsampledSpacing );
         sumImage->SetOrigin( m_UpsampledOrigin );
         sumImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         sumImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         sumImage->SetBufferedRegion( m_UpsampledImageRegion );
         sumImage->SetRequestedRegion( m_UpsampledImageRegion );
         sumImage->Allocate();
         sumImage->FillBuffer(0.0);
     }
     for (int i=0; i<numNonFiberCompartments; i++)
     {
         if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNull())
         {
             ItkDoubleImgType::Pointer doubleImg = ItkDoubleImgType::New();
             doubleImg->SetSpacing( sumImage->GetSpacing() );
             doubleImg->SetOrigin( sumImage->GetOrigin() );
             doubleImg->SetDirection( sumImage->GetDirection() );
             doubleImg->SetLargestPossibleRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->SetBufferedRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->SetRequestedRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->Allocate();
             doubleImg->FillBuffer(1.0/numNonFiberCompartments);
             m_Parameters.m_NonFiberModelList[i]->SetVolumeFractionImage(doubleImg);
         }
         ImageRegionIterator<ItkDoubleImgType> it(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage(), m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             sumImage->SetPixel(it.GetIndex(), sumImage->GetPixel(it.GetIndex())+it.Get());
             ++it;
         }
     }
     for (int i=0; i<numNonFiberCompartments; i++)
     {
         ImageRegionIterator<ItkDoubleImgType> it(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage(), m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             if (sumImage->GetPixel(it.GetIndex())>0)
                 it.Set(it.Get()/sumImage->GetPixel(it.GetIndex()));
             ++it;
         }
     }
 
     // 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)
             itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::Pointer 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
             itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
             resampler->SetInput(rescaler->GetOutput());
             resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
             resampler->SetSize(m_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::Pointer nn_interpolator
                     = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
             resampler->SetInterpolator(nn_interpolator);
             resampler->Update();
             m_Parameters.m_SignalGen.m_MaskImage = resampler->GetOutput();
 
             itk::ImageFileWriter<ItkUcharImgType>::Pointer w = itk::ImageFileWriter<ItkUcharImgType>::New();
             w->SetFileName("/local/mask_ups.nrrd");
             w->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
             w->Update();
         }
         // resample frequency map
         if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
         {
             itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer 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_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::Pointer nn_interpolator
                     = itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::New();
             resampler->SetInterpolator(nn_interpolator);
             resampler->Update();
             m_Parameters.m_SignalGen.m_FrequencyMap = resampler->GetOutput();
         }
     }
 
     // no input tissue mask is set -> create default
     m_MaskImageSet = true;
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNull())
     {
         m_StatusText += "No tissue mask set\n";
         MITK_INFO << "No tissue mask set";
         m_Parameters.m_SignalGen.m_MaskImage = ItkUcharImgType::New();
         m_Parameters.m_SignalGen.m_MaskImage->SetSpacing( m_UpsampledSpacing );
         m_Parameters.m_SignalGen.m_MaskImage->SetOrigin( m_UpsampledOrigin );
         m_Parameters.m_SignalGen.m_MaskImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         m_Parameters.m_SignalGen.m_MaskImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->SetBufferedRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->SetRequestedRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->Allocate();
         m_Parameters.m_SignalGen.m_MaskImage->FillBuffer(1);
         m_MaskImageSet = false;
     }
     else
     {
         m_StatusText += "Using tissue mask\n";
         MITK_INFO << "Using tissue mask";
     }
 
     m_Parameters.m_SignalGen.m_ImageRegion = croppedRegion;
     x=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0); y=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         m_Parameters.m_SignalGen.m_ImageRegion.SetSize(0, x+1);
     if ( y%2 == 1 )
         m_Parameters.m_SignalGen.m_ImageRegion.SetSize(1, y+1);
 
     // resample fiber bundle for sufficient voxel coverage
     m_StatusText += "\n"+this->GetTime()+" > Resampling fibers ...\n";
     double segmentVolume = 0.0001;
     float minSpacing = 1;
     if(m_UpsampledSpacing[0]<m_UpsampledSpacing[1] && m_UpsampledSpacing[0]<m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[0];
     else if (m_UpsampledSpacing[1] < m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[1];
     else
         minSpacing = m_UpsampledSpacing[2];
     m_FiberBundleWorkingCopy = m_FiberBundle->GetDeepCopy();
     double volumeAccuracy = 10;
     m_FiberBundleWorkingCopy->ResampleFibers(minSpacing/volumeAccuracy);
     double mmRadius = m_Parameters.m_SignalGen.m_AxonRadius/1000;
     if (mmRadius>0)
         segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/volumeAccuracy;
 
     double maxVolume = 0;
     m_VoxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
         std::string fileName = "fiberfox_motion_0.log";
         std::string filePath = mitk::IOUtil::GetTempPath();
         if (m_Parameters.m_Misc.m_OutputPath.size()>0)
             filePath = m_Parameters.m_Misc.m_OutputPath;
 
         int c = 1;
 
         while (itksys::SystemTools::FileExists((filePath+fileName).c_str()))
         {
             fileName = "fiberfox_motion_";
             fileName += boost::lexical_cast<std::string>(c);
             fileName += ".log";
             c++;
         }
 
         m_Logfile.open((filePath+fileName).c_str());
         m_Logfile << "0 rotation: 0,0,0; translation: 0,0,0\n";
 
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
             m_StatusText += "Adding random motion artifacts:\n";
             m_StatusText += "Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°\n";
             m_StatusText += "Maximum translation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm\n";
         }
         else
         {
             m_StatusText += "Adding linear motion artifacts:\n";
             m_StatusText += "Maximum rotation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°\n";
             m_StatusText += "Maximum translation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm\n";
         }
         m_StatusText += "Motion logfile: " + (filePath+fileName) + "\n";
         MITK_INFO << "Adding motion artifacts";
         MITK_INFO << "Maximum rotation: " << m_Parameters.m_SignalGen.m_Rotation;
         MITK_INFO << "Maxmimum translation: " << m_Parameters.m_SignalGen.m_Translation;
     }
     maxVolume = 0;
 
     m_StatusText += "\n"+this->GetTime()+" > Generating " + boost::lexical_cast<std::string>(numFiberCompartments+numNonFiberCompartments) + "-compartment diffusion-weighted signal.\n";
+    MITK_INFO << "Generating " << numFiberCompartments+numNonFiberCompartments << "-compartment diffusion-weighted signal.";
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers*m_Parameters.m_SignalGen.GetNumVolumes());
 
 
     // get transform for motion artifacts
     m_FiberBundleTransformed = m_FiberBundleWorkingCopy;
     m_Rotation = m_Parameters.m_SignalGen.m_Rotation/m_Parameters.m_SignalGen.GetNumVolumes();
     m_Translation = m_Parameters.m_SignalGen.m_Translation/m_Parameters.m_SignalGen.GetNumVolumes();
 
     // creat image to hold transformed mask (motion artifact)
     m_MaskImage = ItkUcharImgType::New();
     itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(m_Parameters.m_SignalGen.m_MaskImage);
     duplicator->Update();
     m_MaskImage = duplicator->GetOutput();
 
     // second upsampling needed for motion artifacts
     ImageRegion<3>      upsampledImageRegion = m_UpsampledImageRegion;
     DoubleVectorType    upsampledSpacing = m_UpsampledSpacing;
     upsampledSpacing[0] /= 4;
     upsampledSpacing[1] /= 4;
     upsampledSpacing[2] /= 4;
     upsampledImageRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]*4);
     upsampledImageRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]*4);
     upsampledImageRegion.SetSize(2, m_UpsampledImageRegion.GetSize()[2]*4);
     itk::Point<double,3> upsampledOrigin = m_UpsampledOrigin;
     upsampledOrigin[0] -= m_UpsampledSpacing[0]/2; upsampledOrigin[0] += upsampledSpacing[0]/2;
     upsampledOrigin[1] -= m_UpsampledSpacing[1]/2; upsampledOrigin[1] += upsampledSpacing[1]/2;
     upsampledOrigin[2] -= m_UpsampledSpacing[2]/2; upsampledOrigin[2] += upsampledSpacing[2]/2;
     m_UpsampledMaskImage = ItkUcharImgType::New();
     itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer 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);
     itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::Pointer nn_interpolator
             = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
     upsampler->SetInterpolator(nn_interpolator);
     upsampler->Update();
     m_UpsampledMaskImage = upsampler->GetOutput();
 
     unsigned long lastTick = 0;
     int signalModelSeed = m_RandGen->GetIntegerVariate();
     switch (m_Parameters.m_SignalGen.m_DiffusionDirectionMode)
     {
     case(SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS):   // use fiber tangent directions to determine diffusion direction
     {
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
 
         for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); 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);
 
             ItkDoubleImgType::Pointer intraAxonalVolumeImage = ItkDoubleImgType::New();
             intraAxonalVolumeImage->SetSpacing( m_UpsampledSpacing );
             intraAxonalVolumeImage->SetOrigin( m_UpsampledOrigin );
             intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
             intraAxonalVolumeImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->SetBufferedRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->SetRequestedRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->Allocate();
             intraAxonalVolumeImage->FillBuffer(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++ )
                 {
                     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())
                         {
                             m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                             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_MaskImage->TransformPhysicalPointToIndex(vertex, idx);
                         m_MaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
                         if (!m_MaskImage->GetLargestPossibleRegion().IsInside(idx) || m_MaskImage->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] += segmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g);
 
                             m_CompartmentImages.at(k)->SetPixel(idx, pix);
                         }
 
                         // update fiber volume image
                         double vol = intraAxonalVolumeImage->GetPixel(idx) + segmentVolume;
                         intraAxonalVolumeImage->SetPixel(idx, vol);
                         if (g==0 && 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++)
                         m_StatusText += "*";
                     lastTick = newTick;
                 }
 
             // generate non-fiber signal
             ImageRegionIterator<ItkUcharImgType> it3(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
             double fact = 1;
             if (m_Parameters.m_SignalGen.m_AxonRadius<0.0001 || maxVolume>m_VoxelVolume)
                 fact = m_VoxelVolume/maxVolume;
             while(!it3.IsAtEnd())
             {
                 if (it3.Get()>0)
                 {
                     DoubleDwiType::IndexType index = it3.GetIndex();
 
                     // adjust intra-axonal signal to abtain an only-fiber voxel
                     if (fabs(fact-1.0)>0.0001)
                         for (int i=0; i<numFiberCompartments; i++)
                         {
                             DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                             pix[g] *= fact;
                             m_CompartmentImages.at(i)->SetPixel(index, pix);
                         }
 
                     // simulate other compartments
                     SimulateNonFiberSignal(index, intraAxonalVolumeImage->GetPixel(index)*fact, g);
                 }
                 ++it3;
             }
 
             // move fibers
             SimulateMotion(g);
         }
         break;
     }
     case (SignalGenerationParameters::MAIN_FIBER_DIRECTIONS): // use main fiber directions to determine voxel-wise diffusion directions
     {
         typedef itk::Image< itk::Vector< float, 3>, 3 >                                 ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >  ItkDirectionImageContainerType;
 
         // calculate main fiber directions
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(m_FiberBundleTransformed);
         fOdfFilter->SetMaskImage(m_MaskImage);
         fOdfFilter->SetAngularThreshold(cos(m_Parameters.m_SignalGen.m_FiberSeparationThreshold*M_PI/180.0));
         fOdfFilter->SetNormalizeVectors(false);
         fOdfFilter->SetUseWorkingCopy(true);
         fOdfFilter->SetSizeThreshold(0);
         fOdfFilter->SetMaxNumDirections(3);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // allocate image storing intra-axonal volume fraction information
         ItkDoubleImgType::Pointer intraAxonalVolumeImage = ItkDoubleImgType::New();
         intraAxonalVolumeImage->SetSpacing( m_UpsampledSpacing );
         intraAxonalVolumeImage->SetOrigin( m_UpsampledOrigin );
         intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         intraAxonalVolumeImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->SetBufferedRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->SetRequestedRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->Allocate();
         intraAxonalVolumeImage->FillBuffer(0);
 
         // determine intra-axonal volume fraction using the tract density
         itk::TractDensityImageFilter< ItkDoubleImgType >::Pointer tdiFilter = itk::TractDensityImageFilter< ItkDoubleImgType >::New();
         tdiFilter->SetFiberBundle(m_FiberBundleTransformed);
         tdiFilter->SetBinaryOutput(false);
         tdiFilter->SetOutputAbsoluteValues(false);
         tdiFilter->SetInputImage(intraAxonalVolumeImage);
         tdiFilter->SetUseImageGeometry(true);
         tdiFilter->Update();
         intraAxonalVolumeImage = tdiFilter->GetOutput();
 
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
         boost::progress_display disp(m_MaskImage->GetLargestPossibleRegion().GetNumberOfPixels()*m_Parameters.m_SignalGen.GetNumVolumes());
 
         for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); 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);
 
             if (m_Parameters.m_SignalGen.m_DoAddMotion && g>0)  // if fibers have moved we need a new TDI and new directions
             {
                 fOdfFilter->SetFiberBundle(m_FiberBundleTransformed);
                 fOdfFilter->SetMaskImage(m_MaskImage);
                 fOdfFilter->Update();
                 directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
                 tdiFilter->SetFiberBundle(m_FiberBundleTransformed);
                 tdiFilter->Update();
                 intraAxonalVolumeImage = tdiFilter->GetOutput();
             }
 
             ImageRegionIterator< ItkUcharImgType > it(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
             while(!it.IsAtEnd())
             {
                 ++disp;
                 unsigned long newTick = 50*disp.count()/disp.expected_count();
                 for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
                     m_StatusText += "*";
                 lastTick = newTick;
 
                 if (this->GetAbortGenerateData())
                 {
                     m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                     return;
                 }
 
                 if (it.Get()>0)
                 {
                     // generate fiber signal
                     for (int c=0; c<m_Parameters.m_FiberModelList.size(); c++)
                     {
                         int count = 0;
                         DoubleDwiType::PixelType pix = m_CompartmentImages.at(c)->GetPixel(it.GetIndex());
                         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
                         {
                             itk::Vector< double, 3> dir;
                             dir.CastFrom(directionImageContainer->GetElement(i)->GetPixel(it.GetIndex()));
                             double norm = dir.GetNorm();
                             if (norm>0.0001)
                             {
                                 m_Parameters.m_FiberModelList.at(c)->SetFiberDirection(dir);
                                 pix[g] += m_Parameters.m_FiberModelList.at(c)->SimulateMeasurement(g)*norm;
                                 count++;
                             }
                         }
                         if (count>0)
                             pix[g] /= count;
                         pix[g] *= intraAxonalVolumeImage->GetPixel(it.GetIndex())*m_VoxelVolume;
                         m_CompartmentImages.at(c)->SetPixel(it.GetIndex(), pix);
                     }
 
                     // simulate other compartments
                     SimulateNonFiberSignal(it.GetIndex(), intraAxonalVolumeImage->GetPixel(it.GetIndex())*m_VoxelVolume, g);
                 }
                 ++it;
             }
 
             SimulateMotion(g);
         }
 
         itk::ImageFileWriter< ItkUcharImgType >::Pointer wr = itk::ImageFileWriter< ItkUcharImgType >::New();
         wr->SetInput(fOdfFilter->GetNumDirectionsImage());
         wr->SetFileName(mitk::IOUtil::GetTempPath()+"/NumDirections_MainFiberDirections.nrrd");
         wr->Update();
         break;
     }
     case (SignalGenerationParameters::RANDOM_DIRECTIONS):
     {
         ItkUcharImgType::Pointer numDirectionsImage = ItkUcharImgType::New();
         numDirectionsImage->SetSpacing( m_UpsampledSpacing );
         numDirectionsImage->SetOrigin( m_UpsampledOrigin );
         numDirectionsImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         numDirectionsImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         numDirectionsImage->SetBufferedRegion( m_UpsampledImageRegion );
         numDirectionsImage->SetRequestedRegion( m_UpsampledImageRegion );
         numDirectionsImage->Allocate();
         numDirectionsImage->FillBuffer(0);
         double sepAngle = cos(m_Parameters.m_SignalGen.m_FiberSeparationThreshold*M_PI/180.0);
 
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
         boost::progress_display disp(m_MaskImage->GetLargestPossibleRegion().GetNumberOfPixels());
         ImageRegionIterator<ItkUcharImgType> it(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
 
             if (this->GetAbortGenerateData())
             {
                 m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                 return;
             }
 
             if (it.Get()>0)
             {
                 int numFibs = m_RandGen->GetIntegerVariate(2)+1;
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(it.GetIndex());
                 double volume = m_RandGen->GetVariateWithClosedRange(0.3);
 
                 //                double sum = 0;
                 std::vector< double > fractions;
                 for (int i=0; i<numFibs; i++)
                 {
                     //                    fractions.push_back(1);
                     fractions.push_back(0.5+m_RandGen->GetVariateWithClosedRange(0.5));
                     //                    sum += fractions.at(i);
                 }
                 //                for (int i=0; i<numFibs; i++)
                 //                    fractions[i] /= sum;
 
                 std::vector< itk::Vector<double, 3> > directions;
                 for (int i=0; i<numFibs; i++)
                 {
                     DoubleVectorType fib;
                     fib[0] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib[1] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib[2] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib.Normalize();
 
                     double min = 0;
                     for (unsigned int d=0; d<directions.size(); d++)
                     {
                         double angle = fabs(fib*directions[d]);
                         if (angle>min)
                             min = angle;
                     }
                     if (min<sepAngle)
                     {
                         m_Parameters.m_FiberModelList.at(0)->SetFiberDirection(fib);
                         pix += m_Parameters.m_FiberModelList.at(0)->SimulateMeasurement()*fractions[i];
                         directions.push_back(fib);
                     }
                     else
                         i--;
                 }
                 pix *= (1-volume);
                 m_CompartmentImages.at(0)->SetPixel(it.GetIndex(), pix);
 
                 // CSF/GM
                 {
                     pix += volume*m_Parameters.m_NonFiberModelList.at(0)->SimulateMeasurement();
                 }
 
                 numDirectionsImage->SetPixel(it.GetIndex(), numFibs);
             }
             ++it;
         }
 
         itk::ImageFileWriter< ItkUcharImgType >::Pointer wr = itk::ImageFileWriter< ItkUcharImgType >::New();
         wr->SetInput(numDirectionsImage);
         wr->SetFileName(mitk::IOUtil::GetTempPath()+"/NumDirections_RandomDirections.nrrd");
         wr->Update();
     }
     }
 
     if (m_Logfile.is_open())
     {
         m_Logfile << "DONE";
         m_Logfile.close();
     }
     m_StatusText += "\n\n";
     if (this->GetAbortGenerateData())
     {
         m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
     DoubleDwiType::Pointer doubleOutImage;
     if ( m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition ) // do k-space stuff
     {
         m_StatusText += this->GetTime()+" > Adjusting complex signal\n";
         MITK_INFO << "Adjusting complex signal:";
 
         if (m_Parameters.m_SignalGen.m_DoSimulateRelaxation)
             m_StatusText += "Simulating signal relaxation\n";
         if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
             m_StatusText += "Simulating distortions\n";
         if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
             m_StatusText += "Simulating ringing artifacts\n";
         if (m_Parameters.m_SignalGen.m_EddyStrength>0)
             m_StatusText += "Simulating eddy currents\n";
         if (m_Parameters.m_SignalGen.m_Spikes>0)
             m_StatusText += "Simulating spikes\n";
         if (m_Parameters.m_SignalGen.m_CroppingFactor<1.0)
             m_StatusText += "Simulating aliasing artifacts\n";
         if (m_Parameters.m_SignalGen.m_KspaceLineOffset>0)
             m_StatusText += "Simulating ghosts\n";
 
         doubleOutImage = DoKspaceStuff(m_CompartmentImages);
         m_Parameters.m_SignalGen.m_SignalScale = 1; // already scaled in DoKspaceStuff
     }
     else    // don't do k-space stuff, just sum compartments
     {
         m_StatusText += this->GetTime()+" > Summing compartments\n";
         MITK_INFO << "Summing compartments";
         doubleOutImage = m_CompartmentImages.at(0);
 
         for (unsigned int i=1; i<m_CompartmentImages.size(); i++)
         {
             itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
             adder->SetInput1(doubleOutImage);
             adder->SetInput2(m_CompartmentImages.at(i));
             adder->Update();
             doubleOutImage = adder->GetOutput();
         }
     }
     if (this->GetAbortGenerateData())
     {
         m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
     m_StatusText += this->GetTime()+" > Finalizing image\n";
     MITK_INFO << "Finalizing image";
     if (m_Parameters.m_SignalGen.m_SignalScale>1)
         m_StatusText += " Scaling signal\n";
     if (m_Parameters.m_NoiseModel!=NULL)
         m_StatusText += " Adding noise\n";
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     boost::progress_display disp2(outImage->GetLargestPossibleRegion().GetNumberOfPixels());
 
     m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
     m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
     lastTick = 0;
 
     while(!it4.IsAtEnd())
     {
         if (this->GetAbortGenerateData())
         {
             m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
             return;
         }
 
         ++disp2;
         unsigned long newTick = 50*disp2.count()/disp2.expected_count();
         for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
             m_StatusText += "*";
         lastTick = newTick;
 
         typename OutputImageType::IndexType index = it4.GetIndex();
         signal = doubleOutImage->GetPixel(index)*m_Parameters.m_SignalGen.m_SignalScale;
 
         if (m_Parameters.m_NoiseModel!=NULL)
             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, outImage);
 
     m_StatusText += "\n\n";
     m_StatusText += "Finished simulation\n";
     m_StatusText += "Simulation time: "+GetTime();
     m_TimeProbe.Stop();
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::SimulateMotion(int g)
 {
     if (m_Parameters.m_SignalGen.m_DoAddMotion && g<m_Parameters.m_SignalGen.GetNumVolumes()-1)
     {
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
             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];
         }
 
         // rotate mask image
         if (m_MaskImageSet)
         {
             ImageRegionIterator<ItkUcharImgType> maskIt(m_UpsampledMaskImage, m_UpsampledMaskImage->GetLargestPossibleRegion());
             m_MaskImage->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]*(g+1),m_Rotation[1]*(g+1),m_Rotation[2]*(g+1),m_Translation[0]*(g+1),m_Translation[1]*(g+1),m_Translation[2]*(g+1));
 
                 m_MaskImage->TransformPhysicalPointToIndex(point, index);
                 if (m_MaskImage->GetLargestPossibleRegion().IsInside(index))
                     m_MaskImage->SetPixel(index,100);
                 ++maskIt;
             }
         }
 
         // rotate fibers
         if (m_Logfile.is_open())
         {
             m_Logfile << g+1 << " rotation: " << m_Rotation[0] << "," << m_Rotation[1] << "," << m_Rotation[2] << ";";
             m_Logfile << " translation: " << m_Translation[0] << "," << m_Translation[1] << "," << m_Translation[2] << "\n";
         }
         m_FiberBundleTransformed->TransformFibers(m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
     }
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::SimulateNonFiberSignal(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);
         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
     {
         m_VolumeFractions.at(0)->SetPixel(index, intraAxonalVolume/m_VoxelVolume);
 
         itk::Point<double, 3> point;
         m_MaskImage->TransformIndexToPhysicalPoint(index, point);
         if (m_Parameters.m_SignalGen.m_DoAddMotion)
         {
             if (m_Parameters.m_SignalGen.m_DoRandomizeMotion && g>0)
                 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 if (g>=0)
                 point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), -m_Rotation[0]*g,-m_Rotation[1]*g,-m_Rotation[2]*g,-m_Translation[0]*g,-m_Translation[1]*g,-m_Translation[2]*g);
         }
 
         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)
                 {
                     DoubleDwiType::IndexType newIndex;
                     m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->TransformPhysicalPointToIndex(point, newIndex);
                     if (!m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion().IsInside(newIndex))
                         continue;
                     weight = m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetPixel(newIndex);
                 }
 
                 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);
             else
                 pix += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement();
             doubleDwi->SetPixel(index, pix);
             m_VolumeFractions.at(maxVolumeIndex+numFiberCompartments)->SetPixel(index, 1);
         }
         else
         {
             double extraAxonalVolume = m_VoxelVolume-intraAxonalVolume;    // non-fiber volume
             double interAxonalVolume = 0;
             if (numFiberCompartments>1)
                 interAxonalVolume = extraAxonalVolume * intraAxonalVolume/m_VoxelVolume;   // inter-axonal fraction of non fiber compartment scales linearly with f
             double other = extraAxonalVolume - interAxonalVolume;        // rest of compartment
             double singleinter = interAxonalVolume/(numFiberCompartments-1);
 
             // adjust non-fiber and intra-axonal signal
             for (int i=1; i<numFiberCompartments; i++)
             {
                 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 (g>=0)
                     pix[g] *= singleinter;
                 else
                     pix *= singleinter;
                 m_CompartmentImages.at(i)->SetPixel(index, pix);
                 m_VolumeFractions.at(i)->SetPixel(index, singleinter/m_VoxelVolume);
             }
 
             for (int i=0; i<numNonFiberCompartments; i++)
             {
                 double weight = 1;
                 if (numNonFiberCompartments>1)
                 {
                     DoubleDwiType::IndexType newIndex;
                     m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->TransformPhysicalPointToIndex(point, newIndex);
                     if (!m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion().IsInside(newIndex))
                         continue;
                     weight = m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetPixel(newIndex);
                 }
 
                 DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(i+numFiberCompartments);
                 DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
 
                 if (g>=0)
                     pix[g] += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement(g)*other*weight;
                 else
                     pix += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement()*other*weight;
                 doubleDwi->SetPixel(index, pix);
                 m_VolumeFractions.at(i+numFiberCompartments)->SetPixel(index, other/m_VoxelVolume*weight);
             }
         }
     }
 }
 
 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/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
index 805447625c..f42ba79799 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.cpp
@@ -1,658 +1,668 @@
 /*===================================================================
 
 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 <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 
 #include <itkImageFileWriter.h>
 #include <itkImageFileReader.h>
 
 template< class ScalarType >
 mitk::FiberfoxParameters< ScalarType >::FiberfoxParameters()
     : m_NoiseModel(NULL)
 {
 
 }
 
 template< class ScalarType >
 mitk::FiberfoxParameters< ScalarType >::~FiberfoxParameters()
 {
     //    if (m_NoiseModel!=NULL)
     //        delete m_NoiseModel;
 }
 
 void mitk::SignalGenerationParameters::GenerateGradientHalfShell()
 {
     int NPoints = 2*m_NumGradients;
     m_GradientDirections.clear();
 
     m_NumBaseline = NPoints/20;
     if (m_NumBaseline==0)
         m_NumBaseline=1;
 
     GradientType g;
     g.Fill(0.0);
     for (unsigned int i=0; i<m_NumBaseline; i++)
         m_GradientDirections.push_back(g);
 
     if (NPoints==0)
         return;
 
     vnl_vector<double> theta; theta.set_size(NPoints);
     vnl_vector<double> phi; phi.set_size(NPoints);
     double C = sqrt(4*M_PI);
     phi(0) = 0.0;
     phi(NPoints-1) = 0.0;
     for(int i=0; i<NPoints; i++)
     {
         theta(i) = acos(-1.0+2.0*i/(NPoints-1.0)) - M_PI / 2.0;
         if( i>0 && i<NPoints-1)
         {
             phi(i) = (phi(i-1) + C /
                       sqrt(NPoints*(1-(-1.0+2.0*i/(NPoints-1.0))*(-1.0+2.0*i/(NPoints-1.0)))));
         }
     }
 
     for(int i=0; i<NPoints; i++)
     {
         g[2] = sin(theta(i));
         if (g[2]<0)
             continue;
         g[0] = cos(theta(i)) * cos(phi(i));
         g[1] = cos(theta(i)) * sin(phi(i));
         m_GradientDirections.push_back(g);
     }
 }
 
 std::vector< int > mitk::SignalGenerationParameters::GetBaselineIndices()
 {
     std::vector< int > result;
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
         if (m_GradientDirections.at(i).GetNorm()<0.0001)
             result.push_back(i);
     return result;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetFirstBaselineIndex()
 {
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
         if (m_GradientDirections.at(i).GetNorm()<0.0001)
             return i;
     return -1;
 }
 
 bool mitk::SignalGenerationParameters::IsBaselineIndex(unsigned int idx)
 {
     if (m_GradientDirections.size()>idx && m_GradientDirections.at(idx).GetNorm()<0.0001)
         return true;
     return false;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumWeightedVolumes()
 {
     return m_NumGradients;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumBaselineVolumes()
 {
     return m_NumBaseline;
 }
 
 unsigned int mitk::SignalGenerationParameters::GetNumVolumes()
 {
     return m_GradientDirections.size();
 }
 
-typename mitk::SignalGenerationParameters::GradientListType mitk::SignalGenerationParameters::GetGradientDirections()
+mitk::SignalGenerationParameters::GradientListType mitk::SignalGenerationParameters::GetGradientDirections()
 {
     return m_GradientDirections;
 }
 
 mitk::SignalGenerationParameters::GradientType mitk::SignalGenerationParameters::GetGradientDirection(unsigned int i)
 {
     return m_GradientDirections.at(i);
 }
 
 void mitk::SignalGenerationParameters::SetNumWeightedVolumes(int numGradients)
 {
     m_NumGradients = numGradients;
     GenerateGradientHalfShell();
 }
 
 void mitk::SignalGenerationParameters::SetGradienDirections(GradientListType gradientList)
 {
     m_GradientDirections = gradientList;
     m_NumGradients = 0;
     m_NumBaseline = 0;
     for( unsigned int i=0; i<this->m_GradientDirections.size(); i++)
     {
         if (m_GradientDirections.at(i).GetNorm()>0.0001)
             m_NumGradients++;
         else
             m_NumBaseline++;
     }
 }
 
 void mitk::SignalGenerationParameters::SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList)
 {
     m_NumGradients = 0;
     m_NumBaseline = 0;
     m_GradientDirections.clear();
 
     for( unsigned int i=0; i<gradientList->Size(); i++)
     {
         GradientType g;
         g[0] = gradientList->at(i)[0];
         g[1] = gradientList->at(i)[1];
         g[2] = gradientList->at(i)[2];
         m_GradientDirections.push_back(g);
 
         if (m_GradientDirections.at(i).GetNorm()>0.0001)
             m_NumGradients++;
         else
             m_NumBaseline++;
     }
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::SaveParameters(string filename)
 {
     if(filename.empty())
         return;
     if(".ffp"!=filename.substr(filename.size()-4, 4))
         filename += ".ffp";
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.distribution", m_FiberGen.m_Distribution);
     parameters.put("fiberfox.fibers.variance", m_FiberGen.m_Variance);
     parameters.put("fiberfox.fibers.density", m_FiberGen.m_Density);
     parameters.put("fiberfox.fibers.spline.sampling", m_FiberGen.m_Sampling);
     parameters.put("fiberfox.fibers.spline.tension", m_FiberGen.m_Tension);
     parameters.put("fiberfox.fibers.spline.continuity", m_FiberGen.m_Continuity);
     parameters.put("fiberfox.fibers.spline.bias", m_FiberGen.m_Bias);
     parameters.put("fiberfox.fibers.rotation.x", m_FiberGen.m_Rotation[0]);
     parameters.put("fiberfox.fibers.rotation.y", m_FiberGen.m_Rotation[1]);
     parameters.put("fiberfox.fibers.rotation.z", m_FiberGen.m_Rotation[2]);
     parameters.put("fiberfox.fibers.translation.x", m_FiberGen.m_Translation[0]);
     parameters.put("fiberfox.fibers.translation.y", m_FiberGen.m_Translation[1]);
     parameters.put("fiberfox.fibers.translation.z", m_FiberGen.m_Translation[2]);
     parameters.put("fiberfox.fibers.scale.x", m_FiberGen.m_Scale[0]);
     parameters.put("fiberfox.fibers.scale.y", m_FiberGen.m_Scale[1]);
     parameters.put("fiberfox.fibers.scale.z", m_FiberGen.m_Scale[2]);
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_SignalGen.m_ImageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_SignalGen.m_ImageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_SignalGen.m_ImageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_SignalGen.m_ImageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_SignalGen.m_ImageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_SignalGen.m_ImageSpacing[2]);
     parameters.put("fiberfox.image.basic.origin.x", m_SignalGen.m_ImageOrigin[0]);
     parameters.put("fiberfox.image.basic.origin.y", m_SignalGen.m_ImageOrigin[1]);
     parameters.put("fiberfox.image.basic.origin.z", m_SignalGen.m_ImageOrigin[2]);
     parameters.put("fiberfox.image.basic.direction.1", m_SignalGen.m_ImageDirection[0][0]);
     parameters.put("fiberfox.image.basic.direction.2", m_SignalGen.m_ImageDirection[0][1]);
     parameters.put("fiberfox.image.basic.direction.3", m_SignalGen.m_ImageDirection[0][2]);
     parameters.put("fiberfox.image.basic.direction.4", m_SignalGen.m_ImageDirection[1][0]);
     parameters.put("fiberfox.image.basic.direction.5", m_SignalGen.m_ImageDirection[1][1]);
     parameters.put("fiberfox.image.basic.direction.6", m_SignalGen.m_ImageDirection[1][2]);
     parameters.put("fiberfox.image.basic.direction.7", m_SignalGen.m_ImageDirection[2][0]);
     parameters.put("fiberfox.image.basic.direction.8", m_SignalGen.m_ImageDirection[2][1]);
     parameters.put("fiberfox.image.basic.direction.9", m_SignalGen.m_ImageDirection[2][2]);
     parameters.put("fiberfox.image.basic.numgradients", m_SignalGen.GetNumWeightedVolumes());
+    for( unsigned int i=0; i<this->m_SignalGen.GetNumVolumes(); i++)
+    {
+        parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".x", m_SignalGen.GetGradientDirection(i)[0]);
+        parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".y", m_SignalGen.GetGradientDirection(i)[1]);
+        parameters.put("fiberfox.image.gradients."+boost::lexical_cast<string>(i)+".z", m_SignalGen.GetGradientDirection(i)[2]);
+    }
+
     parameters.put("fiberfox.image.signalScale", m_SignalGen.m_SignalScale);
     parameters.put("fiberfox.image.tEcho", m_SignalGen.m_tEcho);
     parameters.put("fiberfox.image.tLine", m_SignalGen.m_tLine);
     parameters.put("fiberfox.image.tInhom", m_SignalGen.m_tInhom);
     parameters.put("fiberfox.image.bvalue", m_SignalGen.m_Bvalue);
     parameters.put("fiberfox.image.simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
     parameters.put("fiberfox.image.axonRadius", m_SignalGen.m_AxonRadius);
     parameters.put("fiberfox.image.diffusiondirectionmode", m_SignalGen.m_DiffusionDirectionMode);
     parameters.put("fiberfox.image.fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
     parameters.put("fiberfox.image.artifacts.spikesnum", m_SignalGen.m_Spikes);
     parameters.put("fiberfox.image.artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
     parameters.put("fiberfox.image.artifacts.eddyTau", m_SignalGen.m_Tau);
     parameters.put("fiberfox.image.artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
     parameters.put("fiberfox.image.artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
     parameters.put("fiberfox.image.artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
     parameters.put("fiberfox.image.artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
     parameters.put("fiberfox.image.artifacts.translation0", m_SignalGen.m_Translation[0]);
     parameters.put("fiberfox.image.artifacts.translation1", m_SignalGen.m_Translation[1]);
     parameters.put("fiberfox.image.artifacts.translation2", m_SignalGen.m_Translation[2]);
     parameters.put("fiberfox.image.artifacts.rotation0", m_SignalGen.m_Rotation[0]);
     parameters.put("fiberfox.image.artifacts.rotation1", m_SignalGen.m_Rotation[1]);
     parameters.put("fiberfox.image.artifacts.rotation2", m_SignalGen.m_Rotation[2]);
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
     parameters.put("fiberfox.image.artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
     parameters.put("fiberfox.image.artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
     parameters.put("fiberfox.image.artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
     parameters.put("fiberfox.image.artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
     parameters.put("fiberfox.image.artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
     parameters.put("fiberfox.image.outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
     parameters.put("fiberfox.image.showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
     parameters.put("fiberfox.image.signalmodelstring", m_Misc.m_SignalModelString);
     parameters.put("fiberfox.image.artifactmodelstring", m_Misc.m_ArtifactModelString);
     parameters.put("fiberfox.image.outpath", m_Misc.m_OutputPath);
     parameters.put("fiberfox.fibers.realtime", m_Misc.m_CheckRealTimeFibersBox);
     parameters.put("fiberfox.fibers.showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
     parameters.put("fiberfox.fibers.constantradius", m_Misc.m_CheckConstantRadiusBox);
     parameters.put("fiberfox.fibers.includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
     if (m_NoiseModel!=NULL)
     {
         parameters.put("fiberfox.image.artifacts.noisevariance", m_NoiseModel->GetNoiseVariance());
         if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
             parameters.put("fiberfox.image.artifacts.noisetype", "rice");
         else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
             parameters.put("fiberfox.image.artifacts.noisetype", "chisquare");
     }
 
     for (int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
     {
         mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
         if (i<m_FiberModelList.size())
         {
             signalModel = m_FiberModelList.at(i);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "fiber");
         }
         else
         {
             signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".type", "non-fiber");
         }
 
         if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
         {
             mitk::StickModel<ScalarType>* model = dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".stick.d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".stick.t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
         {
             mitk::TensorModel<ScalarType>* model = dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".tensor.d1", model->GetDiffusivity1());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".tensor.d2", model->GetDiffusivity2());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".tensor.d3", model->GetDiffusivity3());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".tensor.t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
         {
             mitk::RawShModel<ScalarType>* model = dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".prototype.minFA", model->GetFaRange().first);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".prototype.maxFA", model->GetFaRange().second);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".prototype.minADC", model->GetAdcRange().first);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".prototype.maxADC", model->GetAdcRange().second);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".prototype.numSamples", model->GetMaxNumKernels());
         }
         else  if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
         {
             mitk::BallModel<ScalarType>* model = dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".ball.d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".ball.t2", model->GetT2());
         }
         else  if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
         {
             mitk::AstroStickModel<ScalarType>* model = dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".astrosticks.d", model->GetDiffusivity());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".astrosticks.t2", model->GetT2());
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".astrosticks.randomize", model->GetRandomizeSticks());
         }
         else  if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
         {
             mitk::DotModel<ScalarType>* model = dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel);
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".dot.t2", model->GetT2());
         }
 
         if (signalModel!=NULL)
         {
             parameters.put("fiberfox.image.compartments."+boost::lexical_cast<string>(i)+".ID", signalModel->m_CompartmentId);
 
-//            if (signalModel->GetVolumeFractionImage().IsNotNull())
-//            {
-//                try{
-//                    itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
-//                    writer->SetFileName(filename+"_VOLUME"+boost::lexical_cast<string>(signalModel->m_CompartmentId)+".nrrd");
-//                    writer->SetInput(signalModel->GetVolumeFractionImage());
-//                    writer->Update();
-//                    MITK_INFO << "Volume fraction image for compartment "+boost::lexical_cast<string>(signalModel->m_CompartmentId)+" saved.";
-//                }
-//                catch(...)
-//                {
-//                }
-//            }
+            if (signalModel->GetVolumeFractionImage().IsNotNull())
+            {
+                try{
+                    itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
+                    writer->SetFileName(filename+"_VOLUME"+boost::lexical_cast<string>(signalModel->m_CompartmentId)+".nrrd");
+                    writer->SetInput(signalModel->GetVolumeFractionImage());
+                    writer->Update();
+                    MITK_INFO << "Volume fraction image for compartment "+boost::lexical_cast<string>(signalModel->m_CompartmentId)+" saved.";
+                }
+                catch(...)
+                {
+                }
+            }
         }
     }
 
     boost::property_tree::xml_writer_settings<char> writerSettings(' ', 2);
     boost::property_tree::xml_parser::write_xml(filename, parameters, std::locale(), writerSettings);
 
-//    if (m_SignalGen.m_DoAddDistortions)
-//    {
-//        try{
-//            itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
-//            writer->SetFileName(filename+"_FMAP.nrrd");
-//            writer->SetInput(m_SignalGen.m_FrequencyMap);
-//            writer->Update();
-//        }
-//        catch(...)
-//        {
-//            MITK_INFO << "No frequency map saved.";
-//        }
-//    }
-
-//    try{
-//        itk::ImageFileWriter<ItkUcharImgType>::Pointer writer = itk::ImageFileWriter<ItkUcharImgType>::New();
-//        writer->SetFileName(filename+"_MASK.nrrd");
-//        writer->SetInput(m_SignalGen.m_MaskImage);
-//        writer->Update();
-//    }
-//    catch(...)
-//    {
-//        MITK_INFO << "No mask image saved.";
-//    }
+    try{
+        itk::ImageFileWriter<ItkDoubleImgType>::Pointer writer = itk::ImageFileWriter<ItkDoubleImgType>::New();
+        writer->SetFileName(filename+"_FMAP.nrrd");
+        writer->SetInput(m_SignalGen.m_FrequencyMap);
+        writer->Update();
+    }
+    catch(...)
+    {
+        MITK_INFO << "No frequency map saved.";
+    }
+    try{
+        itk::ImageFileWriter<ItkUcharImgType>::Pointer writer = itk::ImageFileWriter<ItkUcharImgType>::New();
+        writer->SetFileName(filename+"_MASK.nrrd");
+        writer->SetInput(m_SignalGen.m_MaskImage);
+        writer->Update();
+    }
+    catch(...)
+    {
+        MITK_INFO << "No mask image saved.";
+    }
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::LoadParameters(string filename)
 {
     if(filename.empty())
         return;
 
     boost::property_tree::ptree parameterTree;
     boost::property_tree::xml_parser::read_xml(filename, parameterTree);
 
     m_FiberModelList.clear();
     m_NonFiberModelList.clear();
     if (m_NoiseModel!=NULL)
         delete m_NoiseModel;
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameterTree.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Misc.m_CheckRealTimeFibersBox = v1.second.get<bool>("realtime", m_Misc.m_CheckRealTimeFibersBox);
             m_Misc.m_CheckAdvancedFiberOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedFiberOptionsBox);
             m_Misc.m_CheckConstantRadiusBox = v1.second.get<bool>("constantradius", m_Misc.m_CheckConstantRadiusBox);
             m_Misc.m_CheckIncludeFiducialsBox = v1.second.get<bool>("includeFiducials", m_Misc.m_CheckIncludeFiducialsBox);
 
             switch (v1.second.get<unsigned int>("distribution", 0))
             {
             case 0:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
                 break;
             case 1:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
                 break;
             default:
                 m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
             }
             m_FiberGen.m_Variance = v1.second.get<double>("variance", m_FiberGen.m_Variance);
             m_FiberGen.m_Density = v1.second.get<unsigned int>("density", m_FiberGen.m_Density);
             m_FiberGen.m_Sampling = v1.second.get<double>("spline.sampling", m_FiberGen.m_Sampling);
             m_FiberGen.m_Tension = v1.second.get<double>("spline.tension", m_FiberGen.m_Tension);
             m_FiberGen.m_Continuity = v1.second.get<double>("spline.continuity", m_FiberGen.m_Continuity);
             m_FiberGen.m_Bias = v1.second.get<double>("spline.bias", m_FiberGen.m_Bias);
             m_FiberGen.m_Rotation[0] = v1.second.get<double>("rotation.x", m_FiberGen.m_Rotation[0]);
             m_FiberGen.m_Rotation[1] = v1.second.get<double>("rotation.y", m_FiberGen.m_Rotation[1]);
             m_FiberGen.m_Rotation[2] = v1.second.get<double>("rotation.z", m_FiberGen.m_Rotation[2]);
             m_FiberGen.m_Translation[0] = v1.second.get<double>("translation.x", m_FiberGen.m_Translation[0]);
             m_FiberGen.m_Translation[1] = v1.second.get<double>("translation.y", m_FiberGen.m_Translation[1]);
             m_FiberGen.m_Translation[2] = v1.second.get<double>("translation.z", m_FiberGen.m_Translation[2]);
             m_FiberGen.m_Scale[0] = v1.second.get<double>("scale.x", m_FiberGen.m_Scale[0]);
             m_FiberGen.m_Scale[1] = v1.second.get<double>("scale.y", m_FiberGen.m_Scale[1]);
             m_FiberGen.m_Scale[2] = v1.second.get<double>("scale.z", m_FiberGen.m_Scale[2]);
         }
         else if ( v1.first == "image" )
         {
             m_Misc.m_SignalModelString = v1.second.get<string>("signalmodelstring", m_Misc.m_SignalModelString);
             m_Misc.m_ArtifactModelString = v1.second.get<string>("artifactmodelstring", m_Misc.m_ArtifactModelString);
             m_Misc.m_OutputPath = v1.second.get<string>("outpath", m_Misc.m_OutputPath);
             m_Misc.m_CheckOutputVolumeFractionsBox = v1.second.get<bool>("outputvolumefractions", m_Misc.m_CheckOutputVolumeFractionsBox);
             m_Misc.m_CheckAdvancedSignalOptionsBox = v1.second.get<bool>("showadvanced", m_Misc.m_CheckAdvancedSignalOptionsBox);
             m_Misc.m_CheckAddDistortionsBox = v1.second.get<bool>("artifacts.doAddDistortions", m_Misc.m_CheckAddDistortionsBox);
             m_Misc.m_CheckAddNoiseBox = v1.second.get<bool>("artifacts.addnoise", m_Misc.m_CheckAddNoiseBox);
             m_Misc.m_CheckAddGhostsBox = v1.second.get<bool>("artifacts.addghosts", m_Misc.m_CheckAddGhostsBox);
             m_Misc.m_CheckAddAliasingBox = v1.second.get<bool>("artifacts.addaliasing", m_Misc.m_CheckAddAliasingBox);
             m_Misc.m_CheckAddSpikesBox = v1.second.get<bool>("artifacts.addspikes", m_Misc.m_CheckAddSpikesBox);
             m_Misc.m_CheckAddEddyCurrentsBox = v1.second.get<bool>("artifacts.addeddycurrents", m_Misc.m_CheckAddEddyCurrentsBox);
 
             m_SignalGen.m_ImageRegion.SetSize(0, v1.second.get<int>("basic.size.x",m_SignalGen.m_ImageRegion.GetSize(0)));
             m_SignalGen.m_ImageRegion.SetSize(1, v1.second.get<int>("basic.size.y",m_SignalGen.m_ImageRegion.GetSize(1)));
             m_SignalGen.m_ImageRegion.SetSize(2, v1.second.get<int>("basic.size.z",m_SignalGen.m_ImageRegion.GetSize(2)));
             m_SignalGen.m_ImageSpacing[0] = v1.second.get<double>("basic.spacing.x",m_SignalGen.m_ImageSpacing[0]);
             m_SignalGen.m_ImageSpacing[1] = v1.second.get<double>("basic.spacing.y",m_SignalGen.m_ImageSpacing[1]);
             m_SignalGen.m_ImageSpacing[2] = v1.second.get<double>("basic.spacing.z",m_SignalGen.m_ImageSpacing[2]);
             m_SignalGen.m_ImageOrigin[0] = v1.second.get<double>("basic.origin.x",m_SignalGen.m_ImageOrigin[0]);
             m_SignalGen.m_ImageOrigin[1] = v1.second.get<double>("basic.origin.y",m_SignalGen.m_ImageOrigin[1]);
             m_SignalGen.m_ImageOrigin[2] = v1.second.get<double>("basic.origin.z",m_SignalGen.m_ImageOrigin[2]);
             m_SignalGen.m_ImageDirection[0][0] = v1.second.get<double>("basic.direction.1",m_SignalGen.m_ImageDirection[0][0]);
             m_SignalGen.m_ImageDirection[0][1] = v1.second.get<double>("basic.direction.2",m_SignalGen.m_ImageDirection[0][1]);
             m_SignalGen.m_ImageDirection[0][2] = v1.second.get<double>("basic.direction.3",m_SignalGen.m_ImageDirection[0][2]);
             m_SignalGen.m_ImageDirection[1][0] = v1.second.get<double>("basic.direction.4",m_SignalGen.m_ImageDirection[1][0]);
             m_SignalGen.m_ImageDirection[1][1] = v1.second.get<double>("basic.direction.5",m_SignalGen.m_ImageDirection[1][1]);
             m_SignalGen.m_ImageDirection[1][2] = v1.second.get<double>("basic.direction.6",m_SignalGen.m_ImageDirection[1][2]);
             m_SignalGen.m_ImageDirection[2][0] = v1.second.get<double>("basic.direction.7",m_SignalGen.m_ImageDirection[2][0]);
             m_SignalGen.m_ImageDirection[2][1] = v1.second.get<double>("basic.direction.8",m_SignalGen.m_ImageDirection[2][1]);
             m_SignalGen.m_ImageDirection[2][2] = v1.second.get<double>("basic.direction.9",m_SignalGen.m_ImageDirection[2][2]);
 
             m_SignalGen.m_SignalScale = v1.second.get<double>("signalScale", m_SignalGen.m_SignalScale);
             m_SignalGen.m_tEcho = v1.second.get<double>("tEcho", m_SignalGen.m_tEcho);
             m_SignalGen.m_tLine = v1.second.get<double>("tLine", m_SignalGen.m_tLine);
             m_SignalGen.m_tInhom = v1.second.get<double>("tInhom", m_SignalGen.m_tInhom);
             m_SignalGen.m_Bvalue = v1.second.get<double>("bvalue", m_SignalGen.m_Bvalue);
             m_SignalGen.m_SimulateKspaceAcquisition = v1.second.get<bool>("simulatekspace", m_SignalGen.m_SimulateKspaceAcquisition);
 
             m_SignalGen.m_AxonRadius = v1.second.get<double>("axonRadius", m_SignalGen.m_AxonRadius);
             switch (v1.second.get<int>("diffusiondirectionmode", 0))
             {
             case 0:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
                 break;
             case 1:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
                 break;
             case 2:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
                 break;
             default:
                 m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
             }
             m_SignalGen.m_FiberSeparationThreshold = v1.second.get<double>("fiberseparationthreshold", m_SignalGen.m_FiberSeparationThreshold);
             m_SignalGen.m_Spikes = v1.second.get<unsigned int>("artifacts.spikesnum", m_SignalGen.m_Spikes);
             m_SignalGen.m_SpikeAmplitude = v1.second.get<double>("artifacts.spikesscale", m_SignalGen.m_SpikeAmplitude);
             m_SignalGen.m_KspaceLineOffset = v1.second.get<double>("artifacts.kspaceLineOffset", m_SignalGen.m_KspaceLineOffset);
             m_SignalGen.m_EddyStrength = v1.second.get<double>("artifacts.eddyStrength", m_SignalGen.m_EddyStrength);
             m_SignalGen.m_Tau = v1.second.get<double>("artifacts.eddyTau", m_SignalGen.m_Tau);
             m_SignalGen.m_CroppingFactor = v1.second.get<double>("artifacts.aliasingfactor", m_SignalGen.m_CroppingFactor);
             m_SignalGen.m_DoAddGibbsRinging = v1.second.get<bool>("artifacts.addringing", m_SignalGen.m_DoAddGibbsRinging);
             m_SignalGen.m_DoSimulateRelaxation = v1.second.get<bool>("doSimulateRelaxation", m_SignalGen.m_DoSimulateRelaxation);
             m_SignalGen.m_DoDisablePartialVolume = v1.second.get<bool>("doDisablePartialVolume", m_SignalGen.m_DoDisablePartialVolume);
             m_SignalGen.m_DoAddMotion = v1.second.get<bool>("artifacts.doAddMotion", m_SignalGen.m_DoAddMotion);
             m_SignalGen.m_DoRandomizeMotion = v1.second.get<bool>("artifacts.randomMotion", m_SignalGen.m_DoRandomizeMotion);
             m_SignalGen.m_Translation[0] = v1.second.get<double>("artifacts.translation0", m_SignalGen.m_Translation[0]);
             m_SignalGen.m_Translation[1] = v1.second.get<double>("artifacts.translation1", m_SignalGen.m_Translation[1]);
             m_SignalGen.m_Translation[2] = v1.second.get<double>("artifacts.translation2", m_SignalGen.m_Translation[2]);
             m_SignalGen.m_Rotation[0] = v1.second.get<double>("artifacts.rotation0", m_SignalGen.m_Rotation[0]);
             m_SignalGen.m_Rotation[1] = v1.second.get<double>("artifacts.rotation1", m_SignalGen.m_Rotation[1]);
             m_SignalGen.m_Rotation[2] = v1.second.get<double>("artifacts.rotation2", m_SignalGen.m_Rotation[2]);
-            m_SignalGen.SetNumWeightedVolumes(v1.second.get<unsigned int>("numgradients", m_SignalGen.GetNumWeightedVolumes()));
+//            m_SignalGen.SetNumWeightedVolumes(v1.second.get<unsigned int>("numgradients", m_SignalGen.GetNumWeightedVolumes()));
+            SignalGenerationParameters::GradientListType gradients;
+            BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("gradients") )
+            {
+                SignalGenerationParameters::GradientType g;
+                g[0] = v2.second.get<double>("x");
+                g[1] = v2.second.get<double>("y");
+                g[2] = v2.second.get<double>("z");
+                gradients.push_back(g);
+            }
+            m_SignalGen.SetGradienDirections(gradients);
 
             try
             {
                 if (v1.second.get<string>("artifacts.noisetype")=="rice")
                 {
                     m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                     m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
                 }
             }
             catch(...) {}
             try
             {
                 if (v1.second.get<string>("artifacts.noisetype")=="chisquare")
                 {
                     m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
                     m_NoiseModel->SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
                 }
             }
             catch(...){ }
 
-
             BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second.get_child("compartments") )
             {
                 mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
                 try // stick model
                 {
                     mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("stick.d"));
                     model->SetT2(v2.second.get<double>("stick.t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
                 try // tensor model
                 {
                     mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
                     model->SetDiffusivity1(v2.second.get<double>("tensor.d1"));
                     model->SetDiffusivity2(v2.second.get<double>("tensor.d2"));
                     model->SetDiffusivity3(v2.second.get<double>("tensor.d3"));
                     model->SetT2(v2.second.get<double>("tensor.t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
                 try // ball model
                 {
                     mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("ball.d"));
                     model->SetT2(v2.second.get<double>("ball.t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
                 try // astrosticks model
                 {
                     mitk::AstroStickModel<ScalarType>* model = new AstroStickModel<ScalarType>();
                     model->SetDiffusivity(v2.second.get<double>("astrosticks.d"));
                     model->SetT2(v2.second.get<double>("astrosticks.t2"));
                     model->SetRandomizeSticks(v2.second.get<bool>("astrosticks.randomize"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
                 try // dot model
                 {
                     mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
                     model->SetT2(v2.second.get<double>("dot.t2"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
                 try // prototype model
                 {
                     mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
                     model->SetMaxNumKernels(v2.second.get<unsigned int>("prototype.numSamples"));
                     model->SetFaRange(v2.second.get<double>("prototype.minFA"), v2.second.get<double>("prototype.maxFA"));
                     model->SetAdcRange(v2.second.get<double>("prototype.minADC"), v2.second.get<double>("prototype.maxADC"));
                     model->m_CompartmentId = v2.second.get<unsigned int>("ID");
                     if (v2.second.get<string>("type")=="fiber")
                         m_FiberModelList.push_back(model);
                     else if (v2.second.get<string>("type")=="non-fiber")
                         m_NonFiberModelList.push_back(model);
                     signalModel = model;
                 }
                 catch (...) { }
 
-//                if (signalModel!=NULL)
-//                {
-//                    try{
-//                        itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
-//                        reader->SetFileName(filename+"_VOLUME"+v2.second.get<string>("ID")+".nrrd");
-//                        reader->Update();
-//                        signalModel->SetVolumeFractionImage(reader->GetOutput());
-//                    }
-//                    catch(...)
-//                    {
-//                    }
-//                }
+                if (signalModel!=NULL)
+                {
+                    signalModel->SetGradientList(gradients);
+                    try{
+                        itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
+                        reader->SetFileName(filename+"_VOLUME"+v2.second.get<string>("ID")+".nrrd");
+                        reader->Update();
+                        signalModel->SetVolumeFractionImage(reader->GetOutput());
+                    }
+                    catch(...)
+                    {
+                    }
+                }
             }
         }
     }
 
-//    if (m_SignalGen.m_DoAddDistortions)
-//    {
-//        try{
-//            itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
-//            reader->SetFileName(filename+"_FMAP.nrrd");
-//            reader->Update();
-//            m_SignalGen.m_FrequencyMap = reader->GetOutput();
-//        }
-//        catch(...)
-//        {
-//            MITK_INFO << "No frequency map saved.";
-//        }
-//    }
-
-//    try{
-//        itk::ImageFileReader<ItkUcharImgType>::Pointer reader = itk::ImageFileReader<ItkUcharImgType>::New();
-//        reader->SetFileName(filename+"_MASK.nrrd");
-//        reader->Update();
-//        m_SignalGen.m_MaskImage = reader->GetOutput();
-//    }
-//    catch(...)
-//    {
-//        MITK_INFO << "No mask image saved.";
-//    }
+    try{
+        itk::ImageFileReader<ItkDoubleImgType>::Pointer reader = itk::ImageFileReader<ItkDoubleImgType>::New();
+        reader->SetFileName(filename+"_FMAP.nrrd");
+        reader->Update();
+        m_SignalGen.m_FrequencyMap = reader->GetOutput();
+    }
+    catch(...)
+    {
+        MITK_INFO << "No frequency map saved.";
+    }
+
+    try{
+        itk::ImageFileReader<ItkUcharImgType>::Pointer reader = itk::ImageFileReader<ItkUcharImgType>::New();
+        reader->SetFileName(filename+"_MASK.nrrd");
+        reader->Update();
+        m_SignalGen.m_MaskImage = reader->GetOutput();
+    }
+    catch(...)
+    {
+        MITK_INFO << "No mask image saved.";
+    }
 }
 
 template< class ScalarType >
 void mitk::FiberfoxParameters< ScalarType >::PrintSelf()
 {
     MITK_INFO << "Not implemented :(";
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
index 9de94d3c33..4e43573b4b 100644
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/mitkFiberfoxParameters.h
@@ -1,321 +1,321 @@
 /*===================================================================
 
 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 <mitkDiffusionImage.h>
 #include <mitkPlanarEllipse.h>
 
 #include <mitkStickModel.h>
 #include <mitkTensorModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkBallModel.h>
 #include <mitkDotModel.h>
 #include <mitkRawShModel.h>
 
 using namespace std;
 
 namespace mitk {
 
 /** Signal generation */
-class SignalGenerationParameters
+class MitkFiberTracking_EXPORT SignalGenerationParameters
 {
 public:
     typedef itk::Image<double, 3>                   ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>            ItkUcharImgType;
     typedef itk::Vector<double,3>                   GradientType;
     typedef std::vector<GradientType>               GradientListType;
 
     enum DiffusionDirectionMode {
         FIBER_TANGENT_DIRECTIONS,
         MAIN_FIBER_DIRECTIONS,
         RANDOM_DIRECTIONS
     };
 
     SignalGenerationParameters()
         : m_FrequencyMap(NULL)
         , m_MaskImage(NULL)
         , m_SignalScale(100)
         , m_tEcho(100)
         , m_tLine(1)
         , m_tInhom(50)
         , m_Bvalue(1000)
         , m_SimulateKspaceAcquisition(false)
         , m_AxonRadius(0)
         , m_DiffusionDirectionMode(SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS)
         , m_FiberSeparationThreshold(30)
         , m_Spikes(0)
         , m_SpikeAmplitude(1)
         , m_KspaceLineOffset(0)
         , m_EddyStrength(0)
         , m_Tau(70)
         , m_CroppingFactor(1)
         , m_DoAddGibbsRinging(false)
         , m_DoSimulateRelaxation(true)
         , m_DoDisablePartialVolume(false)
         , m_DoAddMotion(false)
         , m_DoRandomizeMotion(true)
     {
         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_ImageRegion;              ///< Image size.
     itk::Vector<double,3>               m_ImageSpacing;             ///< Image voxel size.
     itk::Point<double,3>                m_ImageOrigin;              ///< Image origin.
     itk::Matrix<double, 3, 3>           m_ImageDirection;           ///< Image rotation matrix.
 
     /** Other acquisitions parameters */
     double                              m_SignalScale;              ///< Scaling factor for output signal (before noise is added).
     double                              m_tEcho;                    ///< Echo time TE.
     double                              m_tLine;                    ///< k-space line readout time.
     double                              m_tInhom;                   ///< T2'
     double                              m_Bvalue;                   ///< Acquisition b-value
     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.
     DiffusionDirectionMode              m_DiffusionDirectionMode;   ///< Determines how the main diffusion direction of the signal models is selected
     double                              m_FiberSeparationThreshold; ///< Used for random and and mein fiber deriction DiffusionDirectionMode
 
     /** Artifacts and other effects */
     unsigned int                        m_Spikes;                   ///< Number of spikes randomly appearing in the image
     double                              m_SpikeAmplitude;           ///< amplitude of spikes relative to the largest signal intensity (magnitude of complex)
     double                              m_KspaceLineOffset;         ///< Causes N/2 ghosts. Larger offset means stronger ghost.
     double                              m_EddyStrength;             ///< Strength of eddy current induced gradients in mT/m.
     double                              m_Tau;                      ///< Eddy current decay constant (in ms)
     double                              m_CroppingFactor;           ///< FOV size in y-direction is multiplied by this factor. Causes aliasing artifacts.
     bool                                m_DoAddGibbsRinging;        ///< Add Gibbs ringing artifact
     bool                                m_DoSimulateRelaxation;     ///< Add T2 relaxation effects
     bool                                m_DoAddMotion;              ///< Enable motion artifacts.
     bool                                m_DoRandomizeMotion;        ///< Toggles between random and linear motion.
     itk::Vector<double,3>               m_Translation;              ///< Maximum translational motion.
     itk::Vector<double,3>               m_Rotation;                 ///< Maximum rotational motion.
     ItkDoubleImgType::Pointer           m_FrequencyMap;             ///< If != NULL, distortions are added to the image using this frequency map.
     ItkUcharImgType::Pointer            m_MaskImage;                ///< Signal is only genrated inside of the mask image.
 
     inline void GenerateGradientHalfShell();                        ///< Generates half shell of gradient directions (with m_NumGradients non-zero directions)
     inline std::vector< int > GetBaselineIndices();                 ///< Returns list of nun-diffusion-weighted image volume indices
     inline unsigned int GetFirstBaselineIndex();                    ///< Returns index of first non-diffusion-weighted image volume
     inline bool IsBaselineIndex(unsigned int idx);                  ///< Checks if image volume with given index is non-diffusion-weighted volume or not.
     inline unsigned int GetNumWeightedVolumes();                    ///< Get number of diffusion-weighted image volumes
     inline unsigned int GetNumBaselineVolumes();                    ///< Get number of non-diffusion-weighted image volumes
     inline unsigned int GetNumVolumes();                            ///< Get number of baseline and diffusion-weighted image volumes
     inline GradientListType GetGradientDirections();                ///< Return gradient direction container
     inline GradientType GetGradientDirection(unsigned int i);
 
     inline void SetNumWeightedVolumes(int numGradients);            ///< Automaticall calls GenerateGradientHalfShell() afterwards.
     inline void SetGradienDirections(GradientListType gradientList);
     inline void SetGradienDirections(mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer gradientList);
 
 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.
 };
 
 /** Fiber generation */
-class FiberGenerationParameters
+class MitkFiberTracking_EXPORT FiberGenerationParameters
 {
 public:
 
     enum FiberDistribution{
         DISTRIBUTE_UNIFORM, // distribute fibers uniformly in the ROIs
         DISTRIBUTE_GAUSSIAN // distribute fibers using a 2D gaussian
     };
 
     typedef vector< vector< mitk::PlanarEllipse::Pointer > >    FiducialListType;
     typedef vector< 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 MiscFiberfoxParameters
+class MitkFiberTracking_EXPORT MiscFiberfoxParameters
 {
 public:
     MiscFiberfoxParameters()
         : m_ResultNode(DataNode::New())
         , m_ParentNode(NULL)
         , m_SignalModelString("")
         , m_ArtifactModelString("")
         , m_OutputPath("")
         , m_CheckOutputVolumeFractionsBox(false)
         , m_CheckAdvancedSignalOptionsBox(false)
         , m_CheckAddNoiseBox(false)
         , m_CheckAddGhostsBox(false)
         , m_CheckAddAliasingBox(false)
         , m_CheckAddSpikesBox(false)
         , m_CheckAddEddyCurrentsBox(false)
         , m_CheckAddDistortionsBox(false)
         , 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.
     string              m_SignalModelString;                ///< Appendet to the name of the result node
     string              m_ArtifactModelString;              ///< Appendet to the name of the result node
     string              m_OutputPath;                       ///< Image is automatically saved to the specified folder after simulation is finished.
 
     /** member variables that store the check-state of GUI checkboxes */
     // image generation
     bool                m_CheckOutputVolumeFractionsBox;
     bool                m_CheckAdvancedSignalOptionsBox;
     bool                m_CheckAddNoiseBox;
     bool                m_CheckAddGhostsBox;
     bool                m_CheckAddAliasingBox;
     bool                m_CheckAddSpikesBox;
     bool                m_CheckAddEddyCurrentsBox;
     bool                m_CheckAddDistortionsBox;
     // fiber generation
     bool                m_CheckRealTimeFibersBox;
     bool                m_CheckAdvancedFiberOptionsBox;
     bool                m_CheckConstantRadiusBox;
     bool                m_CheckIncludeFiducialsBox;
 };
 
 /**
   * \brief Datastructure to manage the Fiberfox signal generation parameters.
   *
   */
 template< class ScalarType = double >
-class FiberfoxParameters
+class MitkFiberTracking_EXPORT FiberfoxParameters
 {
 public:
 
     typedef itk::Image<double, 3>                           ItkDoubleImgType;
     typedef itk::Image<unsigned char, 3>                    ItkUcharImgType;
     typedef DiffusionSignalModel<ScalarType>                DiffusionModelType;
     typedef std::vector< DiffusionModelType* >              DiffusionModelListType;
     typedef DiffusionNoiseModel<ScalarType>                 NoiseModelType;
 
     FiberfoxParameters();
     ~FiberfoxParameters();
 
     /** Get same parameter object with different template parameter */
     template< class OutType >
     FiberfoxParameters< OutType > CopyParameters()
     {
         FiberfoxParameters< OutType > out;
 
         out.m_FiberGen = m_FiberGen;
         out.m_SignalGen = m_SignalGen;
         out.m_Misc = m_Misc;
 
         if (m_NoiseModel!=NULL)
         {
             if (dynamic_cast<mitk::RicianNoiseModel<ScalarType>*>(m_NoiseModel))
                 out.m_NoiseModel = new mitk::RicianNoiseModel<OutType>();
             else if (dynamic_cast<mitk::ChiSquareNoiseModel<ScalarType>*>(m_NoiseModel))
                 out.m_NoiseModel = new mitk::ChiSquareNoiseModel<OutType>();
             out.m_NoiseModel->SetNoiseVariance(m_NoiseModel->GetNoiseVariance());
         }
 
         for (unsigned int i=0; i<m_FiberModelList.size()+m_NonFiberModelList.size(); i++)
         {
             mitk::DiffusionSignalModel<OutType>* outModel = NULL;
             mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
             if (i<m_FiberModelList.size())
                 signalModel = m_FiberModelList.at(i);
             else
                 signalModel = m_NonFiberModelList.at(i-m_FiberModelList.size());
 
             if (dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel))
                 outModel = new mitk::StickModel<OutType>(dynamic_cast<mitk::StickModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel))
                 outModel = new mitk::TensorModel<OutType>(dynamic_cast<mitk::TensorModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel))
                 outModel = new mitk::RawShModel<OutType>(dynamic_cast<mitk::RawShModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel))
                 outModel = new mitk::BallModel<OutType>(dynamic_cast<mitk::BallModel<ScalarType>*>(signalModel));
             else if (dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel))
                 outModel = new mitk::AstroStickModel<OutType>(dynamic_cast<mitk::AstroStickModel<ScalarType>*>(signalModel));
             else  if (dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel))
                 outModel = new mitk::DotModel<OutType>(dynamic_cast<mitk::DotModel<ScalarType>*>(signalModel));
 
             if (i<m_FiberModelList.size())
                 out.m_FiberModelList.push_back(outModel);
             else
                 out.m_NonFiberModelList.push_back(outModel);
         }
 
         return out;
     }
 
     /** 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.
     NoiseModelType*                     m_NoiseModel;           ///< If != NULL, noise is added to the image.
 
     void PrintSelf();                           ///< Print parameters to stdout.
     void SaveParameters(string filename);       ///< Save image generation parameters to .ffp file.
     void LoadParameters(string filename);       ///< Load image generation parameters from .ffp file.
 };
 }
 
 #include "mitkFiberfoxParameters.cpp"
 
 #endif
 
diff --git a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
index 1736ff16c3..bb81ed43bc 100644
--- a/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
+++ b/Modules/DiffusionImaging/FiberTracking/SignalModels/mitkRawShModel.h
@@ -1,103 +1,106 @@
 /*===================================================================
 
 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_RawShModel_H
 #define _MITK_RawShModel_H
 
 #include <mitkDiffusionSignalModel.h>
 
 namespace mitk {
 
 /**
   * \brief The spherical harmonic representation of a prototype diffusion weighted MR signal is used to obtain the direction dependent signal.
   *
   */
 
 template< class ScalarType = double >
 class RawShModel : public DiffusionSignalModel< ScalarType >
 {
 public:
 
     RawShModel();
     template< class OtherType >RawShModel(RawShModel<OtherType>* model)
     {
         this->m_CompartmentId = model->m_CompartmentId;
         this->m_T2 = model->GetT2();
         this->m_FiberDirection = model->GetFiberDirection();
         this->m_GradientList = model->GetGradientList();
         this->m_VolumeFractionImage = model->GetVolumeFractionImage();
         this->m_RandGen = model->GetRandomGenerator();
 
         this->m_AdcRange = model->GetAdcRange();
         this->m_FaRange = model->GetFaRange();
         this->m_ShCoefficients = model->GetShCoefficients();
         this->m_B0Signal = model->GetB0Signals();
         this->m_SphCoords = model->GetSphericalCoordinates();
         this->m_ShOrder = model->GetShOrder();
         this->m_ModelIndex = model->GetModelIndex();
         this->m_MaxNumKernels = model->GetMaxNumKernels();
     }
     ~RawShModel();
 
     typedef typename DiffusionSignalModel< ScalarType >::PixelType          PixelType;
     typedef typename DiffusionSignalModel< ScalarType >::GradientType       GradientType;
     typedef typename DiffusionSignalModel< ScalarType >::GradientListType   GradientListType;
     typedef itk::Matrix< double, 3, 3 >                                     MatrixType;
 
     /** Actual signal generation **/
     PixelType SimulateMeasurement();
     ScalarType SimulateMeasurement(unsigned int dir);
 
     bool SetShCoefficients(vnl_vector< double > shCoefficients, double b0);
     void SetFiberDirection(GradientType fiberDirection);
     void SetGradientList(GradientListType gradientList) { this->m_GradientList = gradientList; }
     void SetFaRange(double min, double max){ m_FaRange.first = min; m_FaRange.second = max; }
     void SetAdcRange(double min, double max){ m_AdcRange.first = min; m_AdcRange.second = max; }
     void SetMaxNumKernels(unsigned int max){ m_MaxNumKernels = max; }
     unsigned int GetNumberOfKernels();
     std::pair< double, double > GetFaRange(){ return m_FaRange; }
     std::pair< double, double > GetAdcRange(){ return m_AdcRange; }
     unsigned int GetMaxNumKernels(){ return m_MaxNumKernels; }
     void Clear();
     std::vector< GradientType >         m_PrototypeMaxDirection;
 
     std::vector< vnl_vector< double > > GetShCoefficients(){ return m_ShCoefficients; }
     std::vector< double > GetB0Signals(){ return m_B0Signal; }
     vnl_matrix<double> GetSphericalCoordinates(){ return m_SphCoords; }
     unsigned int GetShOrder(){ return m_ShOrder; }
     int GetModelIndex(){ return m_ModelIndex; }
 
+    double GetBaselineSignal(int index){ return m_B0Signal.at(index); }
+    vnl_vector< double > GetCoefficients(int index){ return m_ShCoefficients.at(index); }
+
 protected:
 
     void Cart2Sph( GradientListType gradients );
     void RandomModel();
 
     std::pair< double, double >         m_AdcRange;
     std::pair< double, double >         m_FaRange;
     std::vector< vnl_vector< double > > m_ShCoefficients;
     std::vector< double >               m_B0Signal;
     vnl_matrix<double>                  m_SphCoords;
     unsigned int                        m_ShOrder;
     int                                 m_ModelIndex;
     unsigned int                        m_MaxNumKernels;
 };
 
 }
 
 #include "mitkRawShModel.cpp"
 
 #endif
 
diff --git a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
index 0959ccab4e..5f79886390 100755
--- a/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
+++ b/Modules/DiffusionImaging/MiniApps/CMakeLists.txt
@@ -1,64 +1,64 @@
 option(BUILD_DiffusionMiniApps "Build commandline tools for diffusion" OFF)
 
 if(BUILD_DiffusionMiniApps OR MITK_BUILD_ALL_APPS)
 
   # needed include directories
   include_directories(
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_BINARY_DIR}
     )
 
   project( MitkDiffusionMiniApps )
 
   # fill in the standalone executables here
   set(DIFFUSIONMINIAPPS
     mitkDiffusionMiniApps
   )
 
   # set additional files here
   set(DIFFUSIONCORE_ADDITIONAL_FILES
     MiniAppManager.cpp
     FileFormatConverter.cpp
     TensorReconstruction.cpp
     QballReconstruction.cpp
     DiffusionIndices.cpp
     CopyGeometry.cpp
     GibbsTracking.cpp
     StreamlineTracking.cpp
     FiberProcessing.cpp
     LocalDirectionalFiberPlausibility.cpp
     #TractogramAngularError.cpp
     FiberDirectionExtraction.cpp
     PeakExtraction.cpp
     PeaksAngularError.cpp
     MultishellMethods.cpp
-    #FiberFoxProcessing.cpp
+    Fiberfox.cpp
     ExportShImage.cpp
     NetworkCreation.cpp
     NetworkStatistics.cpp
     DwiDenoising.cpp
   )
 
   # deprecated
 #  FOREACH(tool ${DIFFUSIONMINIAPPS})
 #    ADD_EXECUTABLE(
 #    ${tool}
 #    ${tool}.cpp
 #    ${DIFFUSIONCORE_ADDITIONAL_FILES}
 #    )
 
 #    TARGET_LINK_LIBRARIES(
 #      ${tool}
 #      ${ALL_LIBRARIES} )
 #  ENDFOREACH(tool)
 
   mitk_create_executable(DiffusionMiniApps
     DEPENDS MitkDiffusionCore MitkFiberTracking MitkConnectomics
     PACKAGE_DEPENDS ITK|ITKDiffusionTensorImage
   )
 
   if(EXECUTABLE_IS_ENABLED)
     MITK_INSTALL_TARGETS(EXECUTABLES ${EXECUTABLE_TARGET})
   endif()
 
 endif()
diff --git a/Modules/DiffusionImaging/MiniApps/FiberFoxProcessing.cpp b/Modules/DiffusionImaging/MiniApps/FiberFoxProcessing.cpp
deleted file mode 100755
index 695addd8b4..0000000000
--- a/Modules/DiffusionImaging/MiniApps/FiberFoxProcessing.cpp
+++ /dev/null
@@ -1,545 +0,0 @@
-/*===================================================================
-
-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 "MiniAppManager.h"
-#include <mitkImageCast.h>
-#include <mitkDiffusionImage.h>
-#include <mitkBaseDataIOFactory.h>
-#include <mitkFiberTrackingObjectFactory.h>
-#include <mitkIOUtil.h>
-#include <mitkNrrdDiffusionImageWriter.h>
-#include <mitkFiberBundleX.h>
-//#include "ctkCommandLineParser.h"
-#include "ctkCommandLineParser.h"
-#include <mitkRicianNoiseModel.h>
-
-#include <itkAddArtifactsToDwiImageFilter.h>
-#include <itkTractsToDWIImageFilter.h>
-
-#include "boost/property_tree/ptree.hpp"
-#include "boost/property_tree/xml_parser.hpp"
-#include "boost/foreach.hpp"
-#include <mitkStickModel.h>
-#include <mitkTensorModel.h>
-#include <mitkAstroStickModel.h>
-#include <mitkBallModel.h>
-#include <mitkDotModel.h>
-
-using namespace mitk;
-
-struct ImageParameters {
-  itk::ImageRegion<3>                 imageRegion;
-  itk::Vector<double,3>               imageSpacing;
-  itk::Point<double,3>                imageOrigin;
-  itk::Matrix<double, 3, 3>           imageDirection;
-  unsigned int                        numGradients;
-  double                              b_value;
-  unsigned int                        repetitions;
-  double                              signalScale;
-  double                              tEcho;
-  double                              tLine;
-  double                              tInhom;
-  double                              axonRadius;
-  unsigned int                        interpolationShrink;
-  double                              kspaceLineOffset;
-  double                              upsampling;
-  double                              eddyStrength;
-  double                              comp3Weight;
-  double                              comp4Weight;
-  int                                 spikes;
-  double                              spikeAmplitude;
-
-  bool                                doSimulateRelaxation;
-  bool                                doSimulateEddyCurrents;
-  bool                                doDisablePartialVolume;
-
-  mitk::RicianNoiseModel<double>       ricianNoiseModel;
-  mitk::DiffusionSignalModel<double>::GradientListType  gradientDirections;
-  itk::TractsToDWIImageFilter< short >::DiffusionModelListType fiberModelList, nonFiberModelList;
-  std::string signalModelString, artifactModelString;
-
-  itk::Image<double, 3>::Pointer           frequencyMap;
-  itk::Image<unsigned char, 3>::Pointer    tissueMaskImage;
-
-  mitk::DataNode::Pointer             resultNode;
-};
-
-
-
-void LoadParameters(const std::string & filename,
-                    ImageParameters  & m_ImageGenParameters,
-                    mitk::Image::Pointer m_fImage,
-                    mitk::Image::Pointer m_maskImage,
-                    mitk::StickModel<double> * m_StickModel1,
-                    mitk::StickModel<double> * m_StickModel2,
-                    mitk::TensorModel<double> * m_ZeppelinModel1,
-                    mitk::TensorModel<double> * m_ZeppelinModel2,
-                    mitk::TensorModel<double> * m_TensorModel1,
-                    mitk::TensorModel<double> * m_TensorModel2,
-
-                    // extra axonal compartment models
-                    mitk::BallModel<double> * m_BallModel1,
-                    mitk::BallModel<double> * m_BallModel2,
-                    mitk::AstroStickModel<double> * m_AstrosticksModel1,
-                    mitk::AstroStickModel<double> * m_AstrosticksModel2,
-                    mitk::DotModel<double> * m_DotModel1,
-                    mitk::DotModel<double> * m_DotModel2)
-{
-
-
-
-  MITK_INFO << "Initialize Diffusion Models";
-
-  boost::property_tree::ptree parameters;
-  boost::property_tree::xml_parser::read_xml(filename, parameters);
-
-  m_ImageGenParameters.nonFiberModelList.clear();
-  m_ImageGenParameters.fiberModelList.clear();
-  m_ImageGenParameters.signalModelString = "";
-  m_ImageGenParameters.artifactModelString = "";
-  m_ImageGenParameters.resultNode = mitk::DataNode::New();
-  //m_ImageGenParameters.tissueMaskImage = NULL;
-  //m_ImageGenParameters.frequencyMap = NULL;
-  //m_ImageGenParameters.gradientDirections.clear();
-  m_ImageGenParameters.spikes = 0;
-  m_ImageGenParameters.spikeAmplitude = 1;
-
-  MITK_INFO << "reset params";
-
-  BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameters.get_child("fiberfox") )
-  {
-    if( v1.first == "image" )
-    {
-      MITK_INFO << "Load image params";
-      m_ImageGenParameters.tEcho = v1.second.get<double>("tEcho");
-      m_ImageGenParameters.tLine = v1.second.get<double>("tLine");
-
-      m_ImageGenParameters.doSimulateEddyCurrents = v1.second.get<bool>("artifacts.addeddy");
-      m_ImageGenParameters.eddyStrength = 0;
-      if (m_ImageGenParameters.doSimulateEddyCurrents)
-      {
-        m_ImageGenParameters.eddyStrength = v1.second.get<double>("artifacts.eddyStrength");
-      }
-
-      // signal relaxation
-      m_ImageGenParameters.doSimulateRelaxation = v1.second.get<bool>("doSimulateRelaxation");
-      if (m_ImageGenParameters.doSimulateRelaxation)
-
-        // N/2 ghosts
-        if (v1.second.get<bool>("artifacts.addghost"))
-        {
-          m_ImageGenParameters.kspaceLineOffset = v1.second.get<double>("artifacts.kspaceLineOffset");
-        }
-        else
-        {
-          m_ImageGenParameters.kspaceLineOffset = 0;
-        }
-
-      if (v1.second.get<bool>("artifacts.addspikes"))
-      {
-        m_ImageGenParameters.spikes = v1.second.get<int>("artifacts.spikesnum");
-        m_ImageGenParameters.spikeAmplitude = v1.second.get<double>("artifacts.spikesscale");
-      }
-
-
-      // add distortions
-      if (v1.second.get<bool>("artifacts.distortions") && m_fImage)
-      {
-        itk::Image<double,3>::Pointer itkImg = itk::Image<double,3>::New();
-        mitk::CastToItkImage< itk::Image<double,3> >(m_fImage, itkImg);
-
-        if (m_ImageGenParameters.imageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
-            m_ImageGenParameters.imageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
-            m_ImageGenParameters.imageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
-        {
-          m_ImageGenParameters.frequencyMap = itkImg;
-        }
-      }
-
-      // rician noise
-      if (v1.second.get<bool>("artifacts.addnoise"))
-        m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(v1.second.get<double>("artifacts.noisevariance"));
-      else
-        m_ImageGenParameters.ricianNoiseModel.SetNoiseVariance(0);
-
-      // gibbs ringing
-      m_ImageGenParameters.upsampling = 1;
-      if (v1.second.get<bool>("artifacts.addringing"))
-        m_ImageGenParameters.upsampling = v1.second.get<double>("artifacts.ringingupsampling");
-
-      // adjusting line readout time to the adapted image size needed for the DFT
-      int y = m_ImageGenParameters.imageRegion.GetSize(1);
-      if ( y%2 == 1 )
-        y += 1;
-      if ( y>m_ImageGenParameters.imageRegion.GetSize(1) )
-        m_ImageGenParameters.tLine *= (double)m_ImageGenParameters.imageRegion.GetSize(1)/y;
-
-
-      // check tissue mask
-      if (m_maskImage.IsNotNull())
-      {
-        m_ImageGenParameters.tissueMaskImage = itk::Image<unsigned char,3>::New();
-        mitk::CastToItkImage<itk::Image<unsigned char,3> >(m_maskImage.GetPointer(), m_ImageGenParameters.tissueMaskImage);
-      }
-
-      // signal models
-      m_ImageGenParameters.comp3Weight = 1;
-      m_ImageGenParameters.comp4Weight = 0;
-      if (v1.second.get<int>("compartment4.index") > 0)
-      {
-        m_ImageGenParameters.comp4Weight = v1.second.get<double>("compartment4.weight");
-        m_ImageGenParameters.comp3Weight -= m_ImageGenParameters.comp4Weight;
-      }
-
-
-
-      // compartment 1
-      switch(v1.second.get<int>("compartment1.index")){
-      case 0:
-        m_StickModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_StickModel1->SetBvalue(m_ImageGenParameters.b_value);
-        m_StickModel1->SetDiffusivity(v1.second.get<double>("compartment1.stick.d"));
-        m_StickModel1->SetT2(v1.second.get<double>("compartment1.stick.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_StickModel1);
-        break;
-      case 1:
-        m_ZeppelinModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_ZeppelinModel1->SetBvalue(m_ImageGenParameters.b_value);
-        m_ZeppelinModel1->SetDiffusivity1(v1.second.get<double>("compartment1.zeppelin.d1"));
-        m_ZeppelinModel1->SetDiffusivity2(v1.second.get<double>("compartment1.zeppelin.d2"));
-        m_ZeppelinModel1->SetDiffusivity3(v1.second.get<double>("compartment1.zeppelin.d2"));
-        m_ZeppelinModel1->SetT2(v1.second.get<double>("compartment1.zeppelin.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_ZeppelinModel1);
-        break;
-      case 2:
-        m_TensorModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_TensorModel1->SetBvalue(m_ImageGenParameters.b_value);
-        m_TensorModel1->SetDiffusivity1(v1.second.get<double>("compartment1.tensor.d1"));
-        m_TensorModel1->SetDiffusivity2(v1.second.get<double>("compartment1.tensor.d2"));
-        m_TensorModel1->SetDiffusivity3(v1.second.get<double>("compartment1.tensor.d3"));
-        m_TensorModel1->SetT2(v1.second.get<double>("compartment1.tensor.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_TensorModel1);
-        break;
-      }
-
-      // compartment 2
-      switch(v1.second.get<int>("compartment2.index")){
-      case 0:
-        m_StickModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_StickModel2->SetBvalue(m_ImageGenParameters.b_value);
-        m_StickModel2->SetDiffusivity(v1.second.get<double>("compartment2.stick.d"));
-        m_StickModel2->SetT2(v1.second.get<double>("compartment2.stick.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_StickModel2);
-        break;
-      case 1:
-        m_ZeppelinModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_ZeppelinModel2->SetBvalue(m_ImageGenParameters.b_value);
-        m_ZeppelinModel2->SetDiffusivity1(v1.second.get<double>("compartment2.zeppelin.d1"));
-        m_ZeppelinModel2->SetDiffusivity2(v1.second.get<double>("compartment2.zeppelin.d2"));
-        m_ZeppelinModel2->SetDiffusivity3(v1.second.get<double>("compartment2.zeppelin.d2"));
-        m_ZeppelinModel2->SetT2(v1.second.get<double>("compartment2.zeppelin.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_ZeppelinModel2);
-        break;
-      case 2:
-        m_TensorModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_TensorModel2->SetBvalue(m_ImageGenParameters.b_value);
-        m_TensorModel2->SetDiffusivity1(v1.second.get<double>("compartment2.tensor.d1"));
-        m_TensorModel2->SetDiffusivity2(v1.second.get<double>("compartment2.tensor.d2"));
-        m_TensorModel2->SetDiffusivity3(v1.second.get<double>("compartment2.tensor.d3"));
-        m_TensorModel2->SetT2(v1.second.get<double>("compartment2.tensor.t2"));
-        m_ImageGenParameters.fiberModelList.push_back(m_TensorModel2);
-        break;
-      }
-
-      // compartment 3
-      switch(v1.second.get<int>("compartment3.index")){
-      case 0:
-        m_BallModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_BallModel1->SetBvalue(m_ImageGenParameters.b_value);
-        m_BallModel1->SetDiffusivity(v1.second.get<double>("compartment3.ball.d"));
-        m_BallModel1->SetT2(v1.second.get<double>("compartment3.ball.t2"));
-        m_BallModel1->SetWeight(m_ImageGenParameters.comp3Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_BallModel1);
-        break;
-      case 1:
-        m_AstrosticksModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_AstrosticksModel1->SetBvalue(m_ImageGenParameters.b_value);
-        m_AstrosticksModel1->SetDiffusivity(v1.second.get<double>("compartment3.astrosticks.d"));
-        m_AstrosticksModel1->SetT2(v1.second.get<double>("compartment3.astrosticks.t2"));
-        m_AstrosticksModel1->SetRandomizeSticks(v1.second.get<bool>("compartment3.astrosticks.randomize"));
-        m_AstrosticksModel1->SetWeight(m_ImageGenParameters.comp3Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_AstrosticksModel1);
-        break;
-      case 2:
-        m_DotModel1->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_DotModel1->SetT2(v1.second.get<double>("compartment3.dot.t2"));
-        m_DotModel1->SetWeight(m_ImageGenParameters.comp3Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_DotModel1);
-        break;
-      }
-
-      // compartment 4
-      switch(v1.second.get<int>("compartment4.index")){
-      case 0:
-        m_BallModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_BallModel2->SetBvalue(m_ImageGenParameters.b_value);
-        m_BallModel2->SetDiffusivity(v1.second.get<double>("compartment4.ball.d"));
-        m_BallModel2->SetT2(v1.second.get<double>("compartment4.ball.t2"));
-        m_BallModel2->SetWeight(m_ImageGenParameters.comp4Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_BallModel2);
-        break;
-      case 1:
-        m_AstrosticksModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_AstrosticksModel2->SetBvalue(m_ImageGenParameters.b_value);
-        m_AstrosticksModel2->SetDiffusivity(v1.second.get<double>("compartment4.astrosticks.d"));
-        m_AstrosticksModel2->SetT2(v1.second.get<double>("compartment4.astrosticks.t2"));
-        m_AstrosticksModel2->SetRandomizeSticks(v1.second.get<bool>("compartment4.astrosticks.randomize"));
-        m_AstrosticksModel2->SetWeight(m_ImageGenParameters.comp4Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_AstrosticksModel2);
-        break;
-      case 2:
-        m_DotModel2->SetGradientList(m_ImageGenParameters.gradientDirections);
-        m_DotModel2->SetT2(v1.second.get<double>("compartment4.dot.t2"));
-        m_DotModel2->SetWeight(m_ImageGenParameters.comp4Weight);
-        m_ImageGenParameters.nonFiberModelList.push_back(m_DotModel2);
-        break;
-      }
-
-      m_ImageGenParameters.signalScale = v1.second.get<int>("signalScale");
-      m_ImageGenParameters.repetitions = v1.second.get<int>("repetitions");
-
-      m_ImageGenParameters.tInhom = v1.second.get<double>("tInhom");
-
-      m_ImageGenParameters.doDisablePartialVolume = v1.second.get<bool>("doDisablePartialVolume");
-      m_ImageGenParameters.interpolationShrink = v1.second.get<int>("interpolationShrink");
-      m_ImageGenParameters.axonRadius = v1.second.get<double>("axonRadius");
-    }
-
-    /*
-m_Controls->m_VarianceBox->setValue(v1.second.get<double>("variance"));
-
-
-
-m_Controls->m_AdvancedOptionsBox->setChecked(v1.second.get<bool>("showadvanced"));
-m_Controls->m_AdvancedOptionsBox_2->setChecked(v1.second.get<bool>("showadvanced"));
-
-            m_Controls->m_VolumeFractionsBox->setChecked(v1.second.get<bool>("outputvolumefractions"));
-            m_Controls->m_RealTimeFibers->setChecked(v1.second.get<bool>("realtime"));
-
-            m_Controls->m_DistributionBox->setCurrentIndex(v1.second.get<int>("distribution"));
-
-            m_Controls->m_FiberDensityBox->setValue(v1.second.get<int>("density"));
-            m_Controls->m_IncludeFiducials->setChecked(v1.second.get<bool>("includeFiducials"));
-            m_Controls->m_ConstantRadiusBox->setChecked(v1.second.get<bool>("constantradius"));
-
-
-
-
-            BOOST_FOREACH( boost::property_tree::ptree::value_type const& v2, v1.second )
-            {
-                if( v2.first == "spline" )
-                {
-                    m_Controls->m_FiberSamplingBox->setValue(v2.second.get<double>("sampling"));
-                    m_Controls->m_TensionBox->setValue(v2.second.get<double>("tension"));
-                    m_Controls->m_ContinuityBox->setValue(v2.second.get<double>("continuity"));
-                    m_Controls->m_BiasBox->setValue(v2.second.get<double>("bias"));
-                }
-                if( v2.first == "rotation" )
-                {
-                    m_Controls->m_XrotBox->setValue(v2.second.get<double>("x"));
-                    m_Controls->m_YrotBox->setValue(v2.second.get<double>("y"));
-                    m_Controls->m_ZrotBox->setValue(v2.second.get<double>("z"));
-                }
-                if( v2.first == "translation" )
-                {
-                    m_Controls->m_XtransBox->setValue(v2.second.get<double>("x"));
-                    m_Controls->m_YtransBox->setValue(v2.second.get<double>("y"));
-                    m_Controls->m_ZtransBox->setValue(v2.second.get<double>("z"));
-                }
-                if( v2.first == "scale" )
-                {
-                    m_Controls->m_XscaleBox->setValue(v2.second.get<double>("x"));
-                    m_Controls->m_YscaleBox->setValue(v2.second.get<double>("y"));
-                    m_Controls->m_ZscaleBox->setValue(v2.second.get<double>("z"));
-                }
-            }
-        }
-        if( v1.first == "image" )
-        {
-            m_Controls->m_SizeX->setValue(v1.second.get<int>("basic.size.x"));
-            m_Controls->m_SizeY->setValue(v1.second.get<int>("basic.size.y"));
-            m_Controls->m_SizeZ->setValue(v1.second.get<int>("basic.size.z"));
-            m_Controls->m_SpacingX->setValue(v1.second.get<double>("basic.spacing.x"));
-            m_Controls->m_SpacingY->setValue(v1.second.get<double>("basic.spacing.y"));
-            m_Controls->m_SpacingZ->setValue(v1.second.get<double>("basic.spacing.z"));
-            m_Controls->m_NumGradientsBox->setValue(v1.second.get<int>("basic.numgradients"));
-            m_Controls->m_BvalueBox->setValue(v1.second.get<int>("basic.bvalue"));
-*/
-  }
-
-}
-
-
-int FiberFoxProcessing(int argc, char* argv[])
-{
-  ctkCommandLineParser parser;
-  parser.setArgumentPrefix("--", "-");
-  parser.addArgument("in", "i", ctkCommandLineParser::String, "input file", us::Any(), false);
-  parser.addArgument("out", "o", ctkCommandLineParser::String, "output file", us::Any(), false);
-  parser.addArgument("fiberbundle", "f", ctkCommandLineParser::String, "defined fiber bundle for signal generation", us::Any(), false);
-  parser.addArgument("loadparameters", "l", ctkCommandLineParser::String, "load fiber fox signal parameter file", us::Any(), false);
-
-
-  map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
-  if (parsedArgs.size()==0)
-    return EXIT_FAILURE;
-
-  // mandatory arguments
-  string inName = us::any_cast<string>(parsedArgs["in"]);
-  string outName = us::any_cast<string>(parsedArgs["out"]);
-  string fbName = us::any_cast<string>(parsedArgs["fiberbundle"]);
-  string paramName = us::any_cast<string>(parsedArgs["loadparameters"]);
-
-  {
-    RegisterFiberTrackingObjectFactory();
-
-    ImageParameters m_ImageGenParameters;
-    mitk::Image::Pointer m_maskImage = 0;
-    mitk::Image::Pointer m_fImage = 0;
-
-    MITK_INFO << "Loading " << inName;
-    const std::string s1="", s2="";
-    std::vector<BaseData::Pointer> infile = BaseDataIO::LoadBaseDataFromFile( inName, s1, s2, false );
-    mitk::BaseData::Pointer baseData = infile.at(0);
-
-    MITK_INFO << "Loading " << fbName;
-    std::vector<BaseData::Pointer> infile2 = BaseDataIO::LoadBaseDataFromFile( fbName, s1, s2, false );
-    mitk::BaseData::Pointer baseData2 = infile2.at(0);
-
-    DiffusionImage<short>::Pointer dwi;
-    FiberBundleX::Pointer fbi;
-
-    if ( dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer()) )
-      dwi = dynamic_cast<DiffusionImage<short>*>(baseData.GetPointer());
-    else
-      MITK_ERROR << "LOADING DWI FAILD: " << inName;
-
-    if ( dynamic_cast<FiberBundleX*>(baseData2.GetPointer()) )
-      fbi = dynamic_cast<FiberBundleX*>(baseData2.GetPointer());
-    else
-      MITK_ERROR << "LOADING FBI FAILD: " << fbName;
-
-
-
-    m_ImageGenParameters.imageRegion = dwi->GetVectorImage()->GetLargestPossibleRegion();
-    m_ImageGenParameters.imageSpacing = dwi->GetVectorImage()->GetSpacing();
-    m_ImageGenParameters.imageOrigin = dwi->GetVectorImage()->GetOrigin();
-    m_ImageGenParameters.imageDirection = dwi->GetVectorImage()->GetDirection();
-    m_ImageGenParameters.b_value = dwi->GetB_Value();
-    mitk::DiffusionImage<short>::GradientDirectionContainerType::Pointer dirs = dwi->GetDirections();
-
-    m_ImageGenParameters.numGradients = 0;
-    for (int i=0; i<dirs->Size(); i++)
-    {
-      DiffusionSignalModel<double>::GradientType g;
-      g[0] = dirs->at(i)[0];
-      g[1] = dirs->at(i)[1];
-      g[2] = dirs->at(i)[2];
-      m_ImageGenParameters.gradientDirections.push_back(g);
-      if (dirs->at(i).magnitude()>0.0001)
-        m_ImageGenParameters.numGradients++;
-    }
-
-    mitk::StickModel<double> m_StickModel1;
-    mitk::StickModel<double> m_StickModel2;
-    mitk::TensorModel<double> m_ZeppelinModel1;
-    mitk::TensorModel<double> m_ZeppelinModel2;
-    mitk::TensorModel<double> m_TensorModel1;
-    mitk::TensorModel<double> m_TensorModel2;
-
-    // extra axonal compartment models
-    mitk::BallModel<double> m_BallModel1;
-    mitk::BallModel<double> m_BallModel2;
-    mitk::AstroStickModel<double> m_AstrosticksModel1;
-    mitk::AstroStickModel<double> m_AstrosticksModel2;
-    mitk::DotModel<double> m_DotModel1;
-    mitk::DotModel<double> m_DotModel2;
-
-    LoadParameters(paramName,m_ImageGenParameters,NULL, NULL,
-                   &m_StickModel1,
-                   &m_StickModel2,
-                   &m_ZeppelinModel1,
-                   &m_ZeppelinModel2,
-                   &m_TensorModel1,
-                   &m_TensorModel2,
-                   &m_BallModel1,
-                   &m_BallModel2,
-                   &m_AstrosticksModel1,
-                   &m_AstrosticksModel2,
-                   &m_DotModel1,
-                   &m_DotModel2);
-
-    MITK_INFO << "Parameter loaded";
-
-    itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
-
-    tractsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
-    tractsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
-    //tractsToDwiFilter->SetUpsampling(m_ImageGenParameters.upsampling);
-    tractsToDwiFilter->SetSimulateRelaxation(m_ImageGenParameters.doSimulateRelaxation);
-    tractsToDwiFilter->SetImageRegion(m_ImageGenParameters.imageRegion);
-    tractsToDwiFilter->SetSpacing(m_ImageGenParameters.imageSpacing);
-    tractsToDwiFilter->SetOrigin(m_ImageGenParameters.imageOrigin);
-    tractsToDwiFilter->SetDirectionMatrix(m_ImageGenParameters.imageDirection);
-    tractsToDwiFilter->SetFiberBundle(fbi);
-    tractsToDwiFilter->SetFiberModels(m_ImageGenParameters.fiberModelList);
-    tractsToDwiFilter->SetNonFiberModels(m_ImageGenParameters.nonFiberModelList);
-    tractsToDwiFilter->SetNoiseModel(&m_ImageGenParameters.ricianNoiseModel);
-    tractsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
-    tractsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
-    tractsToDwiFilter->SettInhom(m_ImageGenParameters.tInhom);
-    tractsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
-    tractsToDwiFilter->SetNumberOfRepetitions(m_ImageGenParameters.repetitions);
-    tractsToDwiFilter->SetEnforcePureFiberVoxels(m_ImageGenParameters.doDisablePartialVolume);
-    tractsToDwiFilter->SetInterpolationShrink(m_ImageGenParameters.interpolationShrink);
-    tractsToDwiFilter->SetFiberRadius(m_ImageGenParameters.axonRadius);
-    tractsToDwiFilter->SetSignalScale(m_ImageGenParameters.signalScale);
-    if (m_ImageGenParameters.interpolationShrink>0)
-      tractsToDwiFilter->SetUseInterpolation(true);
-    tractsToDwiFilter->SetTissueMask(m_ImageGenParameters.tissueMaskImage);
-    tractsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
-    tractsToDwiFilter->SetSpikeAmplitude(m_ImageGenParameters.spikeAmplitude);
-    tractsToDwiFilter->SetSpikes(m_ImageGenParameters.spikes);
-    tractsToDwiFilter->Update();
-
-    mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
-    image->SetVectorImage( tractsToDwiFilter->GetOutput() );
-    image->SetB_Value(dwi->GetB_Value());
-    image->SetDirections(dwi->GetDirections());
-    image->InitializeFromVectorImage();
-
-    MITK_INFO << "Writing " << outName;
-    NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
-    writer->SetFileName(outName);
-    writer->SetInput(image);
-    writer->Update();
-
-
-  }
-  MITK_INFO << "DONE";
-  return EXIT_SUCCESS;
-}
-RegisterDiffusionMiniApp(FiberFoxProcessing);
diff --git a/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
new file mode 100755
index 0000000000..8dfba05cc5
--- /dev/null
+++ b/Modules/DiffusionImaging/MiniApps/Fiberfox.cpp
@@ -0,0 +1,84 @@
+/*===================================================================
+
+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 "MiniAppManager.h"
+#include <mitkImageCast.h>
+#include <mitkDiffusionImage.h>
+#include <mitkBaseDataIOFactory.h>
+#include <mitkIOUtil.h>
+#include <mitkNrrdDiffusionImageWriter.h>
+#include <mitkFiberBundleX.h>
+#include <mitkFiberfoxParameters.h>
+#include "ctkCommandLineParser.h"
+
+#include <itkAddArtifactsToDwiImageFilter.h>
+#include <itkTractsToDWIImageFilter.h>
+
+#include "boost/property_tree/ptree.hpp"
+#include "boost/property_tree/xml_parser.hpp"
+#include "boost/foreach.hpp"
+
+/** TODO: Proritype signal komplett speichern oder bild mit speichern. */
+/** TODO: Tarball aus images und parametern? */
+/** TODO: Artefakte auf bild in miniapp */
+
+namespace mitk
+{
+int Fiberfox(int argc, char* argv[])
+{
+    ctkCommandLineParser parser;
+    parser.setArgumentPrefix("--", "-");
+    parser.addArgument("out", "o", ctkCommandLineParser::OutputFile, "Output root:", "output root", us::Any(), false);
+    parser.addArgument("parameters", "p", ctkCommandLineParser::InputFile, "Parameter file:", "fiberfox parameter file", us::Any(), false);
+    parser.addArgument("fiberbundle", "f", ctkCommandLineParser::String, "Fiberbundle:", "", us::Any(), false);
+
+    map<string, us::Any> parsedArgs = parser.parseArguments(argc, argv);
+    if (parsedArgs.size()==0)
+        return EXIT_FAILURE;
+
+    string outName = us::any_cast<string>(parsedArgs["out"]);
+    string paramName = us::any_cast<string>(parsedArgs["parameters"]);
+
+    string fibFile = "";
+    if (parsedArgs.count("fiberbundle"))
+        fibFile = us::any_cast<string>(parsedArgs["fiberbundle"]);
+
+    {
+        FiberfoxParameters<double> parameters;
+        parameters.LoadParameters(paramName);
+
+        mitk::FiberBundleX::Pointer inputTractogram = dynamic_cast<mitk::FiberBundleX*>(mitk::IOUtil::LoadDataNode(fibFile)->GetData());
+
+        itk::TractsToDWIImageFilter< short >::Pointer tractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
+        tractsToDwiFilter->SetParameters(parameters);
+        tractsToDwiFilter->SetFiberBundle(inputTractogram);
+        tractsToDwiFilter->Update();
+
+        DiffusionImage<short>::Pointer image = DiffusionImage<short>::New();
+        image->SetVectorImage( tractsToDwiFilter->GetOutput() );
+        image->SetReferenceBValue( parameters.m_SignalGen.m_Bvalue );
+        image->SetDirections( parameters.m_SignalGen.GetGradientDirections() );
+        image->InitializeFromVectorImage();
+
+        NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
+        writer->SetFileName(outName);
+        writer->SetInput(image);
+        writer->Update();
+    }
+    return EXIT_SUCCESS;
+}
+}
+RegisterDiffusionMiniApp(Fiberfox);
diff --git a/Modules/DiffusionImaging/MiniApps/files.cmake b/Modules/DiffusionImaging/MiniApps/files.cmake
index 97544eb067..98428da34c 100644
--- a/Modules/DiffusionImaging/MiniApps/files.cmake
+++ b/Modules/DiffusionImaging/MiniApps/files.cmake
@@ -1,31 +1,31 @@
 set(CPP_FILES
     mitkDiffusionMiniApps.cpp
     MiniAppManager.cpp
 
     BatchedFolderRegistration.cpp
     DicomFolderDump.cpp
     FileFormatConverter.cpp
     TensorReconstruction.cpp
     TensorDerivedMapsExtraction.cpp
     QballReconstruction.cpp
     DiffusionIndices.cpp
     ExtractImageStatistics.cpp
     CopyGeometry.cpp
     GibbsTracking.cpp
     StreamlineTracking.cpp
     FiberProcessing.cpp
     LocalDirectionalFiberPlausibility.cpp
     #TractogramAngularError.cpp
     FiberDirectionExtraction.cpp
     ImageResampler.cpp
     PeakExtraction.cpp
     PeaksAngularError.cpp
     MultishellMethods.cpp
-    #FiberFoxProcessing.cpp
+    Fiberfox.cpp
     ExportShImage.cpp
     NetworkCreation.cpp
     NetworkStatistics.cpp
     DwiDenoising.cpp
     FiberExtraction.cpp
     FiberJoin.cpp
 )