diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
index 9f8384051e..732b38f10e 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,949 +1,959 @@
 /*===================================================================
 
 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 <boost/lexical_cast.hpp>
 
 namespace itk
 {
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
     : m_CircleDummy(false)
     , m_VolumeAccuracy(10)
     , m_AddGibbsRinging(false)
     , m_NumberOfRepetitions(1)
     , m_EnforcePureFiberVoxels(false)
     , m_InterpolationShrink(1000)
     , m_FiberRadius(0)
     , m_SignalScale(25)
     , m_kOffset(0)
     , m_tLine(1)
     , m_UseInterpolation(false)
     , m_SimulateRelaxation(true)
     , m_tInhom(50)
     , m_TE(100)
     , m_FrequencyMap(NULL)
     , m_EddyGradientStrength(0.001)
     , m_SimulateEddyCurrents(false)
     , m_Spikes(0)
     , m_Wrap(1.0)
     , m_NoiseModel(NULL)
     , m_SpikeAmplitude(1)
     , m_AddMotionArtifact(false)
 {
     m_Spacing.Fill(2.5); m_Origin.Fill(0.0);
     m_DirectionMatrix.SetIdentity();
     m_ImageRegion.SetSize(0, 10);
     m_ImageRegion.SetSize(1, 10);
     m_ImageRegion.SetSize(2, 10);
 
     m_MaxTranslation.Fill(0.0);
     m_MaxRotation.Fill(0.0);
 
     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 )
 {
     // 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_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();
     }
 
     DoubleDwiType::Pointer newImage = DoubleDwiType::New();
     newImage->SetSpacing( m_Spacing );
     newImage->SetOrigin( m_Origin );
     newImage->SetDirection( m_DirectionMatrix );
     newImage->SetLargestPossibleRegion( m_ImageRegion );
     newImage->SetBufferedRegion( m_ImageRegion );
     newImage->SetRequestedRegion( m_ImageRegion );
     newImage->SetVectorLength( images.at(0)->GetVectorLength() );
     newImage->Allocate();
 
     MatrixType transform = m_DirectionMatrix;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
         {
             if (j<2)
                 transform[i][j] *= m_UpsampledSpacing[j];
             else
                 transform[i][j] *= m_Spacing[j];
         }
 
     std::vector< unsigned int > spikeVolume;
     for (int i=0; i<m_Spikes; i++)
         spikeVolume.push_back(rand()%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< int > spikeSlice;
         while (!spikeVolume.empty() && spikeVolume.back()==g)
         {
             spikeSlice.push_back(rand()%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<m_FiberModels.size())
                     signalModel = m_FiberModels.at(i);
                 else
                     signalModel = m_NonFiberModels.at(i-m_FiberModels.size());
 
                 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_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_ImageRegion.GetSize(0)); outSize.SetElement(1, m_ImageRegion.GetSize(1));
             itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
             idft->SetCompartmentImages(compartmentSlices);
             idft->SetT2(t2Vector);
             idft->SetkOffset(m_kOffset);
             idft->SettLine(m_tLine);
             idft->SetTE(m_TE);
             idft->SetTinhom(m_tInhom);
             idft->SetSimulateRelaxation(m_SimulateRelaxation);
             idft->SetSimulateEddyCurrents(m_SimulateEddyCurrents);
             idft->SetEddyGradientMagnitude(m_EddyGradientStrength);
             idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
             idft->SetDirectionMatrix(transform);
             idft->SetDiffusionGradientDirection(m_FiberModels.at(0)->GetGradientDirection(g));
             idft->SetFrequencyMap(fMapSlice);
             idft->SetSignalScale(m_SignalScale);
             idft->SetOutSize(outSize);
             int numSpikes = 0;
             while (!spikeSlice.empty() && spikeSlice.back()==z)
             {
                 numSpikes++;
                 spikeSlice.pop_back();
             }
             idft->SetSpikes(numSpikes);
             idft->SetSpikeAmplitude(m_SpikeAmplitude);
             idft->Update();
 
             ComplexSliceType::Pointer fSlice;
             fSlice = idft->GetOutput();
 
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (int 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 (int tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
         }
     }
     m_StatusText += "\n\n";
     return newImage;
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::GenerateData()
 {
     m_StartTime = clock();
     m_StatusText = "Starting simulation\n";
 
     // check input data
     if (m_FiberBundle.IsNull())
         itkExceptionMacro("Input fiber bundle is NULL!");
 
     int numFibers = m_FiberBundle->GetNumFibers();
     if (numFibers<=0)
         itkExceptionMacro("Input fiber bundle contains no fibers!");
 
     if (m_FiberModels.empty())
         itkExceptionMacro("No diffusion model for fiber compartments defined!");
 
     if (m_EnforcePureFiberVoxels)
         while (m_FiberModels.size()>1)
             m_FiberModels.pop_back();
 
     if (m_NonFiberModels.empty())
         itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
 
     int baselineIndex = m_FiberModels[0]->GetFirstBaselineIndex();
     if (baselineIndex<0)
         itkExceptionMacro("No baseline index found!");
 
     // initialize output dwi image
     ImageRegion<3> croppedRegion = m_ImageRegion; croppedRegion.SetSize(1, croppedRegion.GetSize(1)*m_Wrap);
     itk::Point<double,3> shiftedOrigin = m_Origin; shiftedOrigin[1] += (m_ImageRegion.GetSize(1)-croppedRegion.GetSize(1))*m_Spacing[1]/2;
 
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Spacing );
     outImage->SetOrigin( shiftedOrigin );
     outImage->SetDirection( m_DirectionMatrix );
     outImage->SetLargestPossibleRegion( croppedRegion );
     outImage->SetBufferedRegion( croppedRegion );
     outImage->SetRequestedRegion( croppedRegion );
     outImage->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
     outImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_FiberModels[0]->GetNumGradients());
     temp.Fill(0.0);
     outImage->FillBuffer(temp);
 
     // ADJUST GEOMETRY FOR FURTHER PROCESSING
     // is input slize size a power of two?
     unsigned int x=m_ImageRegion.GetSize(0); unsigned int y=m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         m_ImageRegion.SetSize(0, x+1);
     if ( y%2 == 1 )
         m_ImageRegion.SetSize(1, y+1);
 
     // apply in-plane upsampling
     double upsampling = 1;
     if (m_AddGibbsRinging)
     {
         m_StatusText += "Gibbs ringing enabled\n";
         MITK_INFO << "Adding ringing artifacts.";
         upsampling = 2;
     }
     m_UpsampledSpacing = m_Spacing;
     m_UpsampledSpacing[0] /= upsampling;
     m_UpsampledSpacing[1] /= upsampling;
     m_UpsampledImageRegion = m_ImageRegion;
     m_UpsampledImageRegion.SetSize(0, m_ImageRegion.GetSize()[0]*upsampling);
     m_UpsampledImageRegion.SetSize(1, m_ImageRegion.GetSize()[1]*upsampling);
     m_UpsampledOrigin = m_Origin;
     m_UpsampledOrigin[0] -= m_Spacing[0]/2; m_UpsampledOrigin[0] += m_UpsampledSpacing[0]/2;
     m_UpsampledOrigin[1] -= m_Spacing[1]/2; m_UpsampledOrigin[1] += m_UpsampledSpacing[1]/2;
     m_UpsampledOrigin[2] -= m_Spacing[2]/2; m_UpsampledOrigin[2] += m_UpsampledSpacing[2]/2;
 
     // generate double images to store the individual compartment signals
     std::vector< DoubleDwiType::Pointer > compartments;
     for (unsigned int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
         doubleDwi->SetSpacing( m_UpsampledSpacing );
         doubleDwi->SetOrigin( m_UpsampledOrigin );
         doubleDwi->SetDirection( m_DirectionMatrix );
         doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
         doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
         doubleDwi->SetVectorLength( m_FiberModels[0]->GetNumGradients() );
         doubleDwi->Allocate();
         DoubleDwiType::PixelType pix;
         pix.SetSize(m_FiberModels[0]->GetNumGradients());
         pix.Fill(0.0);
         doubleDwi->FillBuffer(pix);
         compartments.push_back(doubleDwi);
     }
 
     // initialize volume fraction images
     m_VolumeFractions.clear();
     for (unsigned int i=0; i<m_FiberModels.size()+m_NonFiberModels.size(); i++)
     {
         ItkDoubleImgType::Pointer doubleImg = ItkDoubleImgType::New();
         doubleImg->SetSpacing( m_UpsampledSpacing );
         doubleImg->SetOrigin( m_UpsampledOrigin );
         doubleImg->SetDirection( m_DirectionMatrix );
         doubleImg->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleImg->SetBufferedRegion( m_UpsampledImageRegion );
         doubleImg->SetRequestedRegion( m_UpsampledImageRegion );
         doubleImg->Allocate();
         doubleImg->FillBuffer(0);
         m_VolumeFractions.push_back(doubleImg);
     }
 
     // resample mask image and frequency map to fit upsampled geometry
     if (m_AddGibbsRinging)
     {
         if (m_TissueMask.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_TissueMask);
             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_TissueMask);
             resampler->SetSize(m_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             resampler->Update();
             m_TissueMask = resampler->GetOutput();
         }
 
         // resample frequency map
         if (m_FrequencyMap.IsNotNull())
         {
             itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
             resampler->SetInput(m_FrequencyMap);
             resampler->SetOutputParametersFromImage(m_FrequencyMap);
             resampler->SetSize(m_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             resampler->Update();
             m_FrequencyMap = resampler->GetOutput();
         }
     }
 
     // no input tissue mask is set -> create default
     bool maskImageSet = true;
     if (m_TissueMask.IsNull())
     {
         m_StatusText += "No tissue mask set\n";
         MITK_INFO << "No tissue mask set";
         m_TissueMask = ItkUcharImgType::New();
         m_TissueMask->SetSpacing( m_UpsampledSpacing );
         m_TissueMask->SetOrigin( m_UpsampledOrigin );
         m_TissueMask->SetDirection( m_DirectionMatrix );
         m_TissueMask->SetLargestPossibleRegion( m_UpsampledImageRegion );
         m_TissueMask->SetBufferedRegion( m_UpsampledImageRegion );
         m_TissueMask->SetRequestedRegion( m_UpsampledImageRegion );
         m_TissueMask->Allocate();
         m_TissueMask->FillBuffer(1);
         maskImageSet = false;
     }
     else
     {
         m_StatusText += "Using tissue mask\n";
         MITK_INFO << "Using tissue mask";
     }
 
     m_ImageRegion = croppedRegion;
     x=m_ImageRegion.GetSize(0); y=m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         m_ImageRegion.SetSize(0, x+1);
     if ( y%2 == 1 )
         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];
     FiberBundleType fiberBundle = m_FiberBundle->GetDeepCopy();
     fiberBundle->ResampleFibers(minSpacing/m_VolumeAccuracy);
     double mmRadius = m_FiberRadius/1000;
     if (mmRadius>0)
         segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/m_VolumeAccuracy;
 
     double interpFact = 2*atan(-0.5*m_InterpolationShrink);
     double maxVolume = 0;
     double voxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
 
-    m_StatusText += "\nGenerating signal of " + boost::lexical_cast<std::string>(m_FiberModels.size()) + " fiber compartments\n";
-    MITK_INFO << "Generating signal of " << m_FiberModels.size() << " fiber compartments";
-    boost::progress_display disp(numFibers*m_FiberModels.at(0)->GetNumGradients());
-
     if (m_AddMotionArtifact)
     {
         if (m_RandomMotion)
         {
             m_StatusText += "Adding random motion artifacts:\n";
             m_StatusText += "Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_MaxRotation) + "°\n";
             m_StatusText += "Maximum translation: +/-" + boost::lexical_cast<std::string>(m_MaxTranslation) + "mm\n";
         }
         else
         {
             m_StatusText += "Adding linear motion artifacts:\n";
             m_StatusText += "Maximum rotation: " + boost::lexical_cast<std::string>(m_MaxRotation) + "°\n";
             m_StatusText += "Maximum translation: " + boost::lexical_cast<std::string>(m_MaxTranslation) + "mm\n";
         }
         MITK_INFO << "Adding motion artifacts";
         MITK_INFO << "Maximum rotation: " << m_MaxRotation;
         MITK_INFO << "Maxmimum translation: " << m_MaxTranslation;
     }
     maxVolume = 0;
 
+    m_StatusText += "\n"+this->GetTime()+" > Generating signal of " + boost::lexical_cast<std::string>(m_FiberModels.size()) + " fiber compartments\n";
+    MITK_INFO << "Generating signal of " << m_FiberModels.size() << " fiber compartments";
+    boost::progress_display disp(numFibers*m_FiberModels.at(0)->GetNumGradients());
+
     ofstream logFile;
     logFile.open("fiberfox_motion.log");
     logFile << "0 rotation: 0,0,0; translation: 0,0,0\n";
 
     // get transform for motion artifacts
     FiberBundleType fiberBundleTransformed = fiberBundle;
     VectorType rotation = m_MaxRotation/m_FiberModels.at(0)->GetNumGradients();
     VectorType translation = m_MaxTranslation/m_FiberModels.at(0)->GetNumGradients();
 
     // creat image to hold transformed mask (motion artifact)
     ItkUcharImgType::Pointer tempTissueMask = ItkUcharImgType::New();
     itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(m_TissueMask);
     duplicator->Update();
     tempTissueMask = duplicator->GetOutput();
 
     // second upsampling needed for motion artifacts
     ImageRegion<3>                      upsampledImageRegion = m_UpsampledImageRegion;
     itk::Vector<double,3>               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;
     ItkUcharImgType::Pointer upsampledTissueMask = ItkUcharImgType::New();
     itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer upsampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
     upsampler->SetInput(m_TissueMask);
     upsampler->SetOutputParametersFromImage(m_TissueMask);
     upsampler->SetSize(upsampledImageRegion.GetSize());
     upsampler->SetOutputSpacing(upsampledSpacing);
     upsampler->SetOutputOrigin(upsampledOrigin);
     itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType>::Pointer nn_interpolator
             = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType>::New();
     upsampler->SetInterpolator(nn_interpolator);
     upsampler->Update();
     upsampledTissueMask = upsampler->GetOutput();
 
     m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
     m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
     unsigned int lastTick = 0;
 
     for (int g=0; g<m_FiberModels.at(0)->GetNumGradients(); g++)
     {
         vtkPolyData* fiberPolyData = fiberBundleTransformed->GetFiberPolyData();
 
         ItkDoubleImgType::Pointer intraAxonalVolume = ItkDoubleImgType::New();
         intraAxonalVolume->SetSpacing( m_UpsampledSpacing );
         intraAxonalVolume->SetOrigin( m_UpsampledOrigin );
         intraAxonalVolume->SetDirection( m_DirectionMatrix );
         intraAxonalVolume->SetLargestPossibleRegion( m_UpsampledImageRegion );
         intraAxonalVolume->SetBufferedRegion( m_UpsampledImageRegion );
         intraAxonalVolume->SetRequestedRegion( m_UpsampledImageRegion );
         intraAxonalVolume->Allocate();
         intraAxonalVolume->FillBuffer(0);
 
         // generate fiber signal
         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 += "\nSimulation aborted\n";
+                    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)
+                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;
                 tempTissueMask->TransformPhysicalPointToIndex(vertex, idx);
                 tempTissueMask->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
                 if (!m_UseInterpolation)    // use nearest neighbour interpolation
                 {
                     if (!tempTissueMask->GetLargestPossibleRegion().IsInside(idx) || tempTissueMask->GetPixel(idx)<=0)
                         continue;
 
                     // generate signal for each fiber compartment
                     for (unsigned int k=0; k<m_FiberModels.size(); k++)
                     {
                         DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                         m_FiberModels[k]->SetFiberDirection(dir);
                         DoubleDwiType::PixelType pix = doubleDwi->GetPixel(idx);
                         pix[g] += segmentVolume*m_FiberModels[k]->SimulateMeasurement(g);
+
+                        if (pix[g]!=pix[g])
+                        {
+                            std::cout << "pix[g] " << pix[g] << std::endl;
+                            std::cout << "dir " << dir << std::endl;
+                            std::cout << "segmentVolume " << segmentVolume << std::endl;
+                            std::cout << "m_FiberModels[k]->SimulateMeasurement(g) " << m_FiberModels[k]->SimulateMeasurement(g) << std::endl;
+                        }
+
                         doubleDwi->SetPixel(idx, pix );
 
                         double vol = intraAxonalVolume->GetPixel(idx) + segmentVolume;
                         intraAxonalVolume->SetPixel(idx, vol );
 
                         if (g==0 && vol>maxVolume)
                             maxVolume = vol;
                     }
                     continue;
                 }
 
                 double frac_x = contIndex[0] - idx[0]; double frac_y = contIndex[1] - idx[1]; double frac_z = contIndex[2] - idx[2];
                 if (frac_x<0)
                 {
                     idx[0] -= 1;
                     frac_x += 1;
                 }
                 if (frac_y<0)
                 {
                     idx[1] -= 1;
                     frac_y += 1;
                 }
                 if (frac_z<0)
                 {
                     idx[2] -= 1;
                     frac_z += 1;
                 }
 
                 frac_x = atan((0.5-frac_x)*m_InterpolationShrink)/interpFact + 0.5;
                 frac_y = atan((0.5-frac_y)*m_InterpolationShrink)/interpFact + 0.5;
                 frac_z = atan((0.5-frac_z)*m_InterpolationShrink)/interpFact + 0.5;
 
                 // use trilinear interpolation
                 itk::Index<3> newIdx;
                 for (int x=0; x<2; x++)
                 {
                     frac_x = 1-frac_x;
                     for (int y=0; y<2; y++)
                     {
                         frac_y = 1-frac_y;
                         for (int z=0; z<2; z++)
                         {
                             frac_z = 1-frac_z;
 
                             newIdx[0] = idx[0]+x;
                             newIdx[1] = idx[1]+y;
                             newIdx[2] = idx[2]+z;
 
                             double frac = frac_x*frac_y*frac_z;
 
                             // is position valid?
                             if (!tempTissueMask->GetLargestPossibleRegion().IsInside(newIdx) || tempTissueMask->GetPixel(newIdx)<=0)
                                 continue;
 
                             // generate signal for each fiber compartment
                             for (unsigned int k=0; k<m_FiberModels.size(); k++)
                             {
                                 DoubleDwiType::Pointer doubleDwi = compartments.at(k);
                                 m_FiberModels[k]->SetFiberDirection(dir);
                                 DoubleDwiType::PixelType pix = doubleDwi->GetPixel(newIdx);
                                 pix[g] += segmentVolume*frac*m_FiberModels[k]->SimulateMeasurement(g);
                                 doubleDwi->SetPixel(newIdx, pix );
 
                                 double vol = intraAxonalVolume->GetPixel(idx) + segmentVolume;
                                 intraAxonalVolume->SetPixel(idx, vol );
 
                                 if (g==0 && vol>maxVolume)
                                     maxVolume = vol;
                             }
                         }
                     }
                 }
             }
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (int tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
         }
 
         // generate non-fiber signal
         ImageRegionIterator<ItkUcharImgType> it3(tempTissueMask, tempTissueMask->GetLargestPossibleRegion());
         double fact = 1;
         if (m_FiberRadius<0.0001)
             fact = voxelVolume/maxVolume;
         while(!it3.IsAtEnd())
         {
             if (it3.Get()>0)
             {
                 DoubleDwiType::IndexType index = it3.GetIndex();
 
                 // get fiber volume fraction
                 DoubleDwiType::Pointer fiberDwi = compartments.at(0);
                 DoubleDwiType::PixelType fiberPix = fiberDwi->GetPixel(index); // intra axonal compartment
                 if (fact>1) // auto scale intra-axonal if no fiber radius is specified
                 {
                     fiberPix[g] *= fact;
                     fiberDwi->SetPixel(index, fiberPix);
                 }
                 double f = intraAxonalVolume->GetPixel(index)*fact;
 
                 if (f>voxelVolume || (f>0.0 && m_EnforcePureFiberVoxels) )  // more fiber than space in voxel?
                 {
                     fiberPix[g] *= voxelVolume/f;
                     fiberDwi->SetPixel(index, fiberPix);
                     m_VolumeFractions.at(0)->SetPixel(index, 1);
                 }
                 else
                 {
                     m_VolumeFractions.at(0)->SetPixel(index, f/voxelVolume);
 
                     double nonf = voxelVolume-f;    // non-fiber volume
                     double inter = 0;
                     if (m_FiberModels.size()>1)
                         inter = nonf * f/voxelVolume;   // inter-axonal fraction of non fiber compartment scales linearly with f
                     double other = nonf - inter;        // rest of compartment
                     double singleinter = inter/(m_FiberModels.size()-1);
 
                     // adjust non-fiber and intra-axonal signal
                     for (unsigned int i=1; i<m_FiberModels.size(); i++)
                     {
                         DoubleDwiType::Pointer doubleDwi = compartments.at(i);
                         DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
                         if (f>0)
                             pix[g] /= f;
                         pix[g] *= singleinter;
                         doubleDwi->SetPixel(index, pix);
                         m_VolumeFractions.at(i)->SetPixel(index, singleinter/voxelVolume);
                     }
                     for (unsigned int i=0; i<m_NonFiberModels.size(); i++)
                     {
                         DoubleDwiType::Pointer doubleDwi = compartments.at(i+m_FiberModels.size());
                         DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
                         //                        if (dynamic_cast< mitk::AstroStickModel<double>* >(m_NonFiberModels.at(i)))
                         //                        {
                         //                            mitk::AstroStickModel<double>* model = dynamic_cast< mitk::AstroStickModel<double>* >(m_NonFiberModels.at(i));
                         //                            model->SetSeed(8111984);
                         //                        }
                         pix[g] += m_NonFiberModels[i]->SimulateMeasurement(g)*other*m_NonFiberModels[i]->GetWeight();
                         doubleDwi->SetPixel(index, pix);
                         m_VolumeFractions.at(i+m_FiberModels.size())->SetPixel(index, other/voxelVolume*m_NonFiberModels[i]->GetWeight());
                     }
                 }
             }
             ++it3;
         }
 
         // move fibers
         if (m_AddMotionArtifact)
         {
             if (m_RandomMotion)
             {
                 fiberBundleTransformed = fiberBundle->GetDeepCopy();
                 rotation[0] = m_RandGen->GetVariateWithClosedRange(m_MaxRotation[0]*2)-m_MaxRotation[0];
                 rotation[1] = m_RandGen->GetVariateWithClosedRange(m_MaxRotation[1]*2)-m_MaxRotation[1];
                 rotation[2] = m_RandGen->GetVariateWithClosedRange(m_MaxRotation[2]*2)-m_MaxRotation[2];
                 translation[0] = m_RandGen->GetVariateWithClosedRange(m_MaxTranslation[0]*2)-m_MaxTranslation[0];
                 translation[1] = m_RandGen->GetVariateWithClosedRange(m_MaxTranslation[1]*2)-m_MaxTranslation[1];
                 translation[2] = m_RandGen->GetVariateWithClosedRange(m_MaxTranslation[2]*2)-m_MaxTranslation[2];
             }
 
             // rotate mask image
             if (maskImageSet)
             {
                 ImageRegionIterator<ItkUcharImgType> maskIt(upsampledTissueMask, upsampledTissueMask->GetLargestPossibleRegion());
                 tempTissueMask->FillBuffer(0);
 
                 while(!maskIt.IsAtEnd())
                 {
                     if (maskIt.Get()<=0)
                     {
                         ++maskIt;
                         continue;
                     }
 
                     DoubleDwiType::IndexType index = maskIt.GetIndex();
                     itk::Point<double, 3> point;
                     upsampledTissueMask->TransformIndexToPhysicalPoint(index, point);
                     if (m_RandomMotion)
                         point = fiberBundle->TransformPoint(point.GetVnlVector(), rotation[0],rotation[1],rotation[2],translation[0],translation[1],translation[2]);
                     else
                         point = fiberBundle->TransformPoint(point.GetVnlVector(), rotation[0]*(g+1),rotation[1]*(g+1),rotation[2]*(g+1),translation[0]*(g+1),translation[1]*(g+1),translation[2]*(g+1));
 
                     tempTissueMask->TransformPhysicalPointToIndex(point, index);
                     if (tempTissueMask->GetLargestPossibleRegion().IsInside(index))
                         tempTissueMask->SetPixel(index,100);
                     ++maskIt;
                 }
             }
 
             // rotate fibers
             logFile << g+1 << " rotation:" << rotation[0] << "," << rotation[1] << "," << rotation[2] << ";";
             logFile << " translation:" << translation[0] << "," << translation[1] << "," << translation[2] << "\n";
             fiberBundleTransformed->TransformFibers(rotation[0],rotation[1],rotation[2],translation[0],translation[1],translation[2]);
         }
     }
     logFile.close();
     m_StatusText += "\n\n";
     if (this->GetAbortGenerateData())
     {
-        m_StatusText += "\nSimulation aborted\n";
+        m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
     // do k-space stuff
     DoubleDwiType::Pointer doubleOutImage;
     if (m_Spikes>0 || m_FrequencyMap.IsNotNull() || m_kOffset>0 || m_SimulateRelaxation || m_SimulateEddyCurrents || m_AddGibbsRinging || m_Wrap<1.0)
     {
-        m_StatusText += "Adjusting complex signal\n";
+        m_StatusText += this->GetTime()+" > Adjusting complex signal\n";
         MITK_INFO << "Adjusting complex signal";
         doubleOutImage = DoKspaceStuff(compartments);
         m_SignalScale = 1;
     }
     else
     {
-        m_StatusText += "Summing compartments\n";
+        m_StatusText += this->GetTime()+" > Summing compartments\n";
         MITK_INFO << "Summing compartments";
         doubleOutImage = compartments.at(0);
 
         for (unsigned int i=1; i<compartments.size(); i++)
         {
             itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
             adder->SetInput1(doubleOutImage);
             adder->SetInput2(compartments.at(i));
             adder->Update();
             doubleOutImage = adder->GetOutput();
         }
     }
     if (this->GetAbortGenerateData())
     {
-        m_StatusText += "\nSimulation aborted\n";
+        m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
-    m_StatusText += "Finalizing image\n";
+    m_StatusText += this->GetTime()+" > Finalizing image\n";
     MITK_INFO << "Finalizing image";
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_FiberModels[0]->GetNumGradients());
     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 += "\nSimulation aborted\n";
+            m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
             return;
         }
 
         ++disp2;
         unsigned long newTick = 50*disp2.count()/disp2.expected_count();
         for (int tick = 0; tick<(newTick-lastTick); tick++)
             m_StatusText += "*";
         lastTick = newTick;
 
         typename OutputImageType::IndexType index = it4.GetIndex();
         signal = doubleOutImage->GetPixel(index)*m_SignalScale;
 
         if (m_NoiseModel!=NULL)
         {
             DoubleDwiType::PixelType accu = signal; accu.Fill(0.0);
             for (unsigned int i=0; i<m_NumberOfRepetitions; i++)
             {
                 DoubleDwiType::PixelType temp = signal;
                 m_NoiseModel->AddNoise(temp);
                 accu += temp;
             }
             signal = accu/m_NumberOfRepetitions;
         }
 
         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_FiberModels.at(0)->IsBaselineIndex(i) && signal[i]>window)
                 window = signal[i];
             if (!m_FiberModels.at(0)->IsBaselineIndex(i) && 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();
 }
 
 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 >
 std::string TractsToDWIImageFilter< PixelType >::GetTime()
 {
     unsigned long total = (double)(clock() - m_StartTime)/CLOCKS_PER_SEC;
     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));
     return out;
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
index 804227dc92..f6059409d2 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2318 +1,2336 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //misc
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberfoxView.h"
 
 // MITK
 #include <mitkImage.h>
 #include <mitkDiffusionImage.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkProperties.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkDataStorage.h>
 #include <itkFibersFromPlanarFiguresFilter.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <mitkTensorImage.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageToItk.h>
 #include <mitkImageCast.h>
 #include <mitkImageGenerator.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/xml_parser.hpp>
 #include <boost/foreach.hpp>
 #include <QFileDialog>
 #include <QMessageBox>
 #include "usModuleRegistry.h"
 #include <mitkChiSquareNoiseModel.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkNrrdDiffusionImageWriter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 QmitkFiberfoxWorker::QmitkFiberfoxWorker(QmitkFiberfoxView* view)
     : m_View(view)
 {
 
 }
 
 void QmitkFiberfoxWorker::run()
 {
     try{
         switch (m_FilterType)
         {
         case 0:
             m_View->m_TractsToDwiFilter->Update();
             break;
         case 1:
             m_View->m_ArtifactsToDwiFilter->Update();
             break;
         }
     }
     catch( ... )
     {
 
     }
     m_View->m_Thread.quit();
 }
 
 const std::string QmitkFiberfoxView::VIEW_ID = "org.mitk.views.fiberfoxview";
 
 QmitkFiberfoxView::QmitkFiberfoxView()
     : QmitkAbstractView()
     , m_Controls( 0 )
     , m_SelectedImage( NULL )
     , m_OutputPath("")
     , m_Worker(this)
     , m_ThreadIsRunning(false)
 {
     m_ImageGenParameters.noiseModel = NULL;
     m_ImageGenParameters.noiseModelShort = NULL;
 
     m_Worker.moveToThread(&m_Thread);
     connect(&m_Thread, SIGNAL(started()), this, SLOT(BeforeThread()));
     connect(&m_Thread, SIGNAL(started()), &m_Worker, SLOT(run()));
     connect(&m_Thread, SIGNAL(finished()), this, SLOT(AfterThread()));
     connect(&m_Thread, SIGNAL(terminated()), this, SLOT(AfterThread()));
     m_SimulationTimer = new QTimer(this);
 }
 
 void QmitkFiberfoxView::KillThread()
 {
     MITK_INFO << "Aborting DWI simulation.";
     switch (m_Worker.m_FilterType)
     {
     case 0:
         m_TractsToDwiFilter->SetAbortGenerateData(true);
         break;
     case 1:
         m_ArtifactsToDwiFilter->SetAbortGenerateData(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::BeforeThread()
 {
     m_SimulationTime = QTime::currentTime();
     m_SimulationTimer->start(100);
     m_ImageGenParametersBackup = m_ImageGenParameters;
     m_Controls->m_AbortSimulationButton->setVisible(true);
     m_Controls->m_GenerateImageButton->setVisible(false);
     m_Controls->m_SimulationStatusText->setVisible(true);
     m_ThreadIsRunning = true;
 }
 
 void QmitkFiberfoxView::AfterThread()
 {
     UpdateSimulationStatus();
     m_SimulationTimer->stop();
     m_Controls->m_AbortSimulationButton->setVisible(false);
     m_Controls->m_GenerateImageButton->setVisible(true);
     //m_Controls->m_SimulationStatusText->setVisible(false);
     m_ThreadIsRunning = false;
 
+    mitk::DiffusionImage<short>::Pointer mitkImage = mitk::DiffusionImage<short>::New();
     switch (m_Worker.m_FilterType)
     {
     case 0:
     {
         if (m_TractsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
-        mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
-        image->SetVectorImage( m_TractsToDwiFilter->GetOutput() );
-        image->SetB_Value(m_ImageGenParametersBackup.b_value);
-        image->SetDirections(m_ImageGenParametersBackup.gradientDirections);
-        image->InitializeFromVectorImage();
-        m_ImageGenParametersBackup.resultNode->SetData( image );
+        mitkImage->SetVectorImage( m_TractsToDwiFilter->GetOutput() );
+        mitkImage->SetB_Value(m_ImageGenParametersBackup.b_value);
+        mitkImage->SetDirections(m_ImageGenParametersBackup.gradientDirections);
+        mitkImage->InitializeFromVectorImage();
+        m_ImageGenParametersBackup.resultNode->SetData( mitkImage );
 
         m_ImageGenParametersBackup.resultNode->SetName(m_ImageGenParametersBackup.parentNode->GetName()
                                                        +"_D"+QString::number(m_ImageGenParametersBackup.imageRegion.GetSize(0)).toStdString()
                                                        +"-"+QString::number(m_ImageGenParametersBackup.imageRegion.GetSize(1)).toStdString()
                                                        +"-"+QString::number(m_ImageGenParametersBackup.imageRegion.GetSize(2)).toStdString()
                                                        +"_S"+QString::number(m_ImageGenParametersBackup.imageSpacing[0]).toStdString()
                 +"-"+QString::number(m_ImageGenParametersBackup.imageSpacing[1]).toStdString()
                 +"-"+QString::number(m_ImageGenParametersBackup.imageSpacing[2]).toStdString()
                 +"_b"+QString::number(m_ImageGenParametersBackup.b_value).toStdString()
                 +"_"+m_ImageGenParametersBackup.signalModelString.toStdString()
                 +m_ImageGenParametersBackup.artifactModelString.toStdString());
 
         GetDataStorage()->Add(m_ImageGenParametersBackup.resultNode, m_ImageGenParametersBackup.parentNode);
 
         m_ImageGenParametersBackup.resultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
 
-        if (!m_ImageGenParametersBackup.outputPath.isEmpty())
-        {
-            mitk::NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
-            writer->SetFileName(m_ImageGenParametersBackup.outputPath.toStdString()+m_ImageGenParametersBackup.resultNode->GetName()+".dwi");
-            writer->SetInput(image);
-            writer->Update();
-        }
-
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
             for (int k=0; k<volumeFractions.size(); k++)
             {
                 mitk::Image::Pointer image = mitk::Image::New();
                 image->InitializeByItk(volumeFractions.at(k).GetPointer());
                 image->SetVolume(volumeFractions.at(k)->GetBufferPointer());
 
                 mitk::DataNode::Pointer node = mitk::DataNode::New();
                 node->SetData( image );
                 node->SetName(m_ImageGenParametersBackup.parentNode->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, m_ImageGenParametersBackup.parentNode);
             }
         }
         break;
     }
     case 1:
     {
         if (m_ArtifactsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(m_ImageGenParametersBackup.parentNode->GetData());
-        mitk::DiffusionImage<short>::Pointer image = mitk::DiffusionImage<short>::New();
-        image->SetVectorImage( m_ArtifactsToDwiFilter->GetOutput() );
-        image->SetB_Value(diffImg->GetB_Value());
-        image->SetDirections(diffImg->GetDirections());
-        image->InitializeFromVectorImage();
-        m_ImageGenParametersBackup.resultNode->SetData( image );
+        mitkImage = mitk::DiffusionImage<short>::New();
+        mitkImage->SetVectorImage( m_ArtifactsToDwiFilter->GetOutput() );
+        mitkImage->SetB_Value(diffImg->GetB_Value());
+        mitkImage->SetDirections(diffImg->GetDirections());
+        mitkImage->InitializeFromVectorImage();
+        m_ImageGenParametersBackup.resultNode->SetData( mitkImage );
         m_ImageGenParametersBackup.resultNode->SetName(m_ImageGenParametersBackup.parentNode->GetName()+m_ImageGenParameters.artifactModelString.toStdString());
         GetDataStorage()->Add(m_ImageGenParametersBackup.resultNode, m_ImageGenParametersBackup.parentNode);
         break;
     }
     }
 
     mitk::BaseData::Pointer basedata = m_ImageGenParametersBackup.resultNode->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
+
+    if (!m_ImageGenParametersBackup.outputPath.isEmpty())
+    {
+        try{
+            QString status("\nSaving output image to ");
+            status += m_ImageGenParametersBackup.outputPath;
+            status += m_ImageGenParametersBackup.resultNode->GetName().c_str();
+            status += ".dwi";
+            m_Controls->m_SimulationStatusText->append(status);
+            mitk::NrrdDiffusionImageWriter<short>::Pointer writer = NrrdDiffusionImageWriter<short>::New();
+            writer->SetFileName(m_ImageGenParametersBackup.outputPath.toStdString()+m_ImageGenParametersBackup.resultNode->GetName()+".dwi");
+            writer->SetInput(mitkImage);
+            writer->Update();
+            m_Controls->m_SimulationStatusText->append("File saved successfully.");
+        }
+        catch (itk::ExceptionObject &e)
+        {
+            QString status("\nException during DWI writing: ");
+            status += e.GetDescription();
+            m_Controls->m_SimulationStatusText->append(status);
+        }
+        catch (...)
+        {
+            m_Controls->m_SimulationStatusText->append("\nUnknown exception during DWI writing!");
+        }
+    }
 }
 
 void QmitkFiberfoxView::UpdateSimulationStatus()
 {
     QString statusText;
     switch (m_Worker.m_FilterType)
     {
     case 0:
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         break;
     case 1:
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         break;
     }
 
     if (QString::compare(m_SimulationStatusText,statusText)!=0)
     {
         m_Controls->m_SimulationStatusText->clear();
         statusText = "<pre>"+statusText+"</pre>";
         m_Controls->m_SimulationStatusText->setText(statusText);
     }
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
     if (m_ImageGenParameters.noiseModel!=NULL)
         delete m_ImageGenParameters.noiseModel;
     if (m_ImageGenParameters.noiseModelShort!=NULL)
         delete m_ImageGenParameters.noiseModelShort;
     delete m_SimulationTimer;
 }
 
 void QmitkFiberfoxView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFiberfoxViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_StickWidget1->setVisible(true);
         m_Controls->m_StickWidget2->setVisible(false);
         m_Controls->m_ZeppelinWidget1->setVisible(false);
         m_Controls->m_ZeppelinWidget2->setVisible(false);
         m_Controls->m_TensorWidget1->setVisible(false);
         m_Controls->m_TensorWidget2->setVisible(false);
 
         m_Controls->m_BallWidget1->setVisible(true);
         m_Controls->m_BallWidget2->setVisible(false);
         m_Controls->m_AstrosticksWidget1->setVisible(false);
         m_Controls->m_AstrosticksWidget2->setVisible(false);
         m_Controls->m_DotWidget1->setVisible(false);
         m_Controls->m_DotWidget2->setVisible(false);
 
         m_Controls->m_Comp4FractionFrame->setVisible(false);
         m_Controls->m_DiffusionPropsMessage->setVisible(false);
         m_Controls->m_GeometryMessage->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_VarianceBox->setVisible(false);
         m_Controls->m_NoiseFrame->setVisible(false);
         m_Controls->m_GhostFrame->setVisible(false);
         m_Controls->m_DistortionsFrame->setVisible(false);
         m_Controls->m_EddyFrame->setVisible(false);
         m_Controls->m_SpikeFrame->setVisible(false);
         m_Controls->m_AliasingFrame->setVisible(false);
         m_Controls->m_MotionArtifactFrame->setVisible(false);
         m_ParameterFile = QDir::currentPath()+"/param.ffp";
 
         m_Controls->m_AbortSimulationButton->setVisible(false);
         m_Controls->m_SimulationStatusText->setVisible(false);
 
         m_Controls->m_FrequencyMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_FrequencyMapBox->SetPredicate(finalPredicate);
 
         connect( m_SimulationTimer, SIGNAL(timeout()), this, SLOT(UpdateSimulationStatus()) );
         connect((QObject*) m_Controls->m_AbortSimulationButton, SIGNAL(clicked()), (QObject*) this, SLOT(KillThread()));
         connect((QObject*) m_Controls->m_GenerateImageButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateImage()));
         connect((QObject*) m_Controls->m_GenerateFibersButton, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFibers()));
         connect((QObject*) m_Controls->m_CircleButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnDrawROI()));
         connect((QObject*) m_Controls->m_FlipButton, SIGNAL(clicked()), (QObject*) this, SLOT(OnFlipButton()));
         connect((QObject*) m_Controls->m_JoinBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(JoinBundles()));
         connect((QObject*) m_Controls->m_VarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_DistributionBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnDistributionChanged(int)));
         connect((QObject*) m_Controls->m_FiberDensityBox, SIGNAL(valueChanged(int)), (QObject*) this, SLOT(OnFiberDensityChanged(int)));
         connect((QObject*) m_Controls->m_FiberSamplingBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnFiberSamplingChanged(double)));
         connect((QObject*) m_Controls->m_TensionBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnTensionChanged(double)));
         connect((QObject*) m_Controls->m_ContinuityBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnContinuityChanged(double)));
         connect((QObject*) m_Controls->m_BiasBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnBiasChanged(double)));
         connect((QObject*) m_Controls->m_AddNoise, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddNoise(int)));
         connect((QObject*) m_Controls->m_AddGhosts, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddGhosts(int)));
         connect((QObject*) m_Controls->m_AddDistortions, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddDistortions(int)));
         connect((QObject*) m_Controls->m_AddEddy, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddEddy(int)));
         connect((QObject*) m_Controls->m_AddSpikes, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddSpikes(int)));
         connect((QObject*) m_Controls->m_AddAliasing, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddAliasing(int)));
         connect((QObject*) m_Controls->m_AddMotion, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnAddMotion(int)));
 
         connect((QObject*) m_Controls->m_ConstantRadiusBox, SIGNAL(stateChanged(int)), (QObject*) this, SLOT(OnConstantRadius(int)));
         connect((QObject*) m_Controls->m_CopyBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(CopyBundles()));
         connect((QObject*) m_Controls->m_TransformBundlesButton, SIGNAL(clicked()), (QObject*) this, SLOT(ApplyTransform()));
         connect((QObject*) m_Controls->m_AlignOnGrid, SIGNAL(clicked()), (QObject*) this, SLOT(AlignOnGrid()));
 
         connect((QObject*) m_Controls->m_Compartment1Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp1ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment2Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp2ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment3Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp3ModelFrameVisibility(int)));
         connect((QObject*) m_Controls->m_Compartment4Box, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(Comp4ModelFrameVisibility(int)));
 
         connect((QObject*) m_Controls->m_AdvancedOptionsBox, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
         connect((QObject*) m_Controls->m_AdvancedOptionsBox_2, SIGNAL( stateChanged(int)), (QObject*) this, SLOT(ShowAdvancedOptions(int)));
 
         connect((QObject*) m_Controls->m_SaveParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(SaveParameters()));
         connect((QObject*) m_Controls->m_LoadParametersButton, SIGNAL(clicked()), (QObject*) this, SLOT(LoadParameters()));
         connect((QObject*) m_Controls->m_OutputPathButton, SIGNAL(clicked()), (QObject*) this, SLOT(SetOutputPath()));
 
     }
 }
 
 void QmitkFiberfoxView::UpdateImageParameters()
 {
     m_ImageGenParameters.nonFiberModelList.clear();
     m_ImageGenParameters.fiberModelList.clear();
     m_ImageGenParameters.signalModelString = "";
     m_ImageGenParameters.artifactModelString = "";
     m_ImageGenParameters.resultNode = mitk::DataNode::New();
     m_ImageGenParameters.frequencyMap = NULL;
     m_ImageGenParameters.gradientDirections.clear();
     m_ImageGenParameters.spikes = 0;
     m_ImageGenParameters.spikeAmplitude = 1;
     m_ImageGenParameters.wrap = 1;
     m_ImageGenParameters.outputPath = m_OutputPath;
 
     if (m_SelectedDWI.IsNotNull())  // use parameters of selected DWI
     {
         mitk::DiffusionImage<short>::Pointer dwi = dynamic_cast<mitk::DiffusionImage<short>*>(m_SelectedDWI->GetData());
         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++;
         }
     }
     else if (m_SelectedImage.IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImage->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         m_ImageGenParameters.imageRegion = itkImg->GetLargestPossibleRegion();
         m_ImageGenParameters.imageSpacing = itkImg->GetSpacing();
         m_ImageGenParameters.imageOrigin = itkImg->GetOrigin();
         m_ImageGenParameters.imageDirection = itkImg->GetDirection();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         m_ImageGenParameters.imageRegion.SetSize(0, m_Controls->m_SizeX->value());
         m_ImageGenParameters.imageRegion.SetSize(1, m_Controls->m_SizeY->value());
         m_ImageGenParameters.imageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         m_ImageGenParameters.imageSpacing[0] = m_Controls->m_SpacingX->value();
         m_ImageGenParameters.imageSpacing[1] = m_Controls->m_SpacingY->value();
         m_ImageGenParameters.imageSpacing[2] = m_Controls->m_SpacingZ->value();
         m_ImageGenParameters.imageOrigin[0] = m_ImageGenParameters.imageSpacing[0]/2;
         m_ImageGenParameters.imageOrigin[1] = m_ImageGenParameters.imageSpacing[1]/2;
         m_ImageGenParameters.imageOrigin[2] = m_ImageGenParameters.imageSpacing[2]/2;
         m_ImageGenParameters.imageDirection.SetIdentity();
 
         m_ImageGenParameters.numGradients = m_Controls->m_NumGradientsBox->value();
         m_ImageGenParameters.gradientDirections = GenerateHalfShell(m_Controls->m_NumGradientsBox->value());;
         m_ImageGenParameters.b_value = m_Controls->m_BvalueBox->value();
     }
 
     // signal relaxation
     m_ImageGenParameters.doSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     if (m_ImageGenParameters.doSimulateRelaxation && m_SelectedBundles.size()>0 )
         m_ImageGenParameters.artifactModelString += "_RELAX";
 
     // N/2 ghosts
     if (m_Controls->m_AddGhosts->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_GHOST";
         m_ImageGenParameters.kspaceLineOffset = m_Controls->m_kOffsetBox->value();
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(m_ImageGenParameters.kspaceLineOffset));
     }
     else
         m_ImageGenParameters.kspaceLineOffset = 0;
 
     // Aliasing
     if (m_Controls->m_AddAliasing->isChecked())
     {
         m_ImageGenParameters.artifactModelString += "_ALIASING";
         m_ImageGenParameters.wrap = (100-m_Controls->m_WrapBox->value())/100;
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
     }
 
     // Motion
     m_ImageGenParameters.doAddMotion = m_Controls->m_AddMotion->isChecked();
     m_ImageGenParameters.randomMotion = m_Controls->m_RandomMotion->isChecked();
     m_ImageGenParameters.translation[0] = m_Controls->m_MaxTranslationBoxX->value();
     m_ImageGenParameters.translation[1] = m_Controls->m_MaxTranslationBoxY->value();
     m_ImageGenParameters.translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
     m_ImageGenParameters.rotation[0] = m_Controls->m_MaxRotationBoxX->value();
     m_ImageGenParameters.rotation[1] = m_Controls->m_MaxRotationBoxY->value();
     m_ImageGenParameters.rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
     if ( m_Controls->m_AddMotion->isChecked() && m_SelectedBundles.size()>0 )
     {
         m_ImageGenParameters.artifactModelString += "_MOTION";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(m_ImageGenParameters.randomMotion));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(m_ImageGenParameters.translation[0]));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(m_ImageGenParameters.translation[1]));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(m_ImageGenParameters.translation[2]));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(m_ImageGenParameters.rotation[0]));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(m_ImageGenParameters.rotation[1]));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(m_ImageGenParameters.rotation[2]));
     }
 
     // other imaging parameters
     m_ImageGenParameters.tLine = m_Controls->m_LineReadoutTimeBox->value();
     m_ImageGenParameters.tInhom = m_Controls->m_T2starBox->value();
     m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
     m_ImageGenParameters.repetitions = m_Controls->m_RepetitionsBox->value();
     m_ImageGenParameters.doDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     m_ImageGenParameters.interpolationShrink = m_Controls->m_InterpolationShrink->value();
     m_ImageGenParameters.axonRadius = m_Controls->m_FiberRadius->value();
     m_ImageGenParameters.signalScale = m_Controls->m_SignalScaleBox->value();
 
     if (m_Controls->m_AddSpikes->isChecked())
     {
         m_ImageGenParameters.spikes = m_Controls->m_SpikeNumBox->value();
         m_ImageGenParameters.spikeAmplitude = m_Controls->m_SpikeScaleBox->value();
         m_ImageGenParameters.artifactModelString += "_SPIKES";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(m_ImageGenParameters.spikes));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(m_ImageGenParameters.spikeAmplitude));
 
     }
 
     // adjust echo time if needed
     if ( m_ImageGenParameters.tEcho < m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine )
     {
         this->m_Controls->m_TEbox->setValue( m_ImageGenParameters.imageRegion.GetSize(1)*m_ImageGenParameters.tLine );
         m_ImageGenParameters.tEcho = m_Controls->m_TEbox->value();
         QMessageBox::information( NULL, "Warning", "Echo time is too short! Time not sufficient to read slice. Automaticall adjusted to "+QString::number(m_ImageGenParameters.tEcho)+" ms");
     }
 
     // rician noise
     if (m_Controls->m_AddNoise->isChecked())
     {
         if (m_ImageGenParameters.noiseModel!=NULL)
             delete m_ImageGenParameters.noiseModel;
         if (m_ImageGenParameters.noiseModelShort!=NULL)
             delete m_ImageGenParameters.noiseModelShort;
 
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         {
             switch (m_Controls->m_NoiseDistributionBox->currentIndex())
             {
             case 0:
             {
                 mitk::RicianNoiseModel<double>* rician = new mitk::RicianNoiseModel<double>();
                 rician->SetNoiseVariance(noiseVariance);
                 m_ImageGenParameters.noiseModel = rician;
                 m_ImageGenParameters.artifactModelString += "_RICIAN-";
                 m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
                 break;
             }
             case 1:
             {
                 mitk::ChiSquareNoiseModel<double>* chiSquare = new mitk::ChiSquareNoiseModel<double>();
                 chiSquare->SetDOF(noiseVariance/2);
                 m_ImageGenParameters.noiseModel = chiSquare;
                 m_ImageGenParameters.artifactModelString += "_CHISQUARED-";
                 m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
                 break;
             }
             default:
             {
                 mitk::RicianNoiseModel<double>* rician = new mitk::RicianNoiseModel<double>();
                 rician->SetNoiseVariance(noiseVariance);
                 m_ImageGenParameters.noiseModel = rician;
                 m_ImageGenParameters.artifactModelString += "_RICIAN-";
                 m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
             }
             }
         }
         {
             switch (m_Controls->m_NoiseDistributionBox->currentIndex())
             {
             case 0:
             {
                 mitk::RicianNoiseModel<short>* rician = new mitk::RicianNoiseModel<short>();
                 rician->SetNoiseVariance(noiseVariance);
                 m_ImageGenParameters.noiseModelShort = rician;
                 break;
             }
             case 1:
             {
                 mitk::ChiSquareNoiseModel<short>* chiSquare = new mitk::ChiSquareNoiseModel<short>();
                 chiSquare->SetDOF(noiseVariance/2);
                 m_ImageGenParameters.noiseModelShort = chiSquare;
                 break;
             }
             default:
             {
                 mitk::RicianNoiseModel<short>* rician = new mitk::RicianNoiseModel<short>();
                 rician->SetNoiseVariance(noiseVariance);
                 m_ImageGenParameters.noiseModelShort = rician;
             }
             }
         }
         m_ImageGenParameters.artifactModelString += QString::number(noiseVariance);
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
     else
     {
         if (m_ImageGenParameters.noiseModel!=NULL)
         {
             delete m_ImageGenParameters.noiseModel;
             m_ImageGenParameters.noiseModel = NULL;
         }
         if (m_ImageGenParameters.noiseModelShort!=NULL)
         {
             delete m_ImageGenParameters.noiseModelShort;
             m_ImageGenParameters.noiseModelShort = NULL;
         }
     }
 
     // gibbs ringing
     m_ImageGenParameters.addGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
         m_ImageGenParameters.artifactModelString += "_RINGING";
     }
 
     // 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;
 
     // add distortions
     if (m_Controls->m_AddDistortions->isChecked() && m_Controls->m_FrequencyMapBox->GetSelectedNode().IsNotNull())
     {
         mitk::DataNode::Pointer fMapNode = m_Controls->m_FrequencyMapBox->GetSelectedNode();
         mitk::Image* img = dynamic_cast<mitk::Image*>(fMapNode->GetData());
         ItkDoubleImgType::Pointer itkImg = ItkDoubleImgType::New();
         CastToItkImage< ItkDoubleImgType >(img, 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;
             m_ImageGenParameters.artifactModelString += "_DISTORTED";
             m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
         }
     }
 
     m_ImageGenParameters.doSimulateEddyCurrents = m_Controls->m_AddEddy->isChecked();
     m_ImageGenParameters.eddyStrength = 0;
     if (m_Controls->m_AddEddy->isChecked())
     {
         m_ImageGenParameters.eddyStrength = m_Controls->m_EddyGradientStrength->value();
         m_ImageGenParameters.artifactModelString += "_EDDY";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(m_ImageGenParameters.eddyStrength));
     }
 
     // signal models
     m_ImageGenParameters.comp3Weight = 1;
     m_ImageGenParameters.comp4Weight = 0;
     if (m_Controls->m_Compartment4Box->currentIndex()>0)
     {
         m_ImageGenParameters.comp4Weight = m_Controls->m_Comp4FractionBox->value();
         m_ImageGenParameters.comp3Weight -= m_ImageGenParameters.comp4Weight;
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.weight", DoubleProperty::New(m_ImageGenParameters.comp3Weight));
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.weight", DoubleProperty::New(m_ImageGenParameters.comp4Weight));
     }
 
     // compartment 1
     switch (m_Controls->m_Compartment1Box->currentIndex())
     {
     case 0:
         m_StickModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel1.SetDiffusivity(m_Controls->m_StickWidget1->GetD());
         m_StickModel1.SetT2(m_Controls->m_StickWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel1);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_StickModel1.GetT2()) );
         break;
     case 1:
         m_ZeppelinModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel1.SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
         m_ZeppelinModel1.SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
         m_ZeppelinModel1.SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel1);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     case 2:
         m_TensorModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel1.SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
         m_TensorModel1.SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
         m_TensorModel1.SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
         m_TensorModel1.SetT2(m_Controls->m_TensorWidget1->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel1);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(m_ZeppelinModel1.GetT2()) );
         break;
     }
 
     // compartment 2
     switch (m_Controls->m_Compartment2Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_StickModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_StickModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_StickModel2.SetDiffusivity(m_Controls->m_StickWidget2->GetD());
         m_StickModel2.SetT2(m_Controls->m_StickWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_StickModel2);
         m_ImageGenParameters.signalModelString += "Stick";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_StickModel2.GetT2()) );
         break;
     case 2:
         m_ZeppelinModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_ZeppelinModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_ZeppelinModel2.SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
         m_ZeppelinModel2.SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
         m_ZeppelinModel2.SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_ZeppelinModel2);
         m_ImageGenParameters.signalModelString += "Zeppelin";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     case 3:
         m_TensorModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_TensorModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_TensorModel2.SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
         m_TensorModel2.SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
         m_TensorModel2.SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
         m_TensorModel2.SetT2(m_Controls->m_TensorWidget2->GetT2());
         m_ImageGenParameters.fiberModelList.push_back(&m_TensorModel2);
         m_ImageGenParameters.signalModelString += "Tensor";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(m_ZeppelinModel2.GetT2()) );
         break;
     }
 
     // compartment 3
     switch (m_Controls->m_Compartment3Box->currentIndex())
     {
     case 0:
         m_BallModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel1.SetDiffusivity(m_Controls->m_BallWidget1->GetD());
         m_BallModel1.SetT2(m_Controls->m_BallWidget1->GetT2());
         m_BallModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel1);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_BallModel1.GetT2()) );
         break;
     case 1:
         m_AstrosticksModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel1.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel1.SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
         m_AstrosticksModel1.SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
         m_AstrosticksModel1.SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
         m_AstrosticksModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel1);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_AstrosticksModel1.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
         break;
     case 2:
         m_DotModel1.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel1.SetT2(m_Controls->m_DotWidget1->GetT2());
         m_DotModel1.SetWeight(m_ImageGenParameters.comp3Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel1);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(m_DotModel1.GetT2()) );
         break;
     }
 
     // compartment 4
     switch (m_Controls->m_Compartment4Box->currentIndex())
     {
     case 0:
         break;
     case 1:
         m_BallModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_BallModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_BallModel2.SetDiffusivity(m_Controls->m_BallWidget2->GetD());
         m_BallModel2.SetT2(m_Controls->m_BallWidget2->GetT2());
         m_BallModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_BallModel2);
         m_ImageGenParameters.signalModelString += "Ball";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_BallModel2.GetT2()) );
         break;
     case 2:
         m_AstrosticksModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_AstrosticksModel2.SetBvalue(m_ImageGenParameters.b_value);
         m_AstrosticksModel2.SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
         m_AstrosticksModel2.SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
         m_AstrosticksModel2.SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
         m_AstrosticksModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_AstrosticksModel2);
         m_ImageGenParameters.signalModelString += "Astrosticks";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_AstrosticksModel2.GetT2()) );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
         break;
     case 3:
         m_DotModel2.SetGradientList(m_ImageGenParameters.gradientDirections);
         m_DotModel2.SetT2(m_Controls->m_DotWidget2->GetT2());
         m_DotModel2.SetWeight(m_ImageGenParameters.comp4Weight);
         m_ImageGenParameters.nonFiberModelList.push_back(&m_DotModel2);
         m_ImageGenParameters.signalModelString += "Dot";
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
         m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(m_DotModel2.GetT2()) );
         break;
     }
 
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.InterpolationShrink", IntProperty::New(m_ImageGenParameters.interpolationShrink));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(m_ImageGenParameters.signalScale));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(m_ImageGenParameters.axonRadius));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(m_ImageGenParameters.tInhom));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(m_ImageGenParameters.tLine));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(m_ImageGenParameters.tEcho));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Repetitions", IntProperty::New(m_ImageGenParameters.repetitions));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(m_ImageGenParameters.b_value));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(m_ImageGenParameters.doDisablePartialVolume));
     m_ImageGenParameters.resultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(m_ImageGenParameters.doSimulateRelaxation));
     m_ImageGenParameters.resultNode->AddProperty("binary", BoolProperty::New(false));
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     UpdateImageParameters();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 m_ParameterFile,
                 tr("Fiberfox Parameters (*.ffp)") );
 
     if(filename.isEmpty() || filename.isNull())
         return;
     if(!filename.endsWith(".ffp"))
         filename += ".ffp";
 
     m_ParameterFile = filename;
 
     boost::property_tree::ptree parameters;
 
     // fiber generation parameters
     parameters.put("fiberfox.fibers.realtime", m_Controls->m_RealTimeFibers->isChecked());
     parameters.put("fiberfox.fibers.showadvanced", m_Controls->m_AdvancedOptionsBox->isChecked());
     parameters.put("fiberfox.fibers.distribution", m_Controls->m_DistributionBox->currentIndex());
     parameters.put("fiberfox.fibers.variance", m_Controls->m_VarianceBox->value());
     parameters.put("fiberfox.fibers.density", m_Controls->m_FiberDensityBox->value());
     parameters.put("fiberfox.fibers.spline.sampling", m_Controls->m_FiberSamplingBox->value());
     parameters.put("fiberfox.fibers.spline.tension", m_Controls->m_TensionBox->value());
     parameters.put("fiberfox.fibers.spline.continuity", m_Controls->m_ContinuityBox->value());
     parameters.put("fiberfox.fibers.spline.bias", m_Controls->m_BiasBox->value());
     parameters.put("fiberfox.fibers.constantradius", m_Controls->m_ConstantRadiusBox->isChecked());
     parameters.put("fiberfox.fibers.rotation.x", m_Controls->m_XrotBox->value());
     parameters.put("fiberfox.fibers.rotation.y", m_Controls->m_YrotBox->value());
     parameters.put("fiberfox.fibers.rotation.z", m_Controls->m_ZrotBox->value());
     parameters.put("fiberfox.fibers.translation.x", m_Controls->m_XtransBox->value());
     parameters.put("fiberfox.fibers.translation.y", m_Controls->m_YtransBox->value());
     parameters.put("fiberfox.fibers.translation.z", m_Controls->m_ZtransBox->value());
     parameters.put("fiberfox.fibers.scale.x", m_Controls->m_XscaleBox->value());
     parameters.put("fiberfox.fibers.scale.y", m_Controls->m_YscaleBox->value());
     parameters.put("fiberfox.fibers.scale.z", m_Controls->m_ZscaleBox->value());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
     parameters.put("fiberfox.fibers.includeFiducials", m_Controls->m_IncludeFiducials->isChecked());
 
     // image generation parameters
     parameters.put("fiberfox.image.basic.size.x", m_ImageGenParameters.imageRegion.GetSize(0));
     parameters.put("fiberfox.image.basic.size.y", m_ImageGenParameters.imageRegion.GetSize(1));
     parameters.put("fiberfox.image.basic.size.z", m_ImageGenParameters.imageRegion.GetSize(2));
     parameters.put("fiberfox.image.basic.spacing.x", m_ImageGenParameters.imageSpacing[0]);
     parameters.put("fiberfox.image.basic.spacing.y", m_ImageGenParameters.imageSpacing[1]);
     parameters.put("fiberfox.image.basic.spacing.z", m_ImageGenParameters.imageSpacing[2]);
     parameters.put("fiberfox.image.basic.numgradients", m_ImageGenParameters.numGradients);
     parameters.put("fiberfox.image.basic.bvalue", m_ImageGenParameters.b_value);
     parameters.put("fiberfox.image.showadvanced", m_Controls->m_AdvancedOptionsBox_2->isChecked());
     parameters.put("fiberfox.image.repetitions", m_ImageGenParameters.repetitions);
     parameters.put("fiberfox.image.signalScale", m_ImageGenParameters.signalScale);
     parameters.put("fiberfox.image.tEcho", m_ImageGenParameters.tEcho);
     parameters.put("fiberfox.image.tLine", m_Controls->m_LineReadoutTimeBox->value());
     parameters.put("fiberfox.image.tInhom", m_ImageGenParameters.tInhom);
     parameters.put("fiberfox.image.axonRadius", m_ImageGenParameters.axonRadius);
     parameters.put("fiberfox.image.interpolationShrink", m_ImageGenParameters.interpolationShrink);
     parameters.put("fiberfox.image.doSimulateRelaxation", m_ImageGenParameters.doSimulateRelaxation);
     parameters.put("fiberfox.image.doDisablePartialVolume", m_ImageGenParameters.doDisablePartialVolume);
     parameters.put("fiberfox.image.outputvolumefractions", m_Controls->m_VolumeFractionsBox->isChecked());
 
     parameters.put("fiberfox.image.artifacts.addnoise", m_Controls->m_AddNoise->isChecked());
     parameters.put("fiberfox.image.artifacts.noisedistribution", m_Controls->m_NoiseDistributionBox->currentIndex());
     parameters.put("fiberfox.image.artifacts.noisevariance", m_Controls->m_NoiseLevel->value());
     parameters.put("fiberfox.image.artifacts.addghost", m_Controls->m_AddGhosts->isChecked());
     parameters.put("fiberfox.image.artifacts.kspaceLineOffset", m_Controls->m_kOffsetBox->value());
     parameters.put("fiberfox.image.artifacts.distortions", m_Controls->m_AddDistortions->isChecked());
     parameters.put("fiberfox.image.artifacts.addeddy", m_Controls->m_AddEddy->isChecked());
     parameters.put("fiberfox.image.artifacts.eddyStrength", m_Controls->m_EddyGradientStrength->value());
     parameters.put("fiberfox.image.artifacts.addringing", m_Controls->m_AddGibbsRinging->isChecked());
     parameters.put("fiberfox.image.artifacts.addspikes", m_Controls->m_AddSpikes->isChecked());
     parameters.put("fiberfox.image.artifacts.spikesnum", m_Controls->m_SpikeNumBox->value());
     parameters.put("fiberfox.image.artifacts.spikesscale", m_Controls->m_SpikeScaleBox->value());
     parameters.put("fiberfox.image.artifacts.addaliasing", m_Controls->m_AddAliasing->isChecked());
     parameters.put("fiberfox.image.artifacts.aliasingfactor", m_Controls->m_WrapBox->value());
     parameters.put("fiberfox.image.artifacts.doAddMotion", m_Controls->m_AddMotion->isChecked());
     parameters.put("fiberfox.image.artifacts.randomMotion", m_Controls->m_RandomMotion->isChecked());
     parameters.put("fiberfox.image.artifacts.translation0", m_Controls->m_MaxTranslationBoxX->value());
     parameters.put("fiberfox.image.artifacts.translation1", m_Controls->m_MaxTranslationBoxY->value());
     parameters.put("fiberfox.image.artifacts.translation2", m_Controls->m_MaxTranslationBoxZ->value());
     parameters.put("fiberfox.image.artifacts.rotation0", m_Controls->m_MaxRotationBoxX->value());
     parameters.put("fiberfox.image.artifacts.rotation1", m_Controls->m_MaxRotationBoxY->value());
     parameters.put("fiberfox.image.artifacts.rotation2", m_Controls->m_MaxRotationBoxZ->value());
 
     parameters.put("fiberfox.image.compartment1.index", m_Controls->m_Compartment1Box->currentIndex());
     parameters.put("fiberfox.image.compartment2.index", m_Controls->m_Compartment2Box->currentIndex());
     parameters.put("fiberfox.image.compartment3.index", m_Controls->m_Compartment3Box->currentIndex());
     parameters.put("fiberfox.image.compartment4.index", m_Controls->m_Compartment4Box->currentIndex());
 
     parameters.put("fiberfox.image.compartment1.stick.d", m_Controls->m_StickWidget1->GetD());
     parameters.put("fiberfox.image.compartment1.stick.t2", m_Controls->m_StickWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.zeppelin.d1", m_Controls->m_ZeppelinWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.zeppelin.d2", m_Controls->m_ZeppelinWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.zeppelin.t2", m_Controls->m_ZeppelinWidget1->GetT2());
     parameters.put("fiberfox.image.compartment1.tensor.d1", m_Controls->m_TensorWidget1->GetD1());
     parameters.put("fiberfox.image.compartment1.tensor.d2", m_Controls->m_TensorWidget1->GetD2());
     parameters.put("fiberfox.image.compartment1.tensor.d3", m_Controls->m_TensorWidget1->GetD3());
     parameters.put("fiberfox.image.compartment1.tensor.t2", m_Controls->m_TensorWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment2.stick.d", m_Controls->m_StickWidget2->GetD());
     parameters.put("fiberfox.image.compartment2.stick.t2", m_Controls->m_StickWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.zeppelin.d1", m_Controls->m_ZeppelinWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.zeppelin.d2", m_Controls->m_ZeppelinWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.zeppelin.t2", m_Controls->m_ZeppelinWidget2->GetT2());
     parameters.put("fiberfox.image.compartment2.tensor.d1", m_Controls->m_TensorWidget2->GetD1());
     parameters.put("fiberfox.image.compartment2.tensor.d2", m_Controls->m_TensorWidget2->GetD2());
     parameters.put("fiberfox.image.compartment2.tensor.d3", m_Controls->m_TensorWidget2->GetD3());
     parameters.put("fiberfox.image.compartment2.tensor.t2", m_Controls->m_TensorWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment3.ball.d", m_Controls->m_BallWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.ball.t2", m_Controls->m_BallWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.d", m_Controls->m_AstrosticksWidget1->GetD());
     parameters.put("fiberfox.image.compartment3.astrosticks.t2", m_Controls->m_AstrosticksWidget1->GetT2());
     parameters.put("fiberfox.image.compartment3.astrosticks.randomize", m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment3.dot.t2", m_Controls->m_DotWidget1->GetT2());
 
     parameters.put("fiberfox.image.compartment4.ball.d", m_Controls->m_BallWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.ball.t2", m_Controls->m_BallWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.d", m_Controls->m_AstrosticksWidget2->GetD());
     parameters.put("fiberfox.image.compartment4.astrosticks.t2", m_Controls->m_AstrosticksWidget2->GetT2());
     parameters.put("fiberfox.image.compartment4.astrosticks.randomize", m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
     parameters.put("fiberfox.image.compartment4.dot.t2", m_Controls->m_DotWidget2->GetT2());
 
     parameters.put("fiberfox.image.compartment4.weight", m_Controls->m_Comp4FractionBox->value());
 
     boost::property_tree::xml_parser::write_xml(filename.toStdString(), parameters);
 }
 
 void QmitkFiberfoxView::LoadParameters()
 {
     QString filename = QFileDialog::getOpenFileName(0, tr("Load Parameters"), QString(itksys::SystemTools::GetFilenamePath(m_ParameterFile.toStdString()).c_str()), tr("Fiberfox Parameters (*.ffp)") );
     if(filename.isEmpty() || filename.isNull())
         return;
 
     m_ParameterFile = filename;
 
     boost::property_tree::ptree parameters;
     boost::property_tree::xml_parser::read_xml(filename.toStdString(), parameters);
 
     BOOST_FOREACH( boost::property_tree::ptree::value_type const& v1, parameters.get_child("fiberfox") )
     {
         if( v1.first == "fibers" )
         {
             m_Controls->m_RealTimeFibers->setChecked(v1.second.get<bool>("realtime"));
             m_Controls->m_AdvancedOptionsBox->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_DistributionBox->setCurrentIndex(v1.second.get<int>("distribution"));
             m_Controls->m_VarianceBox->setValue(v1.second.get<double>("variance"));
             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"));
             m_Controls->m_AdvancedOptionsBox_2->setChecked(v1.second.get<bool>("showadvanced"));
             m_Controls->m_RepetitionsBox->setValue(v1.second.get<int>("repetitions"));
             m_Controls->m_SignalScaleBox->setValue(v1.second.get<int>("signalScale"));
             m_Controls->m_TEbox->setValue(v1.second.get<double>("tEcho"));
             m_Controls->m_LineReadoutTimeBox->setValue(v1.second.get<double>("tLine"));
             m_Controls->m_T2starBox->setValue(v1.second.get<double>("tInhom"));
             m_Controls->m_FiberRadius->setValue(v1.second.get<double>("axonRadius"));
             m_Controls->m_InterpolationShrink->setValue(v1.second.get<int>("interpolationShrink"));
             m_Controls->m_RelaxationBox->setChecked(v1.second.get<bool>("doSimulateRelaxation"));
             m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(v1.second.get<bool>("doDisablePartialVolume"));
             m_Controls->m_VolumeFractionsBox->setChecked(v1.second.get<bool>("outputvolumefractions"));
 
             m_Controls->m_AddNoise->setChecked(v1.second.get<bool>("artifacts.addnoise"));
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(v1.second.get<int>("artifacts.noisedistribution"));
             m_Controls->m_NoiseLevel->setValue(v1.second.get<double>("artifacts.noisevariance"));
             m_Controls->m_AddGhosts->setChecked(v1.second.get<bool>("artifacts.addghost"));
             m_Controls->m_kOffsetBox->setValue(v1.second.get<double>("artifacts.kspaceLineOffset"));
             m_Controls->m_AddAliasing->setChecked(v1.second.get<bool>("artifacts.addaliasing"));
             m_Controls->m_WrapBox->setValue(v1.second.get<double>("artifacts.aliasingfactor"));
             m_Controls->m_AddDistortions->setChecked(v1.second.get<bool>("artifacts.distortions"));
             m_Controls->m_AddSpikes->setChecked(v1.second.get<bool>("artifacts.addspikes"));
             m_Controls->m_SpikeNumBox->setValue(v1.second.get<int>("artifacts.spikesnum"));
             m_Controls->m_SpikeScaleBox->setValue(v1.second.get<double>("artifacts.spikesscale"));
             m_Controls->m_AddEddy->setChecked(v1.second.get<bool>("artifacts.addeddy"));
             m_Controls->m_EddyGradientStrength->setValue(v1.second.get<double>("artifacts.eddyStrength"));
             m_Controls->m_AddGibbsRinging->setChecked(v1.second.get<bool>("artifacts.addringing"));
             m_Controls->m_AddMotion->setChecked(v1.second.get<bool>("artifacts.doAddMotion"));
             m_Controls->m_RandomMotion->setChecked(v1.second.get<bool>("artifacts.randomMotion"));
             m_Controls->m_MaxTranslationBoxX->setValue(v1.second.get<double>("artifacts.translation0"));
             m_Controls->m_MaxTranslationBoxY->setValue(v1.second.get<double>("artifacts.translation1"));
             m_Controls->m_MaxTranslationBoxZ->setValue(v1.second.get<double>("artifacts.translation2"));
             m_Controls->m_MaxRotationBoxX->setValue(v1.second.get<double>("artifacts.rotation0"));
             m_Controls->m_MaxRotationBoxY->setValue(v1.second.get<double>("artifacts.rotation1"));
             m_Controls->m_MaxRotationBoxZ->setValue(v1.second.get<double>("artifacts.rotation2"));
 
             m_Controls->m_Compartment1Box->setCurrentIndex(v1.second.get<int>("compartment1.index"));
             m_Controls->m_Compartment2Box->setCurrentIndex(v1.second.get<int>("compartment2.index"));
             m_Controls->m_Compartment3Box->setCurrentIndex(v1.second.get<int>("compartment3.index"));
             m_Controls->m_Compartment4Box->setCurrentIndex(v1.second.get<int>("compartment4.index"));
 
             m_Controls->m_StickWidget1->SetD(v1.second.get<double>("compartment1.stick.d"));
             m_Controls->m_StickWidget1->SetT2(v1.second.get<double>("compartment1.stick.t2"));
             m_Controls->m_ZeppelinWidget1->SetD1(v1.second.get<double>("compartment1.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget1->SetD2(v1.second.get<double>("compartment1.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget1->SetT2(v1.second.get<double>("compartment1.zeppelin.t2"));
             m_Controls->m_TensorWidget1->SetD1(v1.second.get<double>("compartment1.tensor.d1"));
             m_Controls->m_TensorWidget1->SetD2(v1.second.get<double>("compartment1.tensor.d2"));
             m_Controls->m_TensorWidget1->SetD3(v1.second.get<double>("compartment1.tensor.d3"));
             m_Controls->m_TensorWidget1->SetT2(v1.second.get<double>("compartment1.tensor.t2"));
 
             m_Controls->m_StickWidget2->SetD(v1.second.get<double>("compartment2.stick.d"));
             m_Controls->m_StickWidget2->SetT2(v1.second.get<double>("compartment2.stick.t2"));
             m_Controls->m_ZeppelinWidget2->SetD1(v1.second.get<double>("compartment2.zeppelin.d1"));
             m_Controls->m_ZeppelinWidget2->SetD2(v1.second.get<double>("compartment2.zeppelin.d2"));
             m_Controls->m_ZeppelinWidget2->SetT2(v1.second.get<double>("compartment2.zeppelin.t2"));
             m_Controls->m_TensorWidget2->SetD1(v1.second.get<double>("compartment2.tensor.d1"));
             m_Controls->m_TensorWidget2->SetD2(v1.second.get<double>("compartment2.tensor.d2"));
             m_Controls->m_TensorWidget2->SetD3(v1.second.get<double>("compartment2.tensor.d3"));
             m_Controls->m_TensorWidget2->SetT2(v1.second.get<double>("compartment2.tensor.t2"));
 
             m_Controls->m_BallWidget1->SetD(v1.second.get<double>("compartment3.ball.d"));
             m_Controls->m_BallWidget1->SetT2(v1.second.get<double>("compartment3.ball.t2"));
             m_Controls->m_AstrosticksWidget1->SetD(v1.second.get<double>("compartment3.astrosticks.d"));
             m_Controls->m_AstrosticksWidget1->SetT2(v1.second.get<double>("compartment3.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(v1.second.get<bool>("compartment3.astrosticks.randomize"));
             m_Controls->m_DotWidget1->SetT2(v1.second.get<double>("compartment3.dot.t2"));
 
             m_Controls->m_BallWidget2->SetD(v1.second.get<double>("compartment4.ball.d"));
             m_Controls->m_BallWidget2->SetT2(v1.second.get<double>("compartment4.ball.t2"));
             m_Controls->m_AstrosticksWidget2->SetD(v1.second.get<double>("compartment4.astrosticks.d"));
             m_Controls->m_AstrosticksWidget2->SetT2(v1.second.get<double>("compartment4.astrosticks.t2"));
             m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(v1.second.get<bool>("compartment4.astrosticks.randomize"));
             m_Controls->m_DotWidget2->SetT2(v1.second.get<double>("compartment4.dot.t2"));
 
             m_Controls->m_Comp4FractionBox->setValue(v1.second.get<double>("compartment4.weight"));
         }
     }
     UpdateImageParameters();
 }
 
 void QmitkFiberfoxView::ShowAdvancedOptions(int state)
 {
     if (state)
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(true);
         m_Controls->m_AdvancedOptionsBox->setChecked(true);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(true);
     }
     else
     {
         m_Controls->m_AdvancedFiberOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedSignalOptionsFrame->setVisible(false);
         m_Controls->m_AdvancedOptionsBox->setChecked(false);
         m_Controls->m_AdvancedOptionsBox_2->setChecked(false);
     }
 }
 
 void QmitkFiberfoxView::Comp1ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget1->setVisible(false);
     m_Controls->m_ZeppelinWidget1->setVisible(false);
     m_Controls->m_TensorWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_StickWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_ZeppelinWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_TensorWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp2ModelFrameVisibility(int index)
 {
     m_Controls->m_StickWidget2->setVisible(false);
     m_Controls->m_ZeppelinWidget2->setVisible(false);
     m_Controls->m_TensorWidget2->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_StickWidget2->setVisible(true);
         break;
     case 2:
         m_Controls->m_ZeppelinWidget2->setVisible(true);
         break;
     case 3:
         m_Controls->m_TensorWidget2->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp3ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget1->setVisible(false);
     m_Controls->m_AstrosticksWidget1->setVisible(false);
     m_Controls->m_DotWidget1->setVisible(false);
 
     switch (index)
     {
     case 0:
         m_Controls->m_BallWidget1->setVisible(true);
         break;
     case 1:
         m_Controls->m_AstrosticksWidget1->setVisible(true);
         break;
     case 2:
         m_Controls->m_DotWidget1->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::Comp4ModelFrameVisibility(int index)
 {
     m_Controls->m_BallWidget2->setVisible(false);
     m_Controls->m_AstrosticksWidget2->setVisible(false);
     m_Controls->m_DotWidget2->setVisible(false);
     m_Controls->m_Comp4FractionFrame->setVisible(false);
 
     switch (index)
     {
     case 0:
         break;
     case 1:
         m_Controls->m_BallWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_AstrosticksWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_DotWidget2->setVisible(true);
         m_Controls->m_Comp4FractionFrame->setVisible(true);
         break;
     }
 }
 
 void QmitkFiberfoxView::OnConstantRadius(int value)
 {
     if (value>0 && m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnAddMotion(int value)
 {
     if (value>0)
         m_Controls->m_MotionArtifactFrame->setVisible(true);
     else
         m_Controls->m_MotionArtifactFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddAliasing(int value)
 {
     if (value>0)
         m_Controls->m_AliasingFrame->setVisible(true);
     else
         m_Controls->m_AliasingFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddSpikes(int value)
 {
     if (value>0)
         m_Controls->m_SpikeFrame->setVisible(true);
     else
         m_Controls->m_SpikeFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddEddy(int value)
 {
     if (value>0)
         m_Controls->m_EddyFrame->setVisible(true);
     else
         m_Controls->m_EddyFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddDistortions(int value)
 {
     if (value>0)
         m_Controls->m_DistortionsFrame->setVisible(true);
     else
         m_Controls->m_DistortionsFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddGhosts(int value)
 {
     if (value>0)
         m_Controls->m_GhostFrame->setVisible(true);
     else
         m_Controls->m_GhostFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnAddNoise(int value)
 {
     if (value>0)
         m_Controls->m_NoiseFrame->setVisible(true);
     else
         m_Controls->m_NoiseFrame->setVisible(false);
 }
 
 void QmitkFiberfoxView::OnDistributionChanged(int value)
 {
     if (value==1)
         m_Controls->m_VarianceBox->setVisible(true);
     else
         m_Controls->m_VarianceBox->setVisible(false);
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnVarianceChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double value)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (int i=0; i<m_SelectedFiducials.size(); i++)
     {
         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
         mitk::DataStorage::SetOfObjects::ConstPointer parentFibs = GetDataStorage()->GetSources(m_SelectedFiducials.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parentFibs->begin(); it != parentFibs->end(); ++it )
         {
             mitk::DataNode::Pointer pFibNode = *it;
             if ( pFibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pFibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(pFibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer pImgNode = *it2;
                     if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
                     {
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(pImgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
 
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
 
                         break;
                     }
                 }
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedBundles2.size(); i++ )
     {
         mitk::DataNode::Pointer fibNode = m_SelectedBundles2.at(i);
 
         mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(fibNode);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = sources->begin(); it != sources->end(); ++it )
         {
             mitk::DataNode::Pointer imgNode = *it;
             if ( imgNode.IsNotNull() && dynamic_cast<mitk::Image*>(imgNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(imgNode->GetData());
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
 
                 break;
             }
         }
     }
 
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_SelectedImages.at(i)->GetData());
 
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations2 = GetDataStorage()->GetDerivations(fibNode);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations2->begin(); it2 != derivations2->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse::Pointer pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Point3D wc0 = pe->GetWorldControlPoint(0);
 
                         mitk::Geometry3D::Pointer geom = img->GetGeometry();
                         itk::Index<3> idx;
                         geom->WorldToIndex(wc0, idx);
                         mitk::Point3D cIdx; cIdx[0]=idx[0]; cIdx[1]=idx[1]; cIdx[2]=idx[2];
                         mitk::Point3D world;
                         geom->IndexToWorld(cIdx,world);
 
                         mitk::Vector3D trans = world - wc0;
                         pe->GetGeometry()->Translate(trans);
                     }
                 }
             }
         }
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFlipButton()
 {
     if (m_SelectedFiducial.IsNull())
         return;
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(m_SelectedFiducial.GetPointer());
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
         data.m_Flipped += 1;
         data.m_Flipped %= 2;
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 QmitkFiberfoxView::GradientListType QmitkFiberfoxView::GenerateHalfShell(int NPoints)
 {
     NPoints *= 2;
     GradientListType pointshell;
 
     int numB0 = NPoints/20;
     if (numB0==0)
         numB0=1;
     GradientType g;
     g.Fill(0.0);
     for (int i=0; i<numB0; i++)
         pointshell.push_back(g);
 
     if (NPoints==0)
         return pointshell;
 
     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)))));
             // % (2*DIST_POINTSHELL_PI);
         }
     }
 
     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));
         pointshell.push_back(g);
     }
 
     return pointshell;
 }
 
 template<int ndirs>
 std::vector<itk::Vector<double,3> > QmitkFiberfoxView::MakeGradientList()
 {
     std::vector<itk::Vector<double,3> > retval;
     vnl_matrix_fixed<double, 3, ndirs>* U =
             itk::PointShell<ndirs, vnl_matrix_fixed<double, 3, ndirs> >::DistributePointShell();
 
 
     // Add 0 vector for B0
     int numB0 = ndirs/10;
     if (numB0==0)
         numB0=1;
     itk::Vector<double,3> v;
     v.Fill(0.0);
     for (int i=0; i<numB0; i++)
     {
         retval.push_back(v);
     }
 
     for(int i=0; i<ndirs;i++)
     {
         itk::Vector<double,3> v;
         v[0] = U->get(0,i); v[1] = U->get(1,i); v[2] = U->get(2,i);
         retval.push_back(v);
     }
 
     return retval;
 }
 
 void QmitkFiberfoxView::OnAddBundle()
 {
     if (m_SelectedImage.IsNull())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
 
     mitk::FiberBundleX::Pointer bundle = mitk::FiberBundleX::New();
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( bundle );
     QString name = QString("Bundle_%1").arg(children->size());
     node->SetName(name.toStdString());
     m_SelectedBundles.push_back(node);
     UpdateGui();
 
     GetDataStorage()->Add(node, m_SelectedImage);
 }
 
 void QmitkFiberfoxView::OnDrawROI()
 {
     if (m_SelectedBundles.empty())
         OnAddBundle();
     if (m_SelectedBundles.empty())
         return;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(0));
 
     mitk::PlanarEllipse::Pointer figure = mitk::PlanarEllipse::New();
 
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetData( figure );
 
     QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
     for( int i=0; i<nodes.size(); i++)
         nodes.at(i)->SetSelected(false);
 
     m_SelectedFiducial = node;
 
     QString name = QString("Fiducial_%1").arg(children->size());
     node->SetName(name.toStdString());
     node->SetSelected(true);
 
     this->DisableCrosshairNavigation();
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
     if(figureInteractor.IsNull())
     {
         figureInteractor = mitk::PlanarFigureInteractor::New();
         us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
         figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
         figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
         figureInteractor->SetDataNode( node );
     }
 
     UpdateGui();
     GetDataStorage()->Add(node, m_SelectedBundles.at(0));
 }
 
 bool CompareLayer(mitk::DataNode::Pointer i,mitk::DataNode::Pointer j)
 {
     int li = -1;
     i->GetPropertyValue("layer", li);
     int lj = -1;
     j->GetPropertyValue("layer", lj);
     return li<lj;
 }
 
 void QmitkFiberfoxView::GenerateFibers()
 {
     if (m_SelectedBundles.empty())
     {
         if (m_SelectedFiducial.IsNull())
             return;
 
         mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(m_SelectedFiducial);
         for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             if(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()))
                 m_SelectedBundles.push_back(*it);
 
         if (m_SelectedBundles.empty())
             return;
     }
 
     vector< vector< mitk::PlanarEllipse::Pointer > > fiducials;
     vector< vector< unsigned int > > fliplist;
     for (int i=0; i<m_SelectedBundles.size(); i++)
     {
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedBundles.at(i));
         std::vector< mitk::DataNode::Pointer > childVector;
         for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
             childVector.push_back(*it);
         sort(childVector.begin(), childVector.end(), CompareLayer);
 
         vector< mitk::PlanarEllipse::Pointer > fib;
         vector< unsigned int > flip;
         float radius = 1;
         int count = 0;
         for( std::vector< mitk::DataNode::Pointer >::const_iterator it = childVector.begin(); it != childVector.end(); ++it )
         {
             mitk::DataNode::Pointer node = *it;
 
             if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
             {
                 mitk::PlanarEllipse* ellipse = dynamic_cast<mitk::PlanarEllipse*>(node->GetData());
                 if (m_Controls->m_ConstantRadiusBox->isChecked())
                 {
                     ellipse->SetTreatAsCircle(true);
                     mitk::Point2D c = ellipse->GetControlPoint(0);
                     mitk::Point2D p = ellipse->GetControlPoint(1);
                     mitk::Vector2D v = p-c;
                     if (count==0)
                     {
                         radius = v.GetVnlVector().magnitude();
                         ellipse->SetControlPoint(1, p);
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                     }
                 }
                 fib.push_back(ellipse);
 
                 std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(node.GetPointer());
                 if( it != m_DataNodeToPlanarFigureData.end() )
                 {
                     QmitkPlanarFigureData& data = it->second;
                     flip.push_back(data.m_Flipped);
                 }
                 else
                     flip.push_back(0);
             }
             count++;
         }
         if (fib.size()>1)
         {
             fiducials.push_back(fib);
             fliplist.push_back(flip);
         }
         else if (fib.size()>0)
             m_SelectedBundles.at(i)->SetData( mitk::FiberBundleX::New() );
 
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     itk::FibersFromPlanarFiguresFilter::Pointer filter = itk::FibersFromPlanarFiguresFilter::New();
     filter->SetFiducials(fiducials);
     filter->SetFlipList(fliplist);
 
     switch(m_Controls->m_DistributionBox->currentIndex()){
     case 0:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_UNIFORM);
         break;
     case 1:
         filter->SetFiberDistribution(itk::FibersFromPlanarFiguresFilter::DISTRIBUTE_GAUSSIAN);
         filter->SetVariance(m_Controls->m_VarianceBox->value());
         break;
     }
 
     filter->SetDensity(m_Controls->m_FiberDensityBox->value());
     filter->SetTension(m_Controls->m_TensionBox->value());
     filter->SetContinuity(m_Controls->m_ContinuityBox->value());
     filter->SetBias(m_Controls->m_BiasBox->value());
     filter->SetFiberSampling(m_Controls->m_FiberSamplingBox->value());
     filter->Update();
     vector< mitk::FiberBundleX::Pointer > fiberBundles = filter->GetFiberBundles();
 
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         m_SelectedBundles.at(i)->SetData( fiberBundles.at(i) );
         if (fiberBundles.at(i)->GetNumFibers()>50000)
             m_SelectedBundles.at(i)->SetVisibility(false);
     }
 
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::GenerateImage()
 {
     if (m_SelectedBundles.empty() && m_SelectedDWI.IsNull())
     {
         mitk::Image::Pointer image = mitk::ImageGenerator::GenerateGradientImage<unsigned int>(
                     m_Controls->m_SizeX->value(),
                     m_Controls->m_SizeY->value(),
                     m_Controls->m_SizeZ->value(),
                     m_Controls->m_SpacingX->value(),
                     m_Controls->m_SpacingY->value(),
                     m_Controls->m_SpacingZ->value());
 
         mitk::Geometry3D* geom = image->GetGeometry();
         geom->SetOrigin(m_ImageGenParameters.imageOrigin);
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData( image );
         node->SetName("Dummy");
         unsigned int window = m_Controls->m_SizeX->value()*m_Controls->m_SizeY->value()*m_Controls->m_SizeZ->value();
         unsigned int level = window/2;
         mitk::LevelWindow lw; lw.SetLevelWindow(level, window);
         node->SetProperty( "levelwindow", mitk::LevelWindowProperty::New( lw ) );
         GetDataStorage()->Add(node);
         m_SelectedImage = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeSlicedGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
     }
     else if (!m_SelectedBundles.empty())
         SimulateImageFromFibers(m_SelectedBundles.at(0));
     else if (m_SelectedDWI.IsNotNull())
         SimulateForExistingDwi(m_SelectedDWI);
 }
 
 void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
 {
     if (!dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData()))
         return;
 
     MITK_INFO << "TEST";
     UpdateImageParameters();
 
     mitk::DiffusionImage<short>::Pointer diffImg = dynamic_cast<mitk::DiffusionImage<short>*>(imageNode->GetData());
     m_ArtifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
     m_ArtifactsToDwiFilter->SetInput(diffImg->GetVectorImage());
     m_ArtifactsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
     m_ArtifactsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
     m_ArtifactsToDwiFilter->SetNoiseModel(m_ImageGenParameters.noiseModelShort);
     m_ArtifactsToDwiFilter->SetGradientList(m_ImageGenParameters.gradientDirections);
     m_ArtifactsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
     m_ArtifactsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
     m_ArtifactsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
     m_ArtifactsToDwiFilter->SetAddGibbsRinging(m_ImageGenParameters.addGibbsRinging);
     m_ArtifactsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
     m_ArtifactsToDwiFilter->SetSpikeAmplitude(m_ImageGenParameters.spikeAmplitude);
     m_ArtifactsToDwiFilter->SetSpikes(m_ImageGenParameters.spikes);
     m_ArtifactsToDwiFilter->SetWrap(m_ImageGenParameters.wrap);
     m_ImageGenParameters.parentNode = imageNode;
     m_Worker.m_FilterType = 1;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::SimulateImageFromFibers(mitk::DataNode* fiberNode)
 {
     mitk::FiberBundleX::Pointer fiberBundle = dynamic_cast<mitk::FiberBundleX*>(fiberNode->GetData());
     if (fiberBundle->GetNumFibers()<=0)
         return;
 
     UpdateImageParameters();
 
     m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     m_TractsToDwiFilter->SetSimulateEddyCurrents(m_ImageGenParameters.doSimulateEddyCurrents);
     m_TractsToDwiFilter->SetEddyGradientStrength(m_ImageGenParameters.eddyStrength);
     m_TractsToDwiFilter->SetAddGibbsRinging(m_ImageGenParameters.addGibbsRinging);
     m_TractsToDwiFilter->SetSimulateRelaxation(m_ImageGenParameters.doSimulateRelaxation);
     m_TractsToDwiFilter->SetImageRegion(m_ImageGenParameters.imageRegion);
     m_TractsToDwiFilter->SetSpacing(m_ImageGenParameters.imageSpacing);
     m_TractsToDwiFilter->SetOrigin(m_ImageGenParameters.imageOrigin);
     m_TractsToDwiFilter->SetDirectionMatrix(m_ImageGenParameters.imageDirection);
     m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
     m_TractsToDwiFilter->SetFiberModels(m_ImageGenParameters.fiberModelList);
     m_TractsToDwiFilter->SetNonFiberModels(m_ImageGenParameters.nonFiberModelList);
     m_TractsToDwiFilter->SetNoiseModel(m_ImageGenParameters.noiseModel);
     m_TractsToDwiFilter->SetkOffset(m_ImageGenParameters.kspaceLineOffset);
     m_TractsToDwiFilter->SettLine(m_ImageGenParameters.tLine);
     m_TractsToDwiFilter->SettInhom(m_ImageGenParameters.tInhom);
     m_TractsToDwiFilter->SetTE(m_ImageGenParameters.tEcho);
     m_TractsToDwiFilter->SetNumberOfRepetitions(m_ImageGenParameters.repetitions);
     m_TractsToDwiFilter->SetEnforcePureFiberVoxels(m_ImageGenParameters.doDisablePartialVolume);
     m_TractsToDwiFilter->SetInterpolationShrink(m_ImageGenParameters.interpolationShrink);
     m_TractsToDwiFilter->SetFiberRadius(m_ImageGenParameters.axonRadius);
     m_TractsToDwiFilter->SetSignalScale(m_ImageGenParameters.signalScale);
     if (m_ImageGenParameters.interpolationShrink>0)
         m_TractsToDwiFilter->SetUseInterpolation(true);
     m_TractsToDwiFilter->SetTissueMask(m_ImageGenParameters.maskImage);
     m_TractsToDwiFilter->SetFrequencyMap(m_ImageGenParameters.frequencyMap);
     m_TractsToDwiFilter->SetSpikeAmplitude(m_ImageGenParameters.spikeAmplitude);
     m_TractsToDwiFilter->SetSpikes(m_ImageGenParameters.spikes);
     m_TractsToDwiFilter->SetWrap(m_ImageGenParameters.wrap);
     m_TractsToDwiFilter->SetAddMotionArtifact(m_ImageGenParameters.doAddMotion);
     m_TractsToDwiFilter->SetMaxTranslation(m_ImageGenParameters.translation);
     m_TractsToDwiFilter->SetMaxRotation(m_ImageGenParameters.rotation);
     m_TractsToDwiFilter->SetRandomMotion(m_ImageGenParameters.randomMotion);
     m_ImageGenParameters.parentNode = fiberNode;
     m_Worker.m_FilterType = 0;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for( int i=0; i<m_SelectedImages.size(); i++ )
     {
         mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(m_SelectedImages.at(i));
         for( mitk::DataStorage::SetOfObjects::const_iterator it = derivations->begin(); it != derivations->end(); ++it )
         {
             mitk::DataNode::Pointer fibNode = *it;
             if ( fibNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(fibNode->GetData()) )
                 selectedBundles.push_back(fibNode);
         }
     }
     if (selectedBundles.empty())
         selectedBundles = m_SelectedBundles2;
 
     if (!selectedBundles.empty())
     {
         std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin();
         for (it; it!=selectedBundles.end(); ++it)
         {
             mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
             fib->RotateAroundAxis(m_Controls->m_XrotBox->value(), m_Controls->m_YrotBox->value(), m_Controls->m_ZrotBox->value());
             fib->TranslateFibers(m_Controls->m_XtransBox->value(), m_Controls->m_YtransBox->value(), m_Controls->m_ZtransBox->value());
             fib->ScaleFibers(m_Controls->m_XscaleBox->value(), m_Controls->m_YscaleBox->value(), m_Controls->m_ZscaleBox->value());
 
             // handle child fiducials
             if (m_Controls->m_IncludeFiducials->isChecked())
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
                 for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
                 {
                     mitk::DataNode::Pointer fiducialNode = *it2;
                     if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                     {
                         mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData());
                         mitk::Geometry3D* geom = pe->GetGeometry();
 
                         // translate
                         mitk::Vector3D world;
                         world[0] = m_Controls->m_XtransBox->value();
                         world[1] = m_Controls->m_YtransBox->value();
                         world[2] = m_Controls->m_ZtransBox->value();
                         geom->Translate(world);
 
                         // calculate rotation matrix
                         double x = m_Controls->m_XrotBox->value()*M_PI/180;
                         double y = m_Controls->m_YrotBox->value()*M_PI/180;
                         double z = m_Controls->m_ZrotBox->value()*M_PI/180;
 
                         itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
                         rotX[1][1] = cos(x);
                         rotX[2][2] = rotX[1][1];
                         rotX[1][2] = -sin(x);
                         rotX[2][1] = -rotX[1][2];
 
                         itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
                         rotY[0][0] = cos(y);
                         rotY[2][2] = rotY[0][0];
                         rotY[0][2] = sin(y);
                         rotY[2][0] = -rotY[0][2];
 
                         itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
                         rotZ[0][0] = cos(z);
                         rotZ[1][1] = rotZ[0][0];
                         rotZ[0][1] = -sin(z);
                         rotZ[1][0] = -rotZ[0][1];
 
                         itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
                         // transform control point coordinate into geometry translation
                         geom->SetOrigin(pe->GetWorldControlPoint(0));
                         mitk::Point2D cp; cp.Fill(0.0);
                         pe->SetControlPoint(0, cp);
 
                         // rotate fiducial
                         geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
 
                         // implicit translation
                         mitk::Vector3D trans;
                         trans[0] = geom->GetOrigin()[0]-fib->GetGeometry()->GetCenter()[0];
                         trans[1] = geom->GetOrigin()[1]-fib->GetGeometry()->GetCenter()[1];
                         trans[2] = geom->GetOrigin()[2]-fib->GetGeometry()->GetCenter()[2];
                         mitk::Vector3D newWc = rot*trans;
                         newWc = newWc-trans;
                         geom->Translate(newWc);
                     }
                 }
             }
         }
     }
     else
     {
         for (int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::Geometry3D* geom = pe->GetGeometry();
 
             // translate
             mitk::Vector3D world;
             world[0] = m_Controls->m_XtransBox->value();
             world[1] = m_Controls->m_YtransBox->value();
             world[2] = m_Controls->m_ZtransBox->value();
             geom->Translate(world);
 
             // calculate rotation matrix
             double x = m_Controls->m_XrotBox->value()*M_PI/180;
             double y = m_Controls->m_YrotBox->value()*M_PI/180;
             double z = m_Controls->m_ZrotBox->value()*M_PI/180;
             itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
             rotX[1][1] = cos(x);
             rotX[2][2] = rotX[1][1];
             rotX[1][2] = -sin(x);
             rotX[2][1] = -rotX[1][2];
             itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
             rotY[0][0] = cos(y);
             rotY[2][2] = rotY[0][0];
             rotY[0][2] = sin(y);
             rotY[2][0] = -rotY[0][2];
             itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
             rotZ[0][0] = cos(z);
             rotZ[1][1] = rotZ[0][0];
             rotZ[0][1] = -sin(z);
             rotZ[1][0] = -rotZ[0][1];
             itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
             // transform control point coordinate into geometry translation
             geom->SetOrigin(pe->GetWorldControlPoint(0));
             mitk::Point2D cp; cp.Fill(0.0);
             pe->SetControlPoint(0, cp);
 
             // rotate fiducial
             geom->GetIndexToWorldTransform()->SetMatrix(rot*geom->GetIndexToWorldTransform()->GetMatrix());
         }
         if (m_Controls->m_RealTimeFibers->isChecked())
             GenerateFibers();
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::CopyBundles()
 {
     if ( m_SelectedBundles.size()<1 ){
         QMessageBox::information( NULL, "Warning", "Select at least one fiber bundle!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least one fiber bundle!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         // find parent image
         mitk::DataNode::Pointer parentNode;
         mitk::DataStorage::SetOfObjects::ConstPointer parentImgs = GetDataStorage()->GetSources(*it);
         for( mitk::DataStorage::SetOfObjects::const_iterator it2 = parentImgs->begin(); it2 != parentImgs->end(); ++it2 )
         {
             mitk::DataNode::Pointer pImgNode = *it2;
             if ( pImgNode.IsNotNull() && dynamic_cast<mitk::Image*>(pImgNode->GetData()) )
             {
                 parentNode = pImgNode;
                 break;
             }
         }
 
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
         mitk::FiberBundleX::Pointer newBundle = fib->GetDeepCopy();
         QString name((*it)->GetName().c_str());
         name += "_copy";
 
         mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
         fbNode->SetData(newBundle);
         fbNode->SetName(name.toStdString());
         fbNode->SetVisibility(true);
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(fbNode, parentNode);
         else
             GetDataStorage()->Add(fbNode);
 
         // copy child fiducials
         if (m_Controls->m_IncludeFiducials->isChecked())
         {
             mitk::DataStorage::SetOfObjects::ConstPointer derivations = GetDataStorage()->GetDerivations(*it);
             for( mitk::DataStorage::SetOfObjects::const_iterator it2 = derivations->begin(); it2 != derivations->end(); ++it2 )
             {
                 mitk::DataNode::Pointer fiducialNode = *it2;
                 if ( fiducialNode.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()) )
                 {
                     mitk::PlanarEllipse::Pointer pe = mitk::PlanarEllipse::New();
                     pe->DeepCopy(dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData()));
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     GetDataStorage()->Add(newNode, fbNode);
                 }
             }
         }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::JoinBundles()
 {
     if ( m_SelectedBundles.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin();
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>((*it)->GetData());
     QString name("");
     name += QString((*it)->GetName().c_str());
     ++it;
     for (it; it!=m_SelectedBundles.end(); ++it)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>((*it)->GetData()));
         name += "+"+QString((*it)->GetName().c_str());
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberfoxView::UpdateGui()
 {
     m_Controls->m_FiberBundleLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_GeometryFrame->setEnabled(true);
     m_Controls->m_GeometryMessage->setVisible(false);
     m_Controls->m_DiffusionPropsMessage->setVisible(false);
     m_Controls->m_FiberGenMessage->setVisible(true);
 
     m_Controls->m_TransformBundlesButton->setEnabled(false);
     m_Controls->m_CopyBundlesButton->setEnabled(false);
     m_Controls->m_GenerateFibersButton->setEnabled(false);
     m_Controls->m_FlipButton->setEnabled(false);
     m_Controls->m_CircleButton->setEnabled(false);
     m_Controls->m_BvalueBox->setEnabled(true);
     m_Controls->m_NumGradientsBox->setEnabled(true);
     m_Controls->m_JoinBundlesButton->setEnabled(false);
     m_Controls->m_AlignOnGrid->setEnabled(false);
 
     if (m_SelectedFiducial.IsNotNull())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_FlipButton->setEnabled(true);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_SelectedImage.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
         m_Controls->m_AlignOnGrid->setEnabled(true);
     }
 
     if (m_ImageGenParameters.maskImage.IsNotNull() || m_SelectedImage.IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_SelectedDWI.IsNotNull())
     {
         m_Controls->m_DiffusionPropsMessage->setVisible(true);
         m_Controls->m_BvalueBox->setEnabled(false);
         m_Controls->m_NumGradientsBox->setEnabled(false);
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
         m_Controls->m_FiberBundleLabel->setText(m_SelectedBundles.at(0)->GetName().c_str());
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 }
 
 void QmitkFiberfoxView::OnSelectionChanged( berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes )
 {
     m_SelectedBundles2.clear();
     m_SelectedImages.clear();
     m_SelectedFiducials.clear();
     m_SelectedFiducial = NULL;
     m_ImageGenParameters.maskImage = NULL;
     m_SelectedBundles.clear();
     m_SelectedImage = NULL;
     m_SelectedDWI = NULL;
     m_Controls->m_TissueMaskLabel->setText("<font color='grey'>optional</font>");
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
         if ( node.IsNotNull() && dynamic_cast<mitk::DiffusionImage<short>*>(node->GetData()) )
         {
             m_SelectedDWI = node;
             m_SelectedImage = node;
             m_SelectedImages.push_back(node);
         }
         else if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
             m_SelectedImage = node;
             mitk::Image::Pointer image = dynamic_cast<mitk::Image*>(node->GetData());
             bool isbinary = false;
             node->GetPropertyValue<bool>("binary", isbinary);
             if (isbinary)
             {
                 mitk::CastToItkImage<ItkUcharImgType>(image, m_ImageGenParameters.maskImage);
                 m_Controls->m_TissueMaskLabel->setText(node->GetName().c_str());
             }
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
         {
             m_SelectedBundles2.push_back(node);
             if (m_Controls->m_RealTimeFibers->isChecked())
             {
                 m_SelectedBundles.push_back(node);
                 mitk::FiberBundleX::Pointer newFib = dynamic_cast<mitk::FiberBundleX*>(node->GetData());
                 if (newFib->GetNumFibers()!=m_Controls->m_FiberDensityBox->value())
                     GenerateFibers();
             }
             else
                 m_SelectedBundles.push_back(node);
         }
         else if ( node.IsNotNull() && dynamic_cast<mitk::PlanarEllipse*>(node->GetData()) )
         {
             m_SelectedFiducials.push_back(node);
             m_SelectedFiducial = node;
             m_SelectedBundles.clear();
             mitk::DataStorage::SetOfObjects::ConstPointer parents = GetDataStorage()->GetSources(node);
             for( mitk::DataStorage::SetOfObjects::const_iterator it = parents->begin(); it != parents->end(); ++it )
             {
                 mitk::DataNode::Pointer pNode = *it;
                 if ( pNode.IsNotNull() && dynamic_cast<mitk::FiberBundleX*>(pNode->GetData()) )
                     m_SelectedBundles.push_back(pNode);
             }
         }
     }
     UpdateGui();
 }
 
 
 void QmitkFiberfoxView::EnableCrosshairNavigation()
 {
     MITK_DEBUG << "EnableCrosshairNavigation";
 
     // enable the crosshair navigation
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "enabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(true);
         //        linkedRenderWindow->EnableSlicingPlanes(true);
     }
 
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::DisableCrosshairNavigation()
 {
     MITK_DEBUG << "DisableCrosshairNavigation";
 
     // disable the crosshair navigation during the drawing
     if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
             dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
     {
         MITK_DEBUG << "disabling linked navigation";
         linkedRenderWindow->EnableLinkedNavigation(false);
         //        linkedRenderWindow->EnableSlicingPlanes(false);
     }
 }
 
 void QmitkFiberfoxView::NodeRemoved(const mitk::DataNode* node)
 {
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
     std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it = m_DataNodeToPlanarFigureData.find(nonConstNode);
 
     if (dynamic_cast<FiberBundleX*>(node->GetData()))
     {
         m_SelectedBundles.clear();
         m_SelectedBundles2.clear();
     }
     else if (dynamic_cast<Image*>(node->GetData()))
         m_SelectedImages.clear();
 
     if( it != m_DataNodeToPlanarFigureData.end() )
     {
         QmitkPlanarFigureData& data = it->second;
 
         // remove observers
         data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
         data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
         data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
         data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
         m_DataNodeToPlanarFigureData.erase( it );
     }
 }
 
 void QmitkFiberfoxView::NodeAdded( const mitk::DataNode* node )
 {
     // add observer for selection in renderwindow
     mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
     bool isPositionMarker (false);
     node->GetBoolProperty("isContourMarker", isPositionMarker);
     if( figure && !isPositionMarker )
     {
         MITK_DEBUG << "figure added. will add interactor if needed.";
         mitk::PlanarFigureInteractor::Pointer figureInteractor
                 = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
 
         mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
         if(figureInteractor.IsNull())
         {
             figureInteractor = mitk::PlanarFigureInteractor::New();
             us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "PlanarFigure" );
             figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
             figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
             figureInteractor->SetDataNode( nonConstNode );
         }
 
         MITK_DEBUG << "will now add observers for planarfigure";
         QmitkPlanarFigureData data;
         data.m_Figure = figure;
 
         //        // add observer for event when figure has been placed
         typedef itk::SimpleMemberCommand< QmitkFiberfoxView > SimpleCommandType;
         //        SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
         //        initializationCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureInitialized );
         //        data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
         // add observer for event when figure is picked (selected)
         typedef itk::MemberCommand< QmitkFiberfoxView > MemberCommandType;
         MemberCommandType::Pointer selectCommand = MemberCommandType::New();
         selectCommand->SetCallbackFunction( this, &QmitkFiberfoxView::PlanarFigureSelected );
         data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
         startInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::DisableCrosshairNavigation);
         data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
         // add observer for event when interaction with figure starts
         SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
         endInteractionCommand->SetCallbackFunction( this, &QmitkFiberfoxView::EnableCrosshairNavigation);
         data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
         m_DataNodeToPlanarFigureData[nonConstNode] = data;
     }
 }
 
 void QmitkFiberfoxView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPf = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
     mitk::DataStorage::SetOfObjects::ConstPointer allPfs = this->GetDataStorage()->GetSubset( isPf );
     for ( mitk::DataStorage::SetOfObjects::const_iterator it = allPfs->begin(); it!=allPfs->end(); ++it)
     {
         mitk::DataNode* node = *it;
 
         if( node->GetData() == object )
         {
             node->SetSelected(true);
             m_SelectedFiducial = node;
         }
         else
             node->SetSelected(false);
     }
     UpdateGui();
     this->RequestRenderWindowUpdate();
 }
 
 void QmitkFiberfoxView::SetFocus()
 {
     m_Controls->m_CircleButton->setFocus();
 }
 
 
 void QmitkFiberfoxView::SetOutputPath()
 {
     // SELECT FOLDER DIALOG
 
     m_OutputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", m_OutputPath);
 
     if (m_OutputPath.isEmpty())
         m_Controls->m_SavePathEdit->setText("-");
     else
     {
         m_OutputPath += "/";
         m_Controls->m_SavePathEdit->setText(m_OutputPath);
     }
 }