diff --git a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
index ce9807f8a8..028ffb90a8 100644
--- a/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
+++ b/Modules/DiffusionImaging/DiffusionIO/mitkFiberBundleXReader.cpp
@@ -1,229 +1,229 @@
 /*===================================================================
 
 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 "mitkFiberBundleXReader.h"
 #include <itkMetaDataObject.h>
 #include <vtkPolyData.h>
 #include <vtkDataReader.h>
 #include <vtkPolyDataReader.h>
 #include <vtkMatrix4x4.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkDataArray.h>
 #include <vtkFloatArray.h>
 #include <vtkCellData.h>
 #include <vtkPointData.h>
 #include <itksys/SystemTools.hxx>
 #include <tinyxml.h>
 #include <vtkCleanPolyData.h>
 #include <mitkTrackvis.h>
 #include <mitkCustomMimeType.h>
 #include "mitkDiffusionIOMimeTypes.h"
 
 
 mitk::FiberBundleXReader::FiberBundleXReader()
   : mitk::AbstractFileReader( CustomMimeType( mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_NAME() ), mitk::DiffusionIOMimeTypes::FIBERBUNDLE_MIMETYPE_DESCRIPTION() )
 {
   m_ServiceReg = this->RegisterService();
 }
 
 mitk::FiberBundleXReader::FiberBundleXReader(const FiberBundleXReader &other)
   :mitk::AbstractFileReader(other)
 {
 }
 
 mitk::FiberBundleXReader * mitk::FiberBundleXReader::Clone() const
 {
   return new FiberBundleXReader(*this);
 }
 
 
 std::vector<itk::SmartPointer<mitk::BaseData> > mitk::FiberBundleXReader::Read()
 {
 
   std::vector<itk::SmartPointer<mitk::BaseData> > result;
   try
   {
     const std::string& locale = "C";
     const std::string& currLocale = setlocale( LC_ALL, NULL );
     setlocale(LC_ALL, locale.c_str());
 
     std::string filename = this->GetInputLocation();
 
     std::string ext = itksys::SystemTools::GetFilenameLastExtension(filename);
     ext = itksys::SystemTools::LowerCase(ext);
 
     if (ext==".trk")
     {
       FiberBundleX::Pointer image = FiberBundleX::New();
       TrackVisFiberReader reader;
       reader.open(this->GetInputLocation().c_str());
       reader.read(image.GetPointer());
       result.push_back(image.GetPointer());
       return result;
     }
 
     vtkSmartPointer<vtkDataReader> chooser=vtkSmartPointer<vtkDataReader>::New();
     chooser->SetFileName( this->GetInputLocation().c_str() );
     if( chooser->IsFilePolyData())
     {
       vtkSmartPointer<vtkPolyDataReader> reader = vtkSmartPointer<vtkPolyDataReader>::New();
       reader->SetFileName( this->GetInputLocation().c_str() );
       reader->Update();
 
       if ( reader->GetOutput() != NULL )
       {
         vtkSmartPointer<vtkPolyData> fiberPolyData = reader->GetOutput();
         FiberBundleX::Pointer fiberBundle = FiberBundleX::New(fiberPolyData);
 
         vtkSmartPointer<vtkFloatArray> weights = vtkFloatArray::SafeDownCast(fiberPolyData->GetCellData()->GetArray("FIBER_WEIGHTS"));
         if (weights!=NULL)
         {
-//            float weight=0;
-//            for (int i=0; i<weights->GetSize(); i++)
-//                if (!mitk::Equal(weights->GetValue(i),weight,0.00001))
-//                {
-//                    MITK_INFO << "Weight: " << weights->GetValue(i);
-//                    weight = weights->GetValue(i);
-//                }
+            float weight=0;
+            for (int i=0; i<weights->GetSize(); i++)
+                if (!mitk::Equal(weights->GetValue(i),weight,0.00001))
+                {
+                    MITK_INFO << "Weight: " << weights->GetValue(i);
+                    weight = weights->GetValue(i);
+                }
             fiberBundle->SetFiberWeights(weights);
         }
 
         vtkSmartPointer<vtkUnsignedCharArray> fiberColors = vtkUnsignedCharArray::SafeDownCast(fiberPolyData->GetPointData()->GetArray("FIBER_COLORS"));
         if (fiberColors!=NULL)
             fiberBundle->SetFiberColors(fiberColors);
 
         result.push_back(fiberBundle.GetPointer());
         return result;
       }
     }
     else // try to read deprecated fiber bundle file format
     {
       MITK_INFO << "Reading xml fiber bundle";
       vtkSmartPointer<vtkPolyData> fiberPolyData = vtkSmartPointer<vtkPolyData>::New();
       vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
       vtkSmartPointer<vtkPoints>    points = vtkSmartPointer<vtkPoints>::New();
       TiXmlDocument doc( this->GetInputLocation().c_str() );
       if(doc.LoadFile())
       {
         TiXmlHandle hDoc(&doc);
         TiXmlElement* pElem;
         TiXmlHandle hRoot(0);
         pElem = hDoc.FirstChildElement().Element();
         // save this for later
         hRoot = TiXmlHandle(pElem);
         pElem = hRoot.FirstChildElement("geometry").Element();
         // read geometry
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         // read origin
         mitk::Point3D origin;
         double temp = 0;
         pElem->Attribute("origin_x", &temp);
         origin[0] = temp;
         pElem->Attribute("origin_y", &temp);
         origin[1] = temp;
         pElem->Attribute("origin_z", &temp);
         origin[2] = temp;
         geometry->SetOrigin(origin);
         // read spacing
         ScalarType spacing[3];
         pElem->Attribute("spacing_x", &temp);
         spacing[0] = temp;
         pElem->Attribute("spacing_y", &temp);
         spacing[1] = temp;
         pElem->Attribute("spacing_z", &temp);
         spacing[2] = temp;
         geometry->SetSpacing(spacing);
         // read transform
         vtkMatrix4x4* m = vtkMatrix4x4::New();
         pElem->Attribute("xx", &temp);
         m->SetElement(0,0,temp);
         pElem->Attribute("xy", &temp);
         m->SetElement(1,0,temp);
         pElem->Attribute("xz", &temp);
         m->SetElement(2,0,temp);
         pElem->Attribute("yx", &temp);
         m->SetElement(0,1,temp);
         pElem->Attribute("yy", &temp);
         m->SetElement(1,1,temp);
         pElem->Attribute("yz", &temp);
         m->SetElement(2,1,temp);
         pElem->Attribute("zx", &temp);
         m->SetElement(0,2,temp);
         pElem->Attribute("zy", &temp);
         m->SetElement(1,2,temp);
         pElem->Attribute("zz", &temp);
         m->SetElement(2,2,temp);
         m->SetElement(0,3,origin[0]);
         m->SetElement(1,3,origin[1]);
         m->SetElement(2,3,origin[2]);
         m->SetElement(3,3,1);
         geometry->SetIndexToWorldTransformByVtkMatrix(m);
         // read bounds
         float bounds[] = {0, 0, 0, 0, 0, 0};
         pElem->Attribute("size_x", &temp);
         bounds[1] = temp;
         pElem->Attribute("size_y", &temp);
         bounds[3] = temp;
         pElem->Attribute("size_z", &temp);
         bounds[5] = temp;
         geometry->SetFloatBounds(bounds);
         geometry->SetImageGeometry(true);
         pElem = hRoot.FirstChildElement("fiber_bundle").FirstChild().Element();
         for( ; pElem ; pElem=pElem->NextSiblingElement())
         {
           TiXmlElement* pElem2 = pElem->FirstChildElement();
           vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
           for( ; pElem2; pElem2=pElem2->NextSiblingElement())
           {
             Point3D point;
             pElem2->Attribute("pos_x", &temp);
             point[0] = temp;
             pElem2->Attribute("pos_y", &temp);
             point[1] = temp;
             pElem2->Attribute("pos_z", &temp);
             point[2] = temp;
             geometry->IndexToWorld(point, point);
             vtkIdType id = points->InsertNextPoint(point.GetDataPointer());
             container->GetPointIds()->InsertNextId(id);
           }
           cellArray->InsertNextCell(container);
         }
         fiberPolyData->SetPoints(points);
         fiberPolyData->SetLines(cellArray);
         vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
         cleaner->SetInputData(fiberPolyData);
         cleaner->Update();
         fiberPolyData = cleaner->GetOutput();
         FiberBundleX::Pointer image = FiberBundleX::New(fiberPolyData);
         result.push_back(image.GetPointer());
         return result;
       }
       else
       {
         MITK_ERROR << "could not open xml file";
         throw "could not open xml file";
       }
     }
     setlocale(LC_ALL, currLocale.c_str());
     MITK_INFO << "Fiber bundle read";
   }
   catch(...)
   {
     throw;
   }
   return result;
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
index 86093896aa..230788c36c 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.cpp
@@ -1,1302 +1,1434 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "itkTractsToDWIImageFilter.h"
 #include <boost/progress.hpp>
 #include <vtkSmartPointer.h>
 #include <vtkPolyData.h>
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkResampleImageFilter.h>
 #include <itkNearestNeighborInterpolateImageFunction.h>
 #include <itkBSplineInterpolateImageFunction.h>
 #include <itkCastImageFilter.h>
 #include <itkImageFileWriter.h>
 #include <itkRescaleIntensityImageFilter.h>
 #include <itkWindowedSincInterpolateImageFunction.h>
 #include <itkResampleDwiImageFilter.h>
 #include <itkKspaceImageFilter.h>
 #include <itkDftImageFilter.h>
 #include <itkAddImageFilter.h>
 #include <itkConstantPadImageFilter.h>
 #include <itkCropImageFilter.h>
 #include <mitkAstroStickModel.h>
 #include <vtkTransform.h>
 #include <iostream>
 #include <fstream>
 #include <itkImageDuplicator.h>
 #include <itksys/SystemTools.hxx>
 #include <mitkIOUtil.h>
 #include <itkDiffusionTensor3DReconstructionImageFilter.h>
 #include <itkDiffusionTensor3D.h>
 #include <itkTractDensityImageFilter.h>
 #include <boost/lexical_cast.hpp>
 #include <itkTractsToVectorImageFilter.h>
 
 namespace itk
 {
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::TractsToDWIImageFilter()
     : m_FiberBundle(NULL)
     , m_StatusText("")
     , m_UseConstantRandSeed(false)
     , m_RandGen(itk::Statistics::MersenneTwisterRandomVariateGenerator::New())
 {
     m_RandGen->SetSeed();
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::~TractsToDWIImageFilter()
 {
 
 }
 
 template< class PixelType >
 TractsToDWIImageFilter< PixelType >::DoubleDwiType::Pointer TractsToDWIImageFilter< PixelType >::DoKspaceStuff( std::vector< DoubleDwiType::Pointer >& images )
 {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     // create slice object
     ImageRegion<2> sliceRegion;
     sliceRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
     sliceRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
     Vector< double, 2 > sliceSpacing;
     sliceSpacing[0] = m_UpsampledSpacing[0];
     sliceSpacing[1] = m_UpsampledSpacing[1];
 
     // frequency map slice
     SliceType::Pointer fMapSlice = NULL;
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
     {
         fMapSlice = SliceType::New();
         ImageRegion<2> region;
         region.SetSize(0, m_UpsampledImageRegion.GetSize()[0]);
         region.SetSize(1, m_UpsampledImageRegion.GetSize()[1]);
         fMapSlice->SetLargestPossibleRegion( region );
         fMapSlice->SetBufferedRegion( region );
         fMapSlice->SetRequestedRegion( region );
         fMapSlice->Allocate();
         fMapSlice->FillBuffer(0.0);
     }
 
     DoubleDwiType::Pointer newImage = DoubleDwiType::New();
     newImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     newImage->SetOrigin( m_Parameters.m_SignalGen.m_ImageOrigin );
     newImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     newImage->SetLargestPossibleRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetBufferedRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetRequestedRegion( m_Parameters.m_SignalGen.m_ImageRegion );
     newImage->SetVectorLength( images.at(0)->GetVectorLength() );
     newImage->Allocate();
 
     std::vector< unsigned int > spikeVolume;
     for (unsigned int i=0; i<m_Parameters.m_SignalGen.m_Spikes; i++)
-        spikeVolume.push_back(m_RandGen->GetIntegerVariate()%images.at(0)->GetVectorLength());
+        spikeVolume.push_back(m_RandGen->GetIntegerVariate()%(images.at(0)->GetVectorLength()-1)+1);
     std::sort (spikeVolume.begin(), spikeVolume.end());
     std::reverse (spikeVolume.begin(), spikeVolume.end());
 
     m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
     m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
     unsigned long lastTick = 0;
 
     boost::progress_display disp(2*images.at(0)->GetVectorLength()*images.at(0)->GetLargestPossibleRegion().GetSize(2));
     for (unsigned int g=0; g<images.at(0)->GetVectorLength(); g++)
     {
         std::vector< unsigned int > spikeSlice;
         while (!spikeVolume.empty() && spikeVolume.back()==g)
         {
             spikeSlice.push_back(m_RandGen->GetIntegerVariate()%images.at(0)->GetLargestPossibleRegion().GetSize(2));
             spikeVolume.pop_back();
         }
         std::sort (spikeSlice.begin(), spikeSlice.end());
         std::reverse (spikeSlice.begin(), spikeSlice.end());
 
         for (unsigned int z=0; z<images.at(0)->GetLargestPossibleRegion().GetSize(2); z++)
         {
             std::vector< SliceType::Pointer > compartmentSlices;
             std::vector< double > t2Vector;
 
             for (unsigned int i=0; i<images.size(); i++)
             {
                 DiffusionSignalModel<double>* signalModel;
                 if (i<numFiberCompartments)
                     signalModel = m_Parameters.m_FiberModelList.at(i);
                 else
                     signalModel = m_Parameters.m_NonFiberModelList.at(i-numFiberCompartments);
 
                 SliceType::Pointer slice = SliceType::New();
                 slice->SetLargestPossibleRegion( sliceRegion );
                 slice->SetBufferedRegion( sliceRegion );
                 slice->SetRequestedRegion( sliceRegion );
                 slice->SetSpacing(sliceSpacing);
                 slice->Allocate();
                 slice->FillBuffer(0.0);
 
                 // extract slice from channel g
                 for (unsigned int y=0; y<images.at(0)->GetLargestPossibleRegion().GetSize(1); y++)
                     for (unsigned int x=0; x<images.at(0)->GetLargestPossibleRegion().GetSize(0); x++)
                     {
                         SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
                         DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
 
                         slice->SetPixel(index2D, images.at(i)->GetPixel(index3D)[g]);
 
                         if (fMapSlice.IsNotNull() && i==0)
                             fMapSlice->SetPixel(index2D, m_Parameters.m_SignalGen.m_FrequencyMap->GetPixel(index3D));
                     }
 
                 compartmentSlices.push_back(slice);
                 t2Vector.push_back(signalModel->GetT2());
             }
 
             if (this->GetAbortGenerateData())
                 return NULL;
 
             // create k-sapce (inverse fourier transform slices)
             itk::Size<2> outSize; outSize.SetElement(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0)); outSize.SetElement(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1));
             itk::KspaceImageFilter< SliceType::PixelType >::Pointer idft = itk::KspaceImageFilter< SliceType::PixelType >::New();
             idft->SetCompartmentImages(compartmentSlices);
             idft->SetT2(t2Vector);
             idft->SetUseConstantRandSeed(m_UseConstantRandSeed);
             idft->SetParameters(m_Parameters);
             idft->SetZ((double)z-(double)images.at(0)->GetLargestPossibleRegion().GetSize(2)/2.0);
             idft->SetDiffusionGradientDirection(m_Parameters.m_SignalGen.GetGradientDirection(g));
             idft->SetFrequencyMapSlice(fMapSlice);
             idft->SetOutSize(outSize);
             int numSpikes = 0;
             while (!spikeSlice.empty() && spikeSlice.back()==z)
             {
                 numSpikes++;
                 spikeSlice.pop_back();
             }
             idft->SetSpikesPerSlice(numSpikes);
             idft->Update();
 
             ComplexSliceType::Pointer fSlice;
             fSlice = idft->GetOutput();
 
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned  long tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
 
             // fourier transform slice
             SliceType::Pointer newSlice;
             itk::DftImageFilter< SliceType::PixelType >::Pointer dft = itk::DftImageFilter< SliceType::PixelType >::New();
             dft->SetInput(fSlice);
             dft->Update();
             newSlice = dft->GetOutput();
 
             // put slice back into channel g
             for (unsigned int y=0; y<fSlice->GetLargestPossibleRegion().GetSize(1); y++)
                 for (unsigned int x=0; x<fSlice->GetLargestPossibleRegion().GetSize(0); x++)
                 {
                     DoubleDwiType::IndexType index3D; index3D[0]=x; index3D[1]=y; index3D[2]=z;
                     SliceType::IndexType index2D; index2D[0]=x; index2D[1]=y;
 
                     DoubleDwiType::PixelType pix3D = newImage->GetPixel(index3D);
                     pix3D[g] = newSlice->GetPixel(index2D);
                     newImage->SetPixel(index3D, pix3D);
                 }
             ++disp;
             newTick = 50*disp.count()/disp.expected_count();
             for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
         }
     }
     m_StatusText += "\n\n";
     return newImage;
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::GenerateData()
 {
     m_TimeProbe.Start();
     m_StatusText = "Starting simulation\n";
 
     // check input data
     if (m_FiberBundle.IsNull())
         itkExceptionMacro("Input fiber bundle is NULL!");
 
     if (m_Parameters.m_FiberModelList.empty())
         itkExceptionMacro("No diffusion model for fiber compartments defined!");
 
     if (m_Parameters.m_NonFiberModelList.empty())
         itkExceptionMacro("No diffusion model for non-fiber compartments defined!");
 
     int baselineIndex = m_Parameters.m_SignalGen.GetFirstBaselineIndex();
     if (baselineIndex<0)
         itkExceptionMacro("No baseline index found!");
 
     if (!m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition)
         m_Parameters.m_SignalGen.m_DoAddGibbsRinging = false;
 
     if (m_UseConstantRandSeed)  // always generate the same random numbers?
         m_RandGen->SetSeed(0);
     else
         m_RandGen->SetSeed();
 
     // initialize output dwi image
     ImageRegion<3> croppedRegion = m_Parameters.m_SignalGen.m_ImageRegion; croppedRegion.SetSize(1, croppedRegion.GetSize(1)*m_Parameters.m_SignalGen.m_CroppingFactor);
     itk::Point<double,3> shiftedOrigin = m_Parameters.m_SignalGen.m_ImageOrigin; shiftedOrigin[1] += (m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1)-croppedRegion.GetSize(1))*m_Parameters.m_SignalGen.m_ImageSpacing[1]/2;
     typename OutputImageType::Pointer outImage = OutputImageType::New();
     outImage->SetSpacing( m_Parameters.m_SignalGen.m_ImageSpacing );
     outImage->SetOrigin( shiftedOrigin );
     outImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
     outImage->SetLargestPossibleRegion( croppedRegion );
     outImage->SetBufferedRegion( croppedRegion );
     outImage->SetRequestedRegion( croppedRegion );
     outImage->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
     outImage->Allocate();
     typename OutputImageType::PixelType temp;
     temp.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     temp.Fill(0.0);
     outImage->FillBuffer(temp);
 
     // ADJUST GEOMETRY FOR FURTHER PROCESSING
     // is input slize size a power of two?
     unsigned int x=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0); unsigned int y=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     ItkDoubleImgType::SizeType pad; pad[0]=x%2; pad[1]=y%2; pad[2]=0;
     m_Parameters.m_SignalGen.m_ImageRegion.SetSize(0, x+pad[0]);
     m_Parameters.m_SignalGen.m_ImageRegion.SetSize(1, y+pad[1]);
     if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull() && (pad[0]>0 || pad[1]>0))
     {
         itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
         zeroPadder->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
         zeroPadder->SetConstant(0);
         zeroPadder->SetPadUpperBound(pad);
         zeroPadder->Update();
         m_Parameters.m_SignalGen.m_FrequencyMap = zeroPadder->GetOutput();
     }
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull() && (pad[0]>0 || pad[1]>0))
     {
         itk::ConstantPadImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
         zeroPadder->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
         zeroPadder->SetConstant(0);
         zeroPadder->SetPadUpperBound(pad);
         zeroPadder->Update();
         m_Parameters.m_SignalGen.m_MaskImage = zeroPadder->GetOutput();
     }
 
     // Apply in-plane upsampling for Gibbs ringing artifact
     double upsampling = 1;
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
         upsampling = 2;
     m_UpsampledSpacing = m_Parameters.m_SignalGen.m_ImageSpacing;
     m_UpsampledSpacing[0] /= upsampling;
     m_UpsampledSpacing[1] /= upsampling;
     m_UpsampledImageRegion = m_Parameters.m_SignalGen.m_ImageRegion;
     m_UpsampledImageRegion.SetSize(0, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[0]*upsampling);
     m_UpsampledImageRegion.SetSize(1, m_Parameters.m_SignalGen.m_ImageRegion.GetSize()[1]*upsampling);
     m_UpsampledOrigin = m_Parameters.m_SignalGen.m_ImageOrigin;
     m_UpsampledOrigin[0] -= m_Parameters.m_SignalGen.m_ImageSpacing[0]/2; m_UpsampledOrigin[0] += m_UpsampledSpacing[0]/2;
     m_UpsampledOrigin[1] -= m_Parameters.m_SignalGen.m_ImageSpacing[1]/2; m_UpsampledOrigin[1] += m_UpsampledSpacing[1]/2;
     m_UpsampledOrigin[2] -= m_Parameters.m_SignalGen.m_ImageSpacing[2]/2; m_UpsampledOrigin[2] += m_UpsampledSpacing[2]/2;
 
     // generate double images to store the individual compartment signals
     m_CompartmentImages.clear();
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
     for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
     {
         DoubleDwiType::Pointer doubleDwi = DoubleDwiType::New();
         doubleDwi->SetSpacing( m_UpsampledSpacing );
         doubleDwi->SetOrigin( m_UpsampledOrigin );
         doubleDwi->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         doubleDwi->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleDwi->SetBufferedRegion( m_UpsampledImageRegion );
         doubleDwi->SetRequestedRegion( m_UpsampledImageRegion );
         doubleDwi->SetVectorLength( m_Parameters.m_SignalGen.GetNumVolumes() );
         doubleDwi->Allocate();
         DoubleDwiType::PixelType pix;
         pix.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
         pix.Fill(0.0);
         doubleDwi->FillBuffer(pix);
         m_CompartmentImages.push_back(doubleDwi);
     }
 
     // initialize output volume fraction images
     m_VolumeFractions.clear();
     for (int i=0; i<numFiberCompartments+numNonFiberCompartments; i++)
     {
         ItkDoubleImgType::Pointer doubleImg = ItkDoubleImgType::New();
         doubleImg->SetSpacing( m_UpsampledSpacing );
         doubleImg->SetOrigin( m_UpsampledOrigin );
         doubleImg->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         doubleImg->SetLargestPossibleRegion( m_UpsampledImageRegion );
         doubleImg->SetBufferedRegion( m_UpsampledImageRegion );
         doubleImg->SetRequestedRegion( m_UpsampledImageRegion );
         doubleImg->Allocate();
         doubleImg->FillBuffer(0);
         m_VolumeFractions.push_back(doubleImg);
     }
 
     // get volume fraction images
     ItkDoubleImgType::Pointer sumImage = ItkDoubleImgType::New();
     bool foundVolumeFractionImage = false;
 
     for (int i=0; i<numNonFiberCompartments; i++)  // look if a volume fraction image is set
     {
         if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNotNull())
         {
             foundVolumeFractionImage = true;
 
             itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer zeroPadder = itk::ConstantPadImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
             zeroPadder->SetInput(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage());
             zeroPadder->SetConstant(0);
             zeroPadder->SetPadUpperBound(pad);
             zeroPadder->Update();
             m_Parameters.m_NonFiberModelList[i]->SetVolumeFractionImage(zeroPadder->GetOutput());
 
             sumImage->SetSpacing( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetSpacing() );
             sumImage->SetOrigin( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetOrigin() );
             sumImage->SetDirection( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetDirection() );
             sumImage->SetLargestPossibleRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->SetBufferedRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->SetRequestedRegion( m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion() );
             sumImage->Allocate();
             sumImage->FillBuffer(0);
             break;
         }
     }
     if (!foundVolumeFractionImage)
     {
         sumImage->SetSpacing( m_UpsampledSpacing );
         sumImage->SetOrigin( m_UpsampledOrigin );
         sumImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         sumImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         sumImage->SetBufferedRegion( m_UpsampledImageRegion );
         sumImage->SetRequestedRegion( m_UpsampledImageRegion );
         sumImage->Allocate();
         sumImage->FillBuffer(0.0);
     }
     for (int i=0; i<numNonFiberCompartments; i++)
     {
         if (m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage().IsNull())
         {
             ItkDoubleImgType::Pointer doubleImg = ItkDoubleImgType::New();
             doubleImg->SetSpacing( sumImage->GetSpacing() );
             doubleImg->SetOrigin( sumImage->GetOrigin() );
             doubleImg->SetDirection( sumImage->GetDirection() );
             doubleImg->SetLargestPossibleRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->SetBufferedRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->SetRequestedRegion( sumImage->GetLargestPossibleRegion() );
             doubleImg->Allocate();
             doubleImg->FillBuffer(1.0/numNonFiberCompartments);
             m_Parameters.m_NonFiberModelList[i]->SetVolumeFractionImage(doubleImg);
         }
         ImageRegionIterator<ItkDoubleImgType> it(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage(), m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             sumImage->SetPixel(it.GetIndex(), sumImage->GetPixel(it.GetIndex())+it.Get());
             ++it;
         }
     }
     for (int i=0; i<numNonFiberCompartments; i++)
     {
         ImageRegionIterator<ItkDoubleImgType> it(m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage(), m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             if (sumImage->GetPixel(it.GetIndex())>0)
                 it.Set(it.Get()/sumImage->GetPixel(it.GetIndex()));
             ++it;
         }
     }
 
     // resample mask image and frequency map to fit upsampled geometry
     if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
     {
         if (m_Parameters.m_SignalGen.m_MaskImage.IsNotNull())
         {
             // rescale mask image (otherwise there are problems with the resampling)
             itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkUcharImgType,ItkUcharImgType>::New();
             rescaler->SetInput(0,m_Parameters.m_SignalGen.m_MaskImage);
             rescaler->SetOutputMaximum(100);
             rescaler->SetOutputMinimum(0);
             rescaler->Update();
 
             // resample mask image
             itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer resampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
             resampler->SetInput(rescaler->GetOutput());
             resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
             resampler->SetSize(m_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::Pointer nn_interpolator
                     = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
             resampler->SetInterpolator(nn_interpolator);
             resampler->Update();
             m_Parameters.m_SignalGen.m_MaskImage = resampler->GetOutput();
 
             itk::ImageFileWriter<ItkUcharImgType>::Pointer w = itk::ImageFileWriter<ItkUcharImgType>::New();
             w->SetFileName("/local/mask_ups.nrrd");
             w->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
             w->Update();
         }
         // resample frequency map
         if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
         {
             itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::Pointer resampler = itk::ResampleImageFilter<ItkDoubleImgType, ItkDoubleImgType>::New();
             resampler->SetInput(m_Parameters.m_SignalGen.m_FrequencyMap);
             resampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_FrequencyMap);
             resampler->SetSize(m_UpsampledImageRegion.GetSize());
             resampler->SetOutputSpacing(m_UpsampledSpacing);
             resampler->SetOutputOrigin(m_UpsampledOrigin);
             itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::Pointer nn_interpolator
                     = itk::NearestNeighborInterpolateImageFunction<ItkDoubleImgType, double>::New();
             resampler->SetInterpolator(nn_interpolator);
             resampler->Update();
             m_Parameters.m_SignalGen.m_FrequencyMap = resampler->GetOutput();
         }
     }
 
     // no input tissue mask is set -> create default
     m_MaskImageSet = true;
     if (m_Parameters.m_SignalGen.m_MaskImage.IsNull())
     {
         m_StatusText += "No tissue mask set\n";
         MITK_INFO << "No tissue mask set";
         m_Parameters.m_SignalGen.m_MaskImage = ItkUcharImgType::New();
         m_Parameters.m_SignalGen.m_MaskImage->SetSpacing( m_UpsampledSpacing );
         m_Parameters.m_SignalGen.m_MaskImage->SetOrigin( m_UpsampledOrigin );
         m_Parameters.m_SignalGen.m_MaskImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         m_Parameters.m_SignalGen.m_MaskImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->SetBufferedRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->SetRequestedRegion( m_UpsampledImageRegion );
         m_Parameters.m_SignalGen.m_MaskImage->Allocate();
         m_Parameters.m_SignalGen.m_MaskImage->FillBuffer(1);
         m_MaskImageSet = false;
     }
     else
     {
         m_StatusText += "Using tissue mask\n";
         MITK_INFO << "Using tissue mask";
     }
 
     m_Parameters.m_SignalGen.m_ImageRegion = croppedRegion;
     x=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(0); y=m_Parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     if ( x%2 == 1 )
         m_Parameters.m_SignalGen.m_ImageRegion.SetSize(0, x+1);
     if ( y%2 == 1 )
         m_Parameters.m_SignalGen.m_ImageRegion.SetSize(1, y+1);
 
     // resample fiber bundle for sufficient voxel coverage
     m_StatusText += "\n"+this->GetTime()+" > Resampling fibers ...\n";
     double segmentVolume = 0.0001;
     float minSpacing = 1;
     if(m_UpsampledSpacing[0]<m_UpsampledSpacing[1] && m_UpsampledSpacing[0]<m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[0];
     else if (m_UpsampledSpacing[1] < m_UpsampledSpacing[2])
         minSpacing = m_UpsampledSpacing[1];
     else
         minSpacing = m_UpsampledSpacing[2];
     m_FiberBundleWorkingCopy = m_FiberBundle->GetDeepCopy();
     double volumeAccuracy = 10;
     m_FiberBundleWorkingCopy->ResampleSpline(minSpacing/volumeAccuracy);
     double mmRadius = m_Parameters.m_SignalGen.m_AxonRadius/1000;
     if (mmRadius>0)
         segmentVolume = M_PI*mmRadius*mmRadius*minSpacing/volumeAccuracy;
 
     double maxVolume = 0;
     m_VoxelVolume = m_UpsampledSpacing[0]*m_UpsampledSpacing[1]*m_UpsampledSpacing[2];
 
     if (m_Parameters.m_SignalGen.m_DoAddMotion)
     {
         std::string fileName = "fiberfox_motion_0.log";
         std::string filePath = mitk::IOUtil::GetTempPath();
         if (m_Parameters.m_Misc.m_OutputPath.size()>0)
             filePath = m_Parameters.m_Misc.m_OutputPath;
 
         int c = 1;
 
         while (itksys::SystemTools::FileExists((filePath+fileName).c_str()))
         {
             fileName = "fiberfox_motion_";
             fileName += boost::lexical_cast<std::string>(c);
             fileName += ".log";
             c++;
         }
 
         m_Logfile.open((filePath+fileName).c_str());
         m_Logfile << "0 rotation: 0,0,0; translation: 0,0,0\n";
 
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
             m_StatusText += "Adding random motion artifacts:\n";
             m_StatusText += "Maximum rotation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°\n";
             m_StatusText += "Maximum translation: +/-" + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm\n";
         }
         else
         {
             m_StatusText += "Adding linear motion artifacts:\n";
             m_StatusText += "Maximum rotation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Rotation) + "°\n";
             m_StatusText += "Maximum translation: " + boost::lexical_cast<std::string>(m_Parameters.m_SignalGen.m_Translation) + "mm\n";
         }
         m_StatusText += "Motion logfile: " + (filePath+fileName) + "\n";
         MITK_INFO << "Adding motion artifacts";
         MITK_INFO << "Maximum rotation: " << m_Parameters.m_SignalGen.m_Rotation;
         MITK_INFO << "Maxmimum translation: " << m_Parameters.m_SignalGen.m_Translation;
     }
     maxVolume = 0;
 
     m_StatusText += "\n"+this->GetTime()+" > Generating " + boost::lexical_cast<std::string>(numFiberCompartments+numNonFiberCompartments) + "-compartment diffusion-weighted signal.\n";
     MITK_INFO << "Generating " << numFiberCompartments+numNonFiberCompartments << "-compartment diffusion-weighted signal.";
     int numFibers = m_FiberBundle->GetNumFibers();
     boost::progress_display disp(numFibers*m_Parameters.m_SignalGen.GetNumVolumes());
 
 
     // get transform for motion artifacts
     m_FiberBundleTransformed = m_FiberBundleWorkingCopy;
     m_Rotation = m_Parameters.m_SignalGen.m_Rotation/m_Parameters.m_SignalGen.GetNumVolumes();
     m_Translation = m_Parameters.m_SignalGen.m_Translation/m_Parameters.m_SignalGen.GetNumVolumes();
 
     // creat image to hold transformed mask (motion artifact)
     m_MaskImage = ItkUcharImgType::New();
     itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
     duplicator->SetInputImage(m_Parameters.m_SignalGen.m_MaskImage);
     duplicator->Update();
     m_MaskImage = duplicator->GetOutput();
 
     // second upsampling needed for motion artifacts
     ImageRegion<3>      upsampledImageRegion = m_UpsampledImageRegion;
     DoubleVectorType    upsampledSpacing = m_UpsampledSpacing;
     upsampledSpacing[0] /= 4;
     upsampledSpacing[1] /= 4;
     upsampledSpacing[2] /= 4;
     upsampledImageRegion.SetSize(0, m_UpsampledImageRegion.GetSize()[0]*4);
     upsampledImageRegion.SetSize(1, m_UpsampledImageRegion.GetSize()[1]*4);
     upsampledImageRegion.SetSize(2, m_UpsampledImageRegion.GetSize()[2]*4);
     itk::Point<double,3> upsampledOrigin = m_UpsampledOrigin;
     upsampledOrigin[0] -= m_UpsampledSpacing[0]/2; upsampledOrigin[0] += upsampledSpacing[0]/2;
     upsampledOrigin[1] -= m_UpsampledSpacing[1]/2; upsampledOrigin[1] += upsampledSpacing[1]/2;
     upsampledOrigin[2] -= m_UpsampledSpacing[2]/2; upsampledOrigin[2] += upsampledSpacing[2]/2;
     m_UpsampledMaskImage = ItkUcharImgType::New();
     itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::Pointer upsampler = itk::ResampleImageFilter<ItkUcharImgType, ItkUcharImgType>::New();
     upsampler->SetInput(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetOutputParametersFromImage(m_Parameters.m_SignalGen.m_MaskImage);
     upsampler->SetSize(upsampledImageRegion.GetSize());
     upsampler->SetOutputSpacing(upsampledSpacing);
     upsampler->SetOutputOrigin(upsampledOrigin);
     itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::Pointer nn_interpolator
             = itk::NearestNeighborInterpolateImageFunction<ItkUcharImgType, double>::New();
     upsampler->SetInterpolator(nn_interpolator);
     upsampler->Update();
     m_UpsampledMaskImage = upsampler->GetOutput();
 
+    if (m_HelperTdi.IsNotNull())
+    {
+        itk::ResampleImageFilter<ItkFloatImgType, ItkFloatImgType>::Pointer upsampler = itk::ResampleImageFilter<ItkFloatImgType, ItkFloatImgType>::New();
+        upsampler->SetInput(m_HelperTdi);
+        upsampler->SetOutputParametersFromImage(m_HelperTdi);
+        upsampler->SetSize(upsampledImageRegion.GetSize());
+        upsampler->SetOutputSpacing(upsampledSpacing);
+        upsampler->SetOutputOrigin(upsampledOrigin);
+        itk::NearestNeighborInterpolateImageFunction<ItkFloatImgType, double>::Pointer nn_interpolator
+                = itk::NearestNeighborInterpolateImageFunction<ItkFloatImgType, double>::New();
+        upsampler->SetInterpolator(nn_interpolator);
+        upsampler->Update();
+        m_HelperTdiUpsampled = upsampler->GetOutput();
+
+        m_HelperTdiTransformed = ItkFloatImgType::New();
+        itk::ImageDuplicator<ItkFloatImgType>::Pointer duplicator = itk::ImageDuplicator<ItkFloatImgType>::New();
+        duplicator->SetInputImage(m_HelperTdi);
+        duplicator->Update();
+        m_HelperTdiTransformed = duplicator->GetOutput();
+
+        m_HelperTdiCounter = ItkUcharImgType::New();
+        itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator2 = itk::ImageDuplicator<ItkUcharImgType>::New();
+        duplicator2->SetInputImage(m_MaskImage);
+        duplicator2->Update();
+        m_HelperTdiCounter = duplicator2->GetOutput();
+    }
+
     unsigned long lastTick = 0;
     int signalModelSeed = m_RandGen->GetIntegerVariate();
     switch (m_Parameters.m_SignalGen.m_DiffusionDirectionMode)
     {
     case(SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS):   // use fiber tangent directions to determine diffusion direction
     {
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
 
         for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
         {
             // Set signal model random generator seeds to get same configuration in each voxel
             for (int i=0; i<m_Parameters.m_FiberModelList.size(); i++)
                 m_Parameters.m_FiberModelList.at(i)->SetSeed(signalModelSeed);
             for (int i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
                 m_Parameters.m_NonFiberModelList.at(i)->SetSeed(signalModelSeed);
 
             ItkDoubleImgType::Pointer intraAxonalVolumeImage = ItkDoubleImgType::New();
             intraAxonalVolumeImage->SetSpacing( m_UpsampledSpacing );
             intraAxonalVolumeImage->SetOrigin( m_UpsampledOrigin );
             intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
             intraAxonalVolumeImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->SetBufferedRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->SetRequestedRegion( m_UpsampledImageRegion );
             intraAxonalVolumeImage->Allocate();
             intraAxonalVolumeImage->FillBuffer(0);
 
             vtkPolyData* fiberPolyData = m_FiberBundleTransformed->GetFiberPolyData();
 
+            // GET TDI
+            ItkDoubleImgType::Pointer TDI = ItkDoubleImgType::New();
+            TDI->SetSpacing( m_UpsampledSpacing );
+            TDI->SetOrigin( m_UpsampledOrigin );
+            TDI->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
+            TDI->SetLargestPossibleRegion( m_UpsampledImageRegion );
+            TDI->SetBufferedRegion( m_UpsampledImageRegion );
+            TDI->SetRequestedRegion( m_UpsampledImageRegion );
+            TDI->Allocate();
+            TDI->FillBuffer(0);
+            itk::TractDensityImageFilter< ItkDoubleImgType >::Pointer tdiFilter = itk::TractDensityImageFilter< ItkDoubleImgType >::New();
+            tdiFilter->SetFiberBundle(m_FiberBundleTransformed);
+            tdiFilter->SetBinaryOutput(false);
+            tdiFilter->SetOutputAbsoluteValues(false);
+            tdiFilter->SetInputImage(TDI);
+            tdiFilter->SetUseImageGeometry(true);
+            tdiFilter->SetDoFiberResampling(false);
+            tdiFilter->Update();
+            TDI = tdiFilter->GetOutput();
+
             // generate fiber signal (if there are any fiber models present)
             if (!m_Parameters.m_FiberModelList.empty())
                 for( int i=0; i<numFibers; i++ )
                 {
                     float fiberWeight = m_FiberBundleTransformed->GetFiberWeight(i);
                     vtkCell* cell = fiberPolyData->GetCell(i);
                     int numPoints = cell->GetNumberOfPoints();
                     vtkPoints* points = cell->GetPoints();
 
                     if (numPoints<2)
                         continue;
 
                     for( int j=0; j<numPoints; j++)
                     {
                         if (this->GetAbortGenerateData())
                         {
                             m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                             return;
                         }
 
                         double* temp = points->GetPoint(j);
                         itk::Point<float, 3> vertex = GetItkPoint(temp);
                         itk::Vector<double> v = GetItkVector(temp);
 
                         itk::Vector<double, 3> dir(3);
                         if (j<numPoints-1)
                             dir = GetItkVector(points->GetPoint(j+1))-v;
                         else
                             dir = v-GetItkVector(points->GetPoint(j-1));
 
                         if (dir.GetSquaredNorm()<0.0001 || dir[0]!=dir[0] || dir[1]!=dir[1] || dir[2]!=dir[2])
                             continue;
 
                         itk::Index<3> idx;
                         itk::ContinuousIndex<float, 3> contIndex;
                         m_MaskImage->TransformPhysicalPointToIndex(vertex, idx);
                         m_MaskImage->TransformPhysicalPointToContinuousIndex(vertex, contIndex);
 
                         if (!m_MaskImage->GetLargestPossibleRegion().IsInside(idx) || m_MaskImage->GetPixel(idx)<=0)
                             continue;
 
+                        double TdCorrectionFactor = 1;
+                        if (m_HelperTdiTransformed.IsNotNull())
+                        {
+                            double TD = TDI->GetPixel(idx);
+
+                            itk::Index<3> idx2;
+                            m_HelperTdiTransformed->TransformPhysicalPointToIndex(vertex, idx2);
+                            double HTD = m_HelperTdiTransformed->GetPixel(idx2);
+                            if (TD>0)
+                                TdCorrectionFactor = HTD/TD;
+                        }
+
                         // generate signal for each fiber compartment
                         for (int k=0; k<numFiberCompartments; k++)
                         {
                             m_Parameters.m_FiberModelList[k]->SetFiberDirection(dir);
                             DoubleDwiType::PixelType pix = m_CompartmentImages.at(k)->GetPixel(idx);
-                            pix[g] += fiberWeight*segmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g);
+                            pix[g] += TdCorrectionFactor*fiberWeight*segmentVolume*m_Parameters.m_FiberModelList[k]->SimulateMeasurement(g);
 
                             m_CompartmentImages.at(k)->SetPixel(idx, pix);
                         }
 
                         // update fiber volume image
-                        double vol = intraAxonalVolumeImage->GetPixel(idx) + segmentVolume*fiberWeight;
+                        double vol = intraAxonalVolumeImage->GetPixel(idx) + segmentVolume*fiberWeight*TdCorrectionFactor;
                         intraAxonalVolumeImage->SetPixel(idx, vol);
                         if (g==0 && vol>maxVolume)
                             maxVolume = vol;
                     }
 
                     // progress report
                     ++disp;
                     unsigned long newTick = 50*disp.count()/disp.expected_count();
                     for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
                         m_StatusText += "*";
                     lastTick = newTick;
                 }
 
             // generate non-fiber signal
             ImageRegionIterator<ItkUcharImgType> it3(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
             double fact = 1;
             if (m_Parameters.m_SignalGen.m_AxonRadius<0.0001 || maxVolume>m_VoxelVolume)
                 fact = m_VoxelVolume/maxVolume;
             while(!it3.IsAtEnd())
             {
                 if (it3.Get()>0)
                 {
                     DoubleDwiType::IndexType index = it3.GetIndex();
 
                     // adjust intra-axonal signal to abtain an only-fiber voxel
                     if (fabs(fact-1.0)>0.0001)
+                    {
                         for (int i=0; i<numFiberCompartments; i++)
                         {
                             DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                             pix[g] *= fact;
                             m_CompartmentImages.at(i)->SetPixel(index, pix);
                         }
+                    }
+
+                    //                    double w = 1;
+                    //                    double intraAxonalVolume = intraAxonalVolumeImage->GetPixel(index)*fact;
+                    //                    if (intraAxonalVolume>0.0001 && intraAxonalVolume<0.3)  // only fiber in voxel
+                    //                    {
+                    //                        w = (m_VoxelVolume*0.3)/intraAxonalVolume;
+                    //                        for (int i=0; i<numFiberCompartments; i++)
+                    //                        {
+                    //                            DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
+                    //                            pix[g] *= w;
+                    //                            m_CompartmentImages.at(i)->SetPixel(index, pix);
+                    //                        }
+
+                    //                        m_VolumeFractions.at(0)->SetPixel(index, 1);
+                    //                    }
+
 
                     // simulate other compartments
                     SimulateNonFiberSignal(index, intraAxonalVolumeImage->GetPixel(index)*fact, g);
                 }
                 ++it3;
             }
 
             // move fibers
             SimulateMotion(g);
         }
         break;
     }
     case (SignalGenerationParameters::MAIN_FIBER_DIRECTIONS): // use main fiber directions to determine voxel-wise diffusion directions
     {
         typedef itk::Image< itk::Vector< float, 3>, 3 >                                 ItkDirectionImage3DType;
         typedef itk::VectorContainer< unsigned int, ItkDirectionImage3DType::Pointer >  ItkDirectionImageContainerType;
 
         // calculate main fiber directions
         itk::TractsToVectorImageFilter<float>::Pointer fOdfFilter = itk::TractsToVectorImageFilter<float>::New();
         fOdfFilter->SetFiberBundle(m_FiberBundleTransformed);
         fOdfFilter->SetMaskImage(m_MaskImage);
         fOdfFilter->SetAngularThreshold(cos(m_Parameters.m_SignalGen.m_FiberSeparationThreshold*M_PI/180.0));
         fOdfFilter->SetNormalizeVectors(false);
         fOdfFilter->SetUseWorkingCopy(true);
         fOdfFilter->SetSizeThreshold(0);
         fOdfFilter->SetMaxNumDirections(3);
         fOdfFilter->Update();
         ItkDirectionImageContainerType::Pointer directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
         // allocate image storing intra-axonal volume fraction information
         ItkDoubleImgType::Pointer intraAxonalVolumeImage = ItkDoubleImgType::New();
         intraAxonalVolumeImage->SetSpacing( m_UpsampledSpacing );
         intraAxonalVolumeImage->SetOrigin( m_UpsampledOrigin );
         intraAxonalVolumeImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         intraAxonalVolumeImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->SetBufferedRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->SetRequestedRegion( m_UpsampledImageRegion );
         intraAxonalVolumeImage->Allocate();
         intraAxonalVolumeImage->FillBuffer(0);
 
         // determine intra-axonal volume fraction using the tract density
         itk::TractDensityImageFilter< ItkDoubleImgType >::Pointer tdiFilter = itk::TractDensityImageFilter< ItkDoubleImgType >::New();
         tdiFilter->SetFiberBundle(m_FiberBundleTransformed);
         tdiFilter->SetBinaryOutput(false);
         tdiFilter->SetOutputAbsoluteValues(false);
         tdiFilter->SetInputImage(intraAxonalVolumeImage);
         tdiFilter->SetUseImageGeometry(true);
         tdiFilter->Update();
         intraAxonalVolumeImage = tdiFilter->GetOutput();
 
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
         boost::progress_display disp(m_MaskImage->GetLargestPossibleRegion().GetNumberOfPixels()*m_Parameters.m_SignalGen.GetNumVolumes());
 
         for (unsigned int g=0; g<m_Parameters.m_SignalGen.GetNumVolumes(); g++)
         {
             // Set signal model random generator seeds to get same configuration in each voxel
             for (int i=0; i<m_Parameters.m_FiberModelList.size(); i++)
                 m_Parameters.m_FiberModelList.at(i)->SetSeed(signalModelSeed);
             for (int i=0; i<m_Parameters.m_NonFiberModelList.size(); i++)
                 m_Parameters.m_NonFiberModelList.at(i)->SetSeed(signalModelSeed);
 
             if (m_Parameters.m_SignalGen.m_DoAddMotion && g>0)  // if fibers have moved we need a new TDI and new directions
             {
                 fOdfFilter->SetFiberBundle(m_FiberBundleTransformed);
                 fOdfFilter->SetMaskImage(m_MaskImage);
                 fOdfFilter->Update();
                 directionImageContainer = fOdfFilter->GetDirectionImageContainer();
 
                 tdiFilter->SetFiberBundle(m_FiberBundleTransformed);
                 tdiFilter->Update();
                 intraAxonalVolumeImage = tdiFilter->GetOutput();
             }
 
             ImageRegionIterator< ItkUcharImgType > it(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
             while(!it.IsAtEnd())
             {
                 ++disp;
                 unsigned long newTick = 50*disp.count()/disp.expected_count();
                 for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
                     m_StatusText += "*";
                 lastTick = newTick;
 
                 if (this->GetAbortGenerateData())
                 {
                     m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                     return;
                 }
 
                 if (it.Get()>0)
                 {
                     // generate fiber signal
                     for (int c=0; c<m_Parameters.m_FiberModelList.size(); c++)
                     {
                         int count = 0;
                         DoubleDwiType::PixelType pix = m_CompartmentImages.at(c)->GetPixel(it.GetIndex());
                         for (unsigned int i=0; i<directionImageContainer->Size(); i++)
                         {
                             itk::Vector< double, 3> dir;
                             dir.CastFrom(directionImageContainer->GetElement(i)->GetPixel(it.GetIndex()));
                             double norm = dir.GetNorm();
                             if (norm>0.0001)
                             {
                                 m_Parameters.m_FiberModelList.at(c)->SetFiberDirection(dir);
                                 pix[g] += m_Parameters.m_FiberModelList.at(c)->SimulateMeasurement(g)*norm;
                                 count++;
                             }
                         }
                         if (count>0)
                             pix[g] /= count;
                         pix[g] *= intraAxonalVolumeImage->GetPixel(it.GetIndex())*m_VoxelVolume;
                         m_CompartmentImages.at(c)->SetPixel(it.GetIndex(), pix);
                     }
 
                     // simulate other compartments
                     SimulateNonFiberSignal(it.GetIndex(), intraAxonalVolumeImage->GetPixel(it.GetIndex())*m_VoxelVolume, g);
                 }
                 ++it;
             }
 
             SimulateMotion(g);
         }
 
         itk::ImageFileWriter< ItkUcharImgType >::Pointer wr = itk::ImageFileWriter< ItkUcharImgType >::New();
         wr->SetInput(fOdfFilter->GetNumDirectionsImage());
         wr->SetFileName(mitk::IOUtil::GetTempPath()+"/NumDirections_MainFiberDirections.nrrd");
         wr->Update();
         break;
     }
     case (SignalGenerationParameters::RANDOM_DIRECTIONS):
     {
         ItkUcharImgType::Pointer numDirectionsImage = ItkUcharImgType::New();
         numDirectionsImage->SetSpacing( m_UpsampledSpacing );
         numDirectionsImage->SetOrigin( m_UpsampledOrigin );
         numDirectionsImage->SetDirection( m_Parameters.m_SignalGen.m_ImageDirection );
         numDirectionsImage->SetLargestPossibleRegion( m_UpsampledImageRegion );
         numDirectionsImage->SetBufferedRegion( m_UpsampledImageRegion );
         numDirectionsImage->SetRequestedRegion( m_UpsampledImageRegion );
         numDirectionsImage->Allocate();
         numDirectionsImage->FillBuffer(0);
         double sepAngle = cos(m_Parameters.m_SignalGen.m_FiberSeparationThreshold*M_PI/180.0);
 
         m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
         m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
         boost::progress_display disp(m_MaskImage->GetLargestPossibleRegion().GetNumberOfPixels());
         ImageRegionIterator<ItkUcharImgType> it(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
         while(!it.IsAtEnd())
         {
             ++disp;
             unsigned long newTick = 50*disp.count()/disp.expected_count();
             for (unsigned int tick = 0; tick<(newTick-lastTick); tick++)
                 m_StatusText += "*";
             lastTick = newTick;
 
             if (this->GetAbortGenerateData())
             {
                 m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
                 return;
             }
 
             if (it.Get()>0)
             {
                 int numFibs = m_RandGen->GetIntegerVariate(2)+1;
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(it.GetIndex());
                 double volume = m_RandGen->GetVariateWithClosedRange(0.3);
 
                 //                double sum = 0;
                 std::vector< double > fractions;
                 for (int i=0; i<numFibs; i++)
                 {
                     //                    fractions.push_back(1);
                     fractions.push_back(0.5+m_RandGen->GetVariateWithClosedRange(0.5));
                     //                    sum += fractions.at(i);
                 }
                 //                for (int i=0; i<numFibs; i++)
                 //                    fractions[i] /= sum;
 
                 std::vector< itk::Vector<double, 3> > directions;
                 for (int i=0; i<numFibs; i++)
                 {
                     DoubleVectorType fib;
                     fib[0] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib[1] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib[2] = m_RandGen->GetVariateWithClosedRange(2)-1.0;
                     fib.Normalize();
 
                     double min = 0;
                     for (unsigned int d=0; d<directions.size(); d++)
                     {
                         double angle = fabs(fib*directions[d]);
                         if (angle>min)
                             min = angle;
                     }
                     if (min<sepAngle)
                     {
                         m_Parameters.m_FiberModelList.at(0)->SetFiberDirection(fib);
                         pix += m_Parameters.m_FiberModelList.at(0)->SimulateMeasurement()*fractions[i];
                         directions.push_back(fib);
                     }
                     else
                         i--;
                 }
                 pix *= (1-volume);
                 m_CompartmentImages.at(0)->SetPixel(it.GetIndex(), pix);
 
                 // CSF/GM
                 {
                     pix += volume*m_Parameters.m_NonFiberModelList.at(0)->SimulateMeasurement();
                 }
 
                 numDirectionsImage->SetPixel(it.GetIndex(), numFibs);
             }
             ++it;
         }
 
         itk::ImageFileWriter< ItkUcharImgType >::Pointer wr = itk::ImageFileWriter< ItkUcharImgType >::New();
         wr->SetInput(numDirectionsImage);
         wr->SetFileName(mitk::IOUtil::GetTempPath()+"/NumDirections_RandomDirections.nrrd");
         wr->Update();
     }
     }
 
     if (m_Logfile.is_open())
     {
         m_Logfile << "DONE";
         m_Logfile.close();
     }
     m_StatusText += "\n\n";
     if (this->GetAbortGenerateData())
     {
         m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
     DoubleDwiType::Pointer doubleOutImage;
     if ( m_Parameters.m_SignalGen.m_SimulateKspaceAcquisition ) // do k-space stuff
     {
         m_StatusText += this->GetTime()+" > Adjusting complex signal\n";
         MITK_INFO << "Adjusting complex signal:";
 
         if (m_Parameters.m_SignalGen.m_DoSimulateRelaxation)
             m_StatusText += "Simulating signal relaxation\n";
         if (m_Parameters.m_SignalGen.m_FrequencyMap.IsNotNull())
             m_StatusText += "Simulating distortions\n";
         if (m_Parameters.m_SignalGen.m_DoAddGibbsRinging)
             m_StatusText += "Simulating ringing artifacts\n";
         if (m_Parameters.m_SignalGen.m_EddyStrength>0)
             m_StatusText += "Simulating eddy currents\n";
         if (m_Parameters.m_SignalGen.m_Spikes>0)
             m_StatusText += "Simulating spikes\n";
         if (m_Parameters.m_SignalGen.m_CroppingFactor<1.0)
             m_StatusText += "Simulating aliasing artifacts\n";
         if (m_Parameters.m_SignalGen.m_KspaceLineOffset>0)
             m_StatusText += "Simulating ghosts\n";
 
         doubleOutImage = DoKspaceStuff(m_CompartmentImages);
         m_Parameters.m_SignalGen.m_SignalScale = 1; // already scaled in DoKspaceStuff
     }
     else    // don't do k-space stuff, just sum compartments
     {
         m_StatusText += this->GetTime()+" > Summing compartments\n";
         MITK_INFO << "Summing compartments";
         doubleOutImage = m_CompartmentImages.at(0);
 
         for (unsigned int i=1; i<m_CompartmentImages.size(); i++)
         {
             itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::Pointer adder = itk::AddImageFilter< DoubleDwiType, DoubleDwiType, DoubleDwiType>::New();
             adder->SetInput1(doubleOutImage);
             adder->SetInput2(m_CompartmentImages.at(i));
             adder->Update();
             doubleOutImage = adder->GetOutput();
         }
     }
     if (this->GetAbortGenerateData())
     {
         m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
         return;
     }
 
     m_StatusText += this->GetTime()+" > Finalizing image\n";
     MITK_INFO << "Finalizing image";
     if (m_Parameters.m_SignalGen.m_SignalScale>1)
         m_StatusText += " Scaling signal\n";
     if (m_Parameters.m_NoiseModel!=NULL)
         m_StatusText += " Adding noise\n";
     unsigned int window = 0;
     unsigned int min = itk::NumericTraits<unsigned int>::max();
     ImageRegionIterator<OutputImageType> it4 (outImage, outImage->GetLargestPossibleRegion());
     DoubleDwiType::PixelType signal; signal.SetSize(m_Parameters.m_SignalGen.GetNumVolumes());
     boost::progress_display disp2(outImage->GetLargestPossibleRegion().GetNumberOfPixels());
 
     m_StatusText += "0%   10   20   30   40   50   60   70   80   90   100%\n";
     m_StatusText += "|----|----|----|----|----|----|----|----|----|----|\n*";
     lastTick = 0;
 
     while(!it4.IsAtEnd())
     {
         if (this->GetAbortGenerateData())
         {
             m_StatusText += "\n"+this->GetTime()+" > Simulation aborted\n";
             return;
         }
 
         ++disp2;
         unsigned long newTick = 50*disp2.count()/disp2.expected_count();
         for (unsigned long tick = 0; tick<(newTick-lastTick); tick++)
             m_StatusText += "*";
         lastTick = newTick;
 
         typename OutputImageType::IndexType index = it4.GetIndex();
         signal = doubleOutImage->GetPixel(index)*m_Parameters.m_SignalGen.m_SignalScale;
 
         if (m_Parameters.m_NoiseModel!=NULL)
             m_Parameters.m_NoiseModel->AddNoise(signal);
 
         for (unsigned int i=0; i<signal.Size(); i++)
         {
             if (signal[i]>0)
                 signal[i] = floor(signal[i]+0.5);
             else
                 signal[i] = ceil(signal[i]-0.5);
 
             if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]>window)
                 window = signal[i];
             if ( (!m_Parameters.m_SignalGen.IsBaselineIndex(i) || signal.Size()==1) && signal[i]<min)
                 min = signal[i];
         }
         it4.Set(signal);
         ++it4;
     }
     window -= min;
     unsigned int level = window/2 + min;
     m_LevelWindow.SetLevelWindow(level, window);
     this->SetNthOutput(0, outImage);
 
     m_StatusText += "\n\n";
     m_StatusText += "Finished simulation\n";
     m_StatusText += "Simulation time: "+GetTime();
     m_TimeProbe.Stop();
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::SimulateMotion(int g)
 {
     if (m_Parameters.m_SignalGen.m_DoAddMotion && g<m_Parameters.m_SignalGen.GetNumVolumes()-1)
     {
         if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
         {
             m_FiberBundleTransformed = m_FiberBundleWorkingCopy->GetDeepCopy();
             m_Rotation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[0]*2)-m_Parameters.m_SignalGen.m_Rotation[0];
             m_Rotation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[1]*2)-m_Parameters.m_SignalGen.m_Rotation[1];
             m_Rotation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Rotation[2]*2)-m_Parameters.m_SignalGen.m_Rotation[2];
             m_Translation[0] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[0]*2)-m_Parameters.m_SignalGen.m_Translation[0];
             m_Translation[1] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[1]*2)-m_Parameters.m_SignalGen.m_Translation[1];
             m_Translation[2] = m_RandGen->GetVariateWithClosedRange(m_Parameters.m_SignalGen.m_Translation[2]*2)-m_Parameters.m_SignalGen.m_Translation[2];
         }
 
         // rotate mask image
         if (m_MaskImageSet)
         {
             ImageRegionIterator<ItkUcharImgType> maskIt(m_UpsampledMaskImage, m_UpsampledMaskImage->GetLargestPossibleRegion());
             m_MaskImage->FillBuffer(0);
 
             while(!maskIt.IsAtEnd())
             {
                 if (maskIt.Get()<=0)
                 {
                     ++maskIt;
                     continue;
                 }
 
                 DoubleDwiType::IndexType index = maskIt.GetIndex();
                 itk::Point<double, 3> point;
                 m_UpsampledMaskImage->TransformIndexToPhysicalPoint(index, point);
                 if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
                     point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
                 else
                     point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), m_Rotation[0]*(g+1),m_Rotation[1]*(g+1),m_Rotation[2]*(g+1),m_Translation[0]*(g+1),m_Translation[1]*(g+1),m_Translation[2]*(g+1));
 
                 m_MaskImage->TransformPhysicalPointToIndex(point, index);
                 if (m_MaskImage->GetLargestPossibleRegion().IsInside(index))
                     m_MaskImage->SetPixel(index,100);
                 ++maskIt;
             }
+//            itk::ImageFileWriter<ItkUcharImgType>::Pointer wr = itk::ImageFileWriter<ItkUcharImgType>::New();
+//            wr->SetInput(m_MaskImage);
+//            wr->SetFileName("/local/MASK_transformed.nrrd");
+//            wr->Update();
+        }
+
+        if (m_HelperTdiUpsampled.IsNotNull())
+        {
+            ImageRegionIterator<ItkFloatImgType> maskIt(m_HelperTdiUpsampled, m_HelperTdiUpsampled->GetLargestPossibleRegion());
+            m_HelperTdiTransformed->FillBuffer(0);
+            m_HelperTdiCounter->FillBuffer(0);
+
+            while(!maskIt.IsAtEnd())
+            {
+                DoubleDwiType::IndexType index = maskIt.GetIndex();
+
+                itk::Point<double, 3> point;
+                m_HelperTdiUpsampled->TransformIndexToPhysicalPoint(index, point);
+                if (m_Parameters.m_SignalGen.m_DoRandomizeMotion)
+                    point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
+                else
+                    point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), m_Rotation[0]*(g+1),m_Rotation[1]*(g+1),m_Rotation[2]*(g+1),m_Translation[0]*(g+1),m_Translation[1]*(g+1),m_Translation[2]*(g+1));
+
+                m_HelperTdiTransformed->TransformPhysicalPointToIndex(point, index);
+                if (m_HelperTdiTransformed->GetLargestPossibleRegion().IsInside(index) && m_MaskImage->GetPixel(index)>0)
+                {
+                    m_HelperTdiTransformed->SetPixel(index, m_HelperTdiTransformed->GetPixel(index)+maskIt.Get());
+                    m_HelperTdiCounter->SetPixel(index, m_HelperTdiCounter->GetPixel(index)+1);
+                }
+                ++maskIt;
+            }
+
+            ImageRegionIterator<ItkFloatImgType> maskIt2(m_HelperTdiTransformed, m_HelperTdiTransformed->GetLargestPossibleRegion());
+            while(!maskIt2.IsAtEnd())
+            {
+                DoubleDwiType::IndexType index = maskIt2.GetIndex();
+                if (m_HelperTdiCounter->GetPixel(index)>0)
+                {
+                    m_HelperTdiTransformed->SetPixel(index, maskIt2.Get()/m_HelperTdiCounter->GetPixel(index));
+                }
+                ++maskIt2;
+            }
+
+//            itk::ImageFileWriter<ItkFloatImgType>::Pointer wr = itk::ImageFileWriter<ItkFloatImgType>::New();
+//            wr->SetInput(m_HelperTdiTransformed);
+//            wr->SetFileName("/local/TDI_transformed.nrrd");
+//            wr->Update();
         }
 
         // rotate fibers
         if (m_Logfile.is_open())
         {
             m_Logfile << g+1 << " rotation: " << m_Rotation[0] << "," << m_Rotation[1] << "," << m_Rotation[2] << ";";
             m_Logfile << " translation: " << m_Translation[0] << "," << m_Translation[1] << "," << m_Translation[2] << "\n";
         }
         m_FiberBundleTransformed->TransformFibers(m_Rotation[0],m_Rotation[1],m_Rotation[2],m_Translation[0],m_Translation[1],m_Translation[2]);
     }
 }
 
 template< class PixelType >
 void TractsToDWIImageFilter< PixelType >::SimulateNonFiberSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g)
 {
     int numFiberCompartments = m_Parameters.m_FiberModelList.size();
     int numNonFiberCompartments = m_Parameters.m_NonFiberModelList.size();
 
     if (intraAxonalVolume>0.0001 && m_Parameters.m_SignalGen.m_DoDisablePartialVolume)  // only fiber in voxel
     {
         DoubleDwiType::PixelType pix = m_CompartmentImages.at(0)->GetPixel(index);
         if (g>=0)
             pix[g] *= m_VoxelVolume/intraAxonalVolume;
         else
             pix *= m_VoxelVolume/intraAxonalVolume;
         m_CompartmentImages.at(0)->SetPixel(index, pix);
         m_VolumeFractions.at(0)->SetPixel(index, 1);
         for (int i=1; i<numFiberCompartments; i++)
         {
             DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
             if (g>=0)
                 pix[g] = 0.0;
             else
                 pix.Fill(0.0);
             m_CompartmentImages.at(i)->SetPixel(index, pix);
         }
     }
     else
     {
         m_VolumeFractions.at(0)->SetPixel(index, intraAxonalVolume/m_VoxelVolume);
 
         itk::Point<double, 3> point;
         m_MaskImage->TransformIndexToPhysicalPoint(index, point);
         if (m_Parameters.m_SignalGen.m_DoAddMotion)
         {
             if (m_Parameters.m_SignalGen.m_DoRandomizeMotion && g>0)
                 point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), -m_Rotation[0],-m_Rotation[1],-m_Rotation[2],-m_Translation[0],-m_Translation[1],-m_Translation[2]);
             else if (g>=0)
                 point = m_FiberBundleWorkingCopy->TransformPoint(point.GetVnlVector(), -m_Rotation[0]*g,-m_Rotation[1]*g,-m_Rotation[2]*g,-m_Translation[0]*g,-m_Translation[1]*g,-m_Translation[2]*g);
         }
 
         if (m_Parameters.m_SignalGen.m_DoDisablePartialVolume)
         {
             int maxVolumeIndex = 0;
             double maxWeight = 0;
             for (int i=0; i<numNonFiberCompartments; i++)
             {
                 double weight = 0;
                 if (numNonFiberCompartments>1)
                 {
+                    ItkUcharImgType::IndexType maskIndex;
+                    m_UpsampledMaskImage->TransformPhysicalPointToIndex(point, maskIndex);
+                    if (!m_UpsampledMaskImage->GetLargestPossibleRegion().IsInside(maskIndex) || m_UpsampledMaskImage->GetPixel(maskIndex)==0)
+                        continue;
                     DoubleDwiType::IndexType newIndex;
                     m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->TransformPhysicalPointToIndex(point, newIndex);
                     if (!m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion().IsInside(newIndex))
                         continue;
                     weight = m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetPixel(newIndex);
                 }
 
                 if (weight>maxWeight)
                 {
                     maxWeight = weight;
                     maxVolumeIndex = i;
                 }
             }
             DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(maxVolumeIndex+numFiberCompartments);
             DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
 
             if (g>=0)
                 pix[g] += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement(g);
             else
                 pix += m_Parameters.m_NonFiberModelList[maxVolumeIndex]->SimulateMeasurement();
             doubleDwi->SetPixel(index, pix);
             m_VolumeFractions.at(maxVolumeIndex+numFiberCompartments)->SetPixel(index, 1);
         }
         else
         {
             double extraAxonalVolume = m_VoxelVolume-intraAxonalVolume;    // non-fiber volume
             double interAxonalVolume = 0;
             if (numFiberCompartments>1)
                 interAxonalVolume = extraAxonalVolume * intraAxonalVolume/m_VoxelVolume;   // inter-axonal fraction of non fiber compartment scales linearly with f
             double other = extraAxonalVolume - interAxonalVolume;        // rest of compartment
             double singleinter = interAxonalVolume/(numFiberCompartments-1);
 
             // adjust non-fiber and intra-axonal signal
             for (int i=1; i<numFiberCompartments; i++)
             {
                 DoubleDwiType::PixelType pix = m_CompartmentImages.at(i)->GetPixel(index);
                 if (intraAxonalVolume>0)    // remove scaling by intra-axonal volume from inter-axonal compartment
                 {
                     if (g>=0)
                         pix[g] /= intraAxonalVolume;
                     else
                         pix /= intraAxonalVolume;
                 }
                 if (g>=0)
                     pix[g] *= singleinter;
                 else
                     pix *= singleinter;
                 m_CompartmentImages.at(i)->SetPixel(index, pix);
                 m_VolumeFractions.at(i)->SetPixel(index, singleinter/m_VoxelVolume);
             }
 
             for (int i=0; i<numNonFiberCompartments; i++)
             {
                 double weight = 1;
                 if (numNonFiberCompartments>1)
                 {
+                    ItkUcharImgType::IndexType maskIndex;
+                    m_UpsampledMaskImage->TransformPhysicalPointToIndex(point, maskIndex);
+                    if (!m_UpsampledMaskImage->GetLargestPossibleRegion().IsInside(maskIndex) || m_UpsampledMaskImage->GetPixel(maskIndex)==0)
+                        continue;
                     DoubleDwiType::IndexType newIndex;
                     m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->TransformPhysicalPointToIndex(point, newIndex);
                     if (!m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetLargestPossibleRegion().IsInside(newIndex))
                         continue;
                     weight = m_Parameters.m_NonFiberModelList[i]->GetVolumeFractionImage()->GetPixel(newIndex);
                 }
 
                 DoubleDwiType::Pointer doubleDwi = m_CompartmentImages.at(i+numFiberCompartments);
                 DoubleDwiType::PixelType pix = doubleDwi->GetPixel(index);
 
                 if (g>=0)
                     pix[g] += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement(g)*other*weight;
                 else
                     pix += m_Parameters.m_NonFiberModelList[i]->SimulateMeasurement()*other*weight;
                 doubleDwi->SetPixel(index, pix);
                 m_VolumeFractions.at(i+numFiberCompartments)->SetPixel(index, other/m_VoxelVolume*weight);
             }
         }
     }
 }
 
 template< class PixelType >
 itk::Point<float, 3> TractsToDWIImageFilter< PixelType >::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 template< class PixelType >
 itk::Vector<double, 3> TractsToDWIImageFilter< PixelType >::GetItkVector(double point[3])
 {
     itk::Vector<double, 3> itkVector;
     itkVector[0] = point[0];
     itkVector[1] = point[1];
     itkVector[2] = point[2];
     return itkVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(double point[3])
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = point[0];
     vnlVector[1] = point[1];
     vnlVector[2] = point[2];
     return vnlVector;
 }
 
 template< class PixelType >
 vnl_vector_fixed<double, 3> TractsToDWIImageFilter< PixelType >::GetVnlVector(Vector<float,3>& vector)
 {
     vnl_vector_fixed<double, 3> vnlVector;
     vnlVector[0] = vector[0];
     vnlVector[1] = vector[1];
     vnlVector[2] = vector[2];
     return vnlVector;
 }
 
 template< class PixelType >
 double TractsToDWIImageFilter< PixelType >::RoundToNearest(double num) {
     return (num > 0.0) ? floor(num + 0.5) : ceil(num - 0.5);
 }
 
 template< class PixelType >
 std::string TractsToDWIImageFilter< PixelType >::GetTime()
 {
     m_TimeProbe.Stop();
     unsigned long total = RoundToNearest(m_TimeProbe.GetTotal());
     unsigned long hours = total/3600;
     unsigned long minutes = (total%3600)/60;
     unsigned long seconds = total%60;
     std::string out = "";
     out.append(boost::lexical_cast<std::string>(hours));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(minutes));
     out.append(":");
     out.append(boost::lexical_cast<std::string>(seconds));
     m_TimeProbe.Start();
     return out;
 }
 
 }
diff --git a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
index c284489d44..fdc2b3980a 100755
--- a/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
+++ b/Modules/DiffusionImaging/FiberTracking/Algorithms/itkTractsToDWIImageFilter.h
@@ -1,131 +1,139 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 #ifndef __itkTractsToDWIImageFilter_h__
 #define __itkTractsToDWIImageFilter_h__
 
 #include <mitkFiberBundleX.h>
 #include <itkVnlForwardFFTImageFilter.h>
 #include <itkVectorImage.h>
 #include <cmath>
 #include <mitkFiberfoxParameters.h>
 #include <itkTimeProbe.h>
 #include <mitkRawShModel.h>
 #include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>
 
 namespace itk
 {
 
 /**
 * \brief Generates artificial diffusion weighted image volume from the input fiberbundle using a generic multicompartment model.
 * See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 */
 
 template< class PixelType >
 class TractsToDWIImageFilter : public ImageSource< itk::VectorImage< PixelType, 3 > >
 {
 
 public:
 
     typedef TractsToDWIImageFilter                          Self;
     typedef ImageSource< itk::VectorImage< PixelType, 3 > > Superclass;
     typedef SmartPointer< Self >                            Pointer;
     typedef SmartPointer< const Self >                      ConstPointer;
 
     typedef typename Superclass::OutputImageType                        OutputImageType;
     typedef itk::Image<double, 3>                                       ItkDoubleImgType;
+    typedef itk::Image<float, 3>                                        ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>                                ItkUcharImgType;
     typedef mitk::FiberBundleX::Pointer                                 FiberBundleType;
     typedef itk::VectorImage< double, 3 >                               DoubleDwiType;
     typedef itk::Matrix<double, 3, 3>                                   MatrixType;
     typedef itk::Image< double, 2 >                                     SliceType;
     typedef itk::VnlForwardFFTImageFilter<SliceType>::OutputImageType   ComplexSliceType;
     typedef itk::Vector< double,3>                                      DoubleVectorType;
 
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
     itkTypeMacro( TractsToDWIImageFilter, ImageSource )
 
     /** Input */
     itkSetMacro( FiberBundle, FiberBundleType )             ///< Input fiber bundle
     itkSetMacro( UseConstantRandSeed, bool )                ///< Seed for random generator.
     void SetParameters( FiberfoxParameters<double> param )  ///< Simulation parameters.
     { m_Parameters = param; }
+    itkSetMacro( HelperTdi, ItkFloatImgType::Pointer )
 
     /** Output */
     FiberfoxParameters<double> GetParameters(){ return m_Parameters; }
     std::vector< ItkDoubleImgType::Pointer > GetVolumeFractions() ///< one double image for each compartment containing the corresponding volume fraction per voxel
     { return m_VolumeFractions; }
     mitk::LevelWindow GetLevelWindow(){ return m_LevelWindow; }
     itkGetMacro( StatusText, std::string )
 
     void GenerateData();
 
 protected:
 
     TractsToDWIImageFilter();
     virtual ~TractsToDWIImageFilter();
     itk::Point<float, 3> GetItkPoint(double point[3]);
     itk::Vector<double, 3> GetItkVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(double point[3]);
     vnl_vector_fixed<double, 3> GetVnlVector(Vector< float, 3 >& vector);
     double RoundToNearest(double num);
     std::string GetTime();
 
     /** Transform generated image compartment by compartment, channel by channel and slice by slice using DFT and add k-space artifacts. */
     DoubleDwiType::Pointer DoKspaceStuff(std::vector< DoubleDwiType::Pointer >& images);
 
     /** Generate signal of non-fiber compartments. */
     void SimulateNonFiberSignal(ItkUcharImgType::IndexType index, double intraAxonalVolume, int g=-1);
 
     /** Move fibers to simulate headmotion */
     void SimulateMotion(int g=-1);
 
     // input
     mitk::FiberfoxParameters<double>            m_Parameters;
     FiberBundleType                             m_FiberBundle;
 
     // output
     mitk::LevelWindow                           m_LevelWindow;
     std::vector< ItkDoubleImgType::Pointer >    m_VolumeFractions;
     std::string                                 m_StatusText;
 
     // MISC
     itk::TimeProbe                              m_TimeProbe;
     bool                                        m_UseConstantRandSeed;
     bool                                        m_MaskImageSet;
     ofstream                                    m_Logfile;
 
     // signal generation
     FiberBundleType                             m_FiberBundleWorkingCopy;   ///< we work on an upsampled version of the input bundle
     FiberBundleType                             m_FiberBundleTransformed;   ///< transformed bundle simulating headmotion
     itk::Vector<double,3>                       m_UpsampledSpacing;
     itk::Point<double,3>                        m_UpsampledOrigin;
     ImageRegion<3>                              m_UpsampledImageRegion;
     double                                      m_VoxelVolume;
     std::vector< DoubleDwiType::Pointer >       m_CompartmentImages;
     ItkUcharImgType::Pointer                    m_MaskImage;                ///< copy of mask image (changes for each motion step)
     ItkUcharImgType::Pointer                    m_UpsampledMaskImage;       ///< helper image for motion simulation
     DoubleVectorType                            m_Rotation;
     DoubleVectorType                            m_Translation;
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_RandGen;
+
+    // TEMP
+    ItkFloatImgType::Pointer                    m_HelperTdi;
+    ItkFloatImgType::Pointer                    m_HelperTdiUpsampled;
+    ItkFloatImgType::Pointer                    m_HelperTdiTransformed;
+    ItkUcharImgType::Pointer                    m_HelperTdiCounter;
 };
 }
 
 #ifndef ITK_MANUAL_INSTANTIATION
 #include "itkTractsToDWIImageFilter.cpp"
 #endif
 
 #endif
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 fd750f32f1..def44bc6da 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.cpp
@@ -1,2694 +1,2701 @@
 /*===================================================================
 
 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 <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 <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateIsDWI.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 <mitkIOUtil.h>
 #include <QScrollBar>
 #include <itkInvertIntensityImageFilter.h>
 #include <QDialogButtonBox>
 #include <itkAdcImageFilter.h>
 #include <itkShiftScaleImageFilter.h>
 #include <mitkITKImageImport.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.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_SelectedImageNode( NULL )
     , m_Worker(this)
     , m_ThreadIsRunning(false)
 {
     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;
     }
     m_Controls->m_AbortSimulationButton->setEnabled(false);
     m_Controls->m_AbortSimulationButton->setText("Aborting simulation ...");
 }
 
 void QmitkFiberfoxView::BeforeThread()
 {
     m_SimulationTime = QTime::currentTime();
     m_SimulationTimer->start(100);
     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_AbortSimulationButton->setEnabled(true);
     m_Controls->m_AbortSimulationButton->setText("Abort simulation");
     m_Controls->m_GenerateImageButton->setVisible(true);
     m_ThreadIsRunning = false;
 
     QString statusText;
     FiberfoxParameters<double> parameters;
     mitk::Image::Pointer mitkImage = mitk::Image::New();
     switch (m_Worker.m_FilterType)
     {
     case 0:
     {
         statusText = QString(m_TractsToDwiFilter->GetStatusText().c_str());
         if (m_TractsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_TractsToDwiFilter->GetParameters();
 
         mitkImage = mitk::GrabItkImageMemory( m_TractsToDwiFilter->GetOutput() );
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New(  parameters.m_SignalGen.GetGradientDirections()  ));
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( parameters.m_SignalGen.m_Bvalue ));
         mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
         propertyHelper.InitializeImage();
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
 
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()
                                                 +"_D"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(0)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(1)).toStdString()
                                                 +"-"+QString::number(parameters.m_SignalGen.m_ImageRegion.GetSize(2)).toStdString()
                                                 +"_S"+QString::number(parameters.m_SignalGen.m_ImageSpacing[0]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[1]).toStdString()
                 +"-"+QString::number(parameters.m_SignalGen.m_ImageSpacing[2]).toStdString()
                 +"_b"+QString::number(parameters.m_SignalGen.m_Bvalue).toStdString()
                 +"_"+parameters.m_Misc.m_SignalModelString
                 +parameters.m_Misc.m_ArtifactModelString);
 
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
 
         parameters.m_Misc.m_ResultNode->SetProperty( "levelwindow", mitk::LevelWindowProperty::New(m_TractsToDwiFilter->GetLevelWindow()) );
 
         if (m_Controls->m_VolumeFractionsBox->isChecked())
         {
             std::vector< itk::TractsToDWIImageFilter< short >::ItkDoubleImgType::Pointer > volumeFractions = m_TractsToDwiFilter->GetVolumeFractions();
             for (unsigned 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(parameters.m_Misc.m_ParentNode->GetName()+"_CompartmentVolume-"+QString::number(k).toStdString());
                 GetDataStorage()->Add(node, parameters.m_Misc.m_ParentNode);
             }
         }
         m_TractsToDwiFilter = NULL;
         break;
     }
     case 1:
     {
         statusText = QString(m_ArtifactsToDwiFilter->GetStatusText().c_str());
         if (m_ArtifactsToDwiFilter->GetAbortGenerateData())
         {
             MITK_INFO << "Simulation aborted.";
             return;
         }
 
         parameters = m_ArtifactsToDwiFilter->GetParameters().CopyParameters<double>();
 
         mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(parameters.m_Misc.m_ParentNode->GetData());
         mitkImage = mitk::GrabItkImageMemory( m_ArtifactsToDwiFilter->GetOutput() );
 
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str(), mitk::GradientDirectionsProperty::New( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() ) );
         mitkImage->SetProperty( mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str(), mitk::FloatProperty::New( static_cast<mitk::FloatProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() ) );
         mitk::DiffusionPropertyHelper propertyHelper( mitkImage );
         propertyHelper.InitializeImage();
 
         parameters.m_Misc.m_ResultNode->SetData( mitkImage );
         parameters.m_Misc.m_ResultNode->SetName(parameters.m_Misc.m_ParentNode->GetName()+parameters.m_Misc.m_ArtifactModelString);
         GetDataStorage()->Add(parameters.m_Misc.m_ResultNode, parameters.m_Misc.m_ParentNode);
         m_ArtifactsToDwiFilter = NULL;
         break;
     }
     }
 
     mitk::BaseData::Pointer basedata = parameters.m_Misc.m_ResultNode->GetData();
     if (basedata.IsNotNull())
     {
         mitk::RenderingManager::GetInstance()->InitializeViews(
                     basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 
     if (!parameters.m_Misc.m_OutputPath.empty())
     {
         try{
             QString outputFileName(parameters.m_Misc.m_OutputPath.c_str());
             outputFileName += parameters.m_Misc.m_ResultNode->GetName().c_str();
             outputFileName.replace(QString("."), QString("_"));
             outputFileName += ".dwi";
             QString status("Saving output image to ");
             status += outputFileName;
             m_Controls->m_SimulationStatusText->append(status);
             mitk::IOUtil::SaveBaseData(mitkImage, outputFileName.toStdString());
             m_Controls->m_SimulationStatusText->append("File saved successfully.");
         }
         catch (itk::ExceptionObject &e)
         {
             QString status("Exception during DWI writing: ");
             status += e.GetDescription();
             m_Controls->m_SimulationStatusText->append(status);
         }
         catch (...)
         {
             m_Controls->m_SimulationStatusText->append("Unknown exception during DWI writing!");
         }
     }
     parameters.m_SignalGen.m_FrequencyMap = NULL;
 }
 
 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);
         QScrollBar *vScrollBar = m_Controls->m_SimulationStatusText->verticalScrollBar();
         vScrollBar->triggerAction(QScrollBar::SliderToMaximum);
     }
 }
 
 // Destructor
 QmitkFiberfoxView::~QmitkFiberfoxView()
 {
     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 );
 
         // commented out
         m_Controls->m_DiffusionDirectionBox->setVisible(false);
         m_Controls->label_3->setVisible(false);
         m_Controls->m_SeparationAngleBox->setVisible(false);
         m_Controls->label_4->setVisible(false);
         //
 
         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_PrototypeWidget1->setVisible(false);
         m_Controls->m_PrototypeWidget2->setVisible(false);
         m_Controls->m_PrototypeWidget3->setVisible(false);
         m_Controls->m_PrototypeWidget4->setVisible(false);
 
         m_Controls->m_PrototypeWidget3->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget4->SetMinFa(0.0);
         m_Controls->m_PrototypeWidget4->SetMaxFa(0.15);
         m_Controls->m_PrototypeWidget3->SetMinAdc(0.0);
         m_Controls->m_PrototypeWidget3->SetMaxAdc(0.001);
         m_Controls->m_PrototypeWidget4->SetMinAdc(0.003);
         m_Controls->m_PrototypeWidget4->SetMaxAdc(0.004);
 
         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());
         m_Controls->m_Comp4VolumeFraction->SetDataStorage(this->GetDataStorage());
         m_Controls->m_MaskComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_TemplateComboBox->SetDataStorage(this->GetDataStorage());
         m_Controls->m_FiberBundleComboBox->SetDataStorage(this->GetDataStorage());
 
         mitk::TNodePredicateDataType<mitk::FiberBundleX>::Pointer isFiberBundle = mitk::TNodePredicateDataType<mitk::FiberBundleX>::New();
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateIsDWI::Pointer isDwi = mitk::NodePredicateIsDWI::New( );
         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 isNonDiffMitkImage = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
         mitk::NodePredicateAnd::Pointer isBinaryMitkImage = mitk::NodePredicateAnd::New( isNonDiffMitkImage, isBinaryPredicate );
 
         m_Controls->m_FrequencyMapBox->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_Comp4VolumeFraction->SetPredicate(isNonDiffMitkImage);
         m_Controls->m_MaskComboBox->SetPredicate(isBinaryMitkImage);
         m_Controls->m_MaskComboBox->SetZeroEntryText("--");
         m_Controls->m_TemplateComboBox->SetPredicate(isMitkImage);
         m_Controls->m_TemplateComboBox->SetZeroEntryText("--");
         m_Controls->m_FiberBundleComboBox->SetPredicate(isFiberBundle);
         m_Controls->m_FiberBundleComboBox->SetZeroEntryText("--");
 
 //        mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
 
         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()));
 
         connect((QObject*) m_Controls->m_MaskComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnMaskSelected(int)));
         connect((QObject*) m_Controls->m_TemplateComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnTemplateSelected(int)));
         connect((QObject*) m_Controls->m_FiberBundleComboBox, SIGNAL(currentIndexChanged(int)), (QObject*) this, SLOT(OnFibSelected(int)));
     }
 }
 
 void QmitkFiberfoxView::OnMaskSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnTemplateSelected(int value)
 {
     UpdateGui();
 }
 
 void QmitkFiberfoxView::OnFibSelected(int value)
 {
     UpdateGui();
 }
 
 template< class ScalarType >
 FiberfoxParameters< ScalarType > QmitkFiberfoxView::UpdateImageParameters()
 {
     FiberfoxParameters< ScalarType > parameters;
     parameters.m_Misc.m_OutputPath = "";
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckAdvancedSignalOptionsBox = m_Controls->m_AdvancedOptionsBox_2->isChecked();
     parameters.m_Misc.m_CheckOutputVolumeFractionsBox = m_Controls->m_VolumeFractionsBox->isChecked();
 
     string outputPath = m_Controls->m_SavePathEdit->text().toStdString();
     if (outputPath.compare("-")!=0)
     {
         parameters.m_Misc.m_OutputPath = outputPath;
         parameters.m_Misc.m_OutputPath += "/";
     }
 
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull())
     {
         mitk::Image::Pointer mitkMaskImage = dynamic_cast<mitk::Image*>(m_Controls->m_MaskComboBox->GetSelectedNode()->GetData());
         mitk::CastToItkImage<ItkUcharImgType>(mitkMaskImage, parameters.m_SignalGen.m_MaskImage);
         itk::ImageDuplicator<ItkUcharImgType>::Pointer duplicator = itk::ImageDuplicator<ItkUcharImgType>::New();
         duplicator->SetInputImage(parameters.m_SignalGen.m_MaskImage);
         duplicator->Update();
         parameters.m_SignalGen.m_MaskImage = duplicator->GetOutput();
     }
 
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))  // use parameters of selected DWI
     {
         mitk::Image::Pointer dwi = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
         ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
         mitk::CastToItkImage(dwi, itkVectorImagePointer);
 
         parameters.m_SignalGen.m_ImageRegion = itkVectorImagePointer->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkVectorImagePointer->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkVectorImagePointer->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkVectorImagePointer->GetDirection();
         parameters.m_SignalGen.m_Bvalue = static_cast<mitk::FloatProperty*>(dwi->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue();
         parameters.m_SignalGen.SetGradienDirections(static_cast<mitk::GradientDirectionsProperty*>( dwi->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer());
     }
     else if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())   // use geometry of selected image
     {
         mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< float, 3 >::Pointer itkImg = itk::Image< float, 3 >::New();
         CastToItkImage< itk::Image< float, 3 > >(img, itkImg);
 
         parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
         parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
         parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
         parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
     }
     else    // use GUI parameters
     {
         parameters.m_SignalGen.m_ImageRegion.SetSize(0, m_Controls->m_SizeX->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(1, m_Controls->m_SizeY->value());
         parameters.m_SignalGen.m_ImageRegion.SetSize(2, m_Controls->m_SizeZ->value());
         parameters.m_SignalGen.m_ImageSpacing[0] = m_Controls->m_SpacingX->value();
         parameters.m_SignalGen.m_ImageSpacing[1] = m_Controls->m_SpacingY->value();
         parameters.m_SignalGen.m_ImageSpacing[2] = m_Controls->m_SpacingZ->value();
         parameters.m_SignalGen.m_ImageOrigin[0] = parameters.m_SignalGen.m_ImageSpacing[0]/2;
         parameters.m_SignalGen.m_ImageOrigin[1] = parameters.m_SignalGen.m_ImageSpacing[1]/2;
         parameters.m_SignalGen.m_ImageOrigin[2] = parameters.m_SignalGen.m_ImageSpacing[2]/2;
         parameters.m_SignalGen.m_ImageDirection.SetIdentity();
         parameters.m_SignalGen.SetNumWeightedVolumes(m_Controls->m_NumGradientsBox->value());
         parameters.m_SignalGen.m_Bvalue = m_Controls->m_BvalueBox->value();
         parameters.m_SignalGen.GenerateGradientHalfShell();
     }
 
     // signal relaxation
     parameters.m_SignalGen.m_DoSimulateRelaxation = m_Controls->m_RelaxationBox->isChecked();
     parameters.m_SignalGen.m_SimulateKspaceAcquisition = parameters.m_SignalGen.m_DoSimulateRelaxation;
     if (parameters.m_SignalGen.m_DoSimulateRelaxation && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
         parameters.m_Misc.m_ArtifactModelString += "_RELAX";
 
     // N/2 ghosts
     parameters.m_Misc.m_CheckAddGhostsBox = m_Controls->m_AddGhosts->isChecked();
     if (m_Controls->m_AddGhosts->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_GHOST";
         parameters.m_SignalGen.m_KspaceLineOffset = m_Controls->m_kOffsetBox->value();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ghost", DoubleProperty::New(parameters.m_SignalGen.m_KspaceLineOffset));
     }
     else
         parameters.m_SignalGen.m_KspaceLineOffset = 0;
 
     // Aliasing
     parameters.m_Misc.m_CheckAddAliasingBox = m_Controls->m_AddAliasing->isChecked();
     if (m_Controls->m_AddAliasing->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ArtifactModelString += "_ALIASING";
         parameters.m_SignalGen.m_CroppingFactor = (100-m_Controls->m_WrapBox->value())/100;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Aliasing", DoubleProperty::New(m_Controls->m_WrapBox->value()));
     }
 
     // Spikes
     parameters.m_Misc.m_CheckAddSpikesBox = m_Controls->m_AddSpikes->isChecked();
     if (m_Controls->m_AddSpikes->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_SignalGen.m_Spikes = m_Controls->m_SpikeNumBox->value();
         parameters.m_SignalGen.m_SpikeAmplitude = m_Controls->m_SpikeScaleBox->value();
         parameters.m_Misc.m_ArtifactModelString += "_SPIKES";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Number", IntProperty::New(parameters.m_SignalGen.m_Spikes));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Spikes.Amplitude", DoubleProperty::New(parameters.m_SignalGen.m_SpikeAmplitude));
     }
 
     // gibbs ringing
     parameters.m_SignalGen.m_DoAddGibbsRinging = m_Controls->m_AddGibbsRinging->isChecked();
     if (m_Controls->m_AddGibbsRinging->isChecked())
     {
         parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Ringing", BoolProperty::New(true));
         parameters.m_Misc.m_ArtifactModelString += "_RINGING";
     }
 
     // add distortions
     parameters.m_Misc.m_CheckAddDistortionsBox = m_Controls->m_AddDistortions->isChecked();
     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_Controls->m_TemplateComboBox->GetSelectedNode().IsNull())   // use geometry of frequency map
         {
             parameters.m_SignalGen.m_ImageRegion = itkImg->GetLargestPossibleRegion();
             parameters.m_SignalGen.m_ImageSpacing = itkImg->GetSpacing();
             parameters.m_SignalGen.m_ImageOrigin = itkImg->GetOrigin();
             parameters.m_SignalGen.m_ImageDirection = itkImg->GetDirection();
         }
 
         if (parameters.m_SignalGen.m_ImageRegion.GetSize(0)==itkImg->GetLargestPossibleRegion().GetSize(0) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(1)==itkImg->GetLargestPossibleRegion().GetSize(1) &&
                 parameters.m_SignalGen.m_ImageRegion.GetSize(2)==itkImg->GetLargestPossibleRegion().GetSize(2))
         {
             parameters.m_SignalGen.m_SimulateKspaceAcquisition = true;
             itk::ImageDuplicator<ItkDoubleImgType>::Pointer duplicator = itk::ImageDuplicator<ItkDoubleImgType>::New();
             duplicator->SetInputImage(itkImg);
             duplicator->Update();
             parameters.m_SignalGen.m_FrequencyMap = duplicator->GetOutput();
             parameters.m_Misc.m_ArtifactModelString += "_DISTORTED";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Distortions", BoolProperty::New(true));
         }
     }
 
     parameters.m_SignalGen.m_EddyStrength = 0;
     parameters.m_Misc.m_CheckAddEddyCurrentsBox = m_Controls->m_AddEddy->isChecked();
     if (m_Controls->m_AddEddy->isChecked())
     {
         parameters.m_SignalGen.m_EddyStrength = m_Controls->m_EddyGradientStrength->value();
         parameters.m_Misc.m_ArtifactModelString += "_EDDY";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Eddy-strength", DoubleProperty::New(parameters.m_SignalGen.m_EddyStrength));
     }
 
     // Motion
     parameters.m_SignalGen.m_DoAddMotion = m_Controls->m_AddMotion->isChecked();
     parameters.m_SignalGen.m_DoRandomizeMotion = m_Controls->m_RandomMotion->isChecked();
     parameters.m_SignalGen.m_Translation[0] = m_Controls->m_MaxTranslationBoxX->value();
     parameters.m_SignalGen.m_Translation[1] = m_Controls->m_MaxTranslationBoxY->value();
     parameters.m_SignalGen.m_Translation[2] = m_Controls->m_MaxTranslationBoxZ->value();
     parameters.m_SignalGen.m_Rotation[0] = m_Controls->m_MaxRotationBoxX->value();
     parameters.m_SignalGen.m_Rotation[1] = m_Controls->m_MaxRotationBoxY->value();
     parameters.m_SignalGen.m_Rotation[2] = m_Controls->m_MaxRotationBoxZ->value();
     if ( m_Controls->m_AddMotion->isChecked() && m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull() )
     {
         parameters.m_Misc.m_ArtifactModelString += "_MOTION";
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Random", BoolProperty::New(parameters.m_SignalGen.m_DoRandomizeMotion));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-x", DoubleProperty::New(parameters.m_SignalGen.m_Translation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-y", DoubleProperty::New(parameters.m_SignalGen.m_Translation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Translation-z", DoubleProperty::New(parameters.m_SignalGen.m_Translation[2]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-x", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[0]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-y", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[1]));
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Motion.Rotation-z", DoubleProperty::New(parameters.m_SignalGen.m_Rotation[2]));
     }
 
     // other imaging parameters
     parameters.m_SignalGen.m_tLine = m_Controls->m_LineReadoutTimeBox->value();
     parameters.m_SignalGen.m_tInhom = m_Controls->m_T2starBox->value();
     parameters.m_SignalGen.m_tEcho = m_Controls->m_TEbox->value();
     parameters.m_SignalGen.m_DoDisablePartialVolume = m_Controls->m_EnforcePureFiberVoxelsBox->isChecked();
     parameters.m_SignalGen.m_AxonRadius = m_Controls->m_FiberRadius->value();
     parameters.m_SignalGen.m_SignalScale = m_Controls->m_SignalScaleBox->value();
 
     // adjust echo time if needed
     if ( parameters.m_SignalGen.m_tEcho < parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine )
     {
         this->m_Controls->m_TEbox->setValue( parameters.m_SignalGen.m_ImageRegion.GetSize(1)*parameters.m_SignalGen.m_tLine );
         parameters.m_SignalGen.m_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(parameters.m_SignalGen.m_tEcho)+" ms");
     }
 
     // Noise
     parameters.m_Misc.m_CheckAddNoiseBox = m_Controls->m_AddNoise->isChecked();
     if (m_Controls->m_AddNoise->isChecked())
     {
         double noiseVariance = m_Controls->m_NoiseLevel->value();
         {
             switch (m_Controls->m_NoiseDistributionBox->currentIndex())
             {
             case 0:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
                 break;
             }
             case 1:
             {
                 parameters.m_NoiseModel = new mitk::ChiSquareNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_CHISQUARED-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Chi-squared"));
                 break;
             }
             default:
             {
                 parameters.m_NoiseModel = new mitk::RicianNoiseModel<ScalarType>();
                 parameters.m_Misc.m_ArtifactModelString += "_RICIAN-";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Distribution", StringProperty::New("Rician"));
             }
             }
         }
         parameters.m_NoiseModel->SetNoiseVariance(noiseVariance);
         parameters.m_Misc.m_ArtifactModelString += QString::number(noiseVariance).toStdString();
         parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Noise-Variance", DoubleProperty::New(noiseVariance));
     }
 
     // adjusting line readout time to the adapted image size needed for the DFT
     unsigned int y = parameters.m_SignalGen.m_ImageRegion.GetSize(1);
     y += y%2;
     if ( y>parameters.m_SignalGen.m_ImageRegion.GetSize(1) )
         parameters.m_SignalGen.m_tLine *= (double)parameters.m_SignalGen.m_ImageRegion.GetSize(1)/y;
 
     // signal models
     {
         // compartment 1
         switch (m_Controls->m_Compartment1Box->currentIndex())
         {
         case 0:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget1->GetD());
             model->SetT2(m_Controls->m_StickWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D", DoubleProperty::New(m_Controls->m_StickWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget1->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget1->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget1->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget1->GetD3());
             model->SetT2(m_Controls->m_TensorWidget1->GetT2());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D1", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D2", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.D3", DoubleProperty::New(m_Controls->m_TensorWidget1->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget1->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget1->GetMinFa(), m_Controls->m_PrototypeWidget1->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget1->GetMinAdc(), m_Controls->m_PrototypeWidget1->GetMaxAdc());
             model->m_CompartmentId = 1;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Description", StringProperty::New("Intra-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment1.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 2
         switch (m_Controls->m_Compartment2Box->currentIndex())
         {
         case 0:
             break;
         case 1:
         {
             mitk::StickModel<ScalarType>* model = new mitk::StickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_StickWidget2->GetD());
             model->SetT2(m_Controls->m_StickWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Stick";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Stick") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D", DoubleProperty::New(m_Controls->m_StickWidget2->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 2:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_ZeppelinWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_ZeppelinWidget2->GetD2());
             model->SetT2(m_Controls->m_ZeppelinWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Zeppelin";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Zeppelin") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_ZeppelinWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::TensorModel<ScalarType>* model = new mitk::TensorModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity1(m_Controls->m_TensorWidget2->GetD1());
             model->SetDiffusivity2(m_Controls->m_TensorWidget2->GetD2());
             model->SetDiffusivity3(m_Controls->m_TensorWidget2->GetD3());
             model->SetT2(m_Controls->m_TensorWidget2->GetT2());
             model->m_CompartmentId = 2;
             parameters.m_FiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Tensor";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Description", StringProperty::New("Inter-axonal compartment") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.Model", StringProperty::New("Tensor") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D1", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD1()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D2", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.D3", DoubleProperty::New(m_Controls->m_TensorWidget2->GetD3()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment2.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         }
 
         // compartment 3
         switch (m_Controls->m_Compartment3Box->currentIndex())
         {
         case 0:
         {
             mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_BallWidget1->GetD());
             model->SetT2(m_Controls->m_BallWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Ball";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Ball") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_BallWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 1:
         {
             mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
             model->SetDiffusivity(m_Controls->m_AstrosticksWidget1->GetD());
             model->SetT2(m_Controls->m_AstrosticksWidget1->GetT2());
             model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Astrosticks";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Astrosticks") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget1->GetD()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget1->GetRandomizeSticks()) );
             break;
         }
         case 2:
         {
             mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetT2(m_Controls->m_DotWidget1->GetT2());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Dot";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Dot") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.T2", DoubleProperty::New(model->GetT2()) );
             break;
         }
         case 3:
         {
             mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
             parameters.m_SignalGen.m_DoSimulateRelaxation = false;
             model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
             model->SetMaxNumKernels(m_Controls->m_PrototypeWidget3->GetNumberOfSamples());
             model->SetFaRange(m_Controls->m_PrototypeWidget3->GetMinFa(), m_Controls->m_PrototypeWidget3->GetMaxFa());
             model->SetAdcRange(m_Controls->m_PrototypeWidget3->GetMinAdc(), m_Controls->m_PrototypeWidget3->GetMaxAdc());
             model->m_CompartmentId = 3;
             parameters.m_NonFiberModelList.push_back(model);
             parameters.m_Misc.m_SignalModelString += "Prototype";
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Description", StringProperty::New("Extra-axonal compartment 1") );
             parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment3.Model", StringProperty::New("Prototype") );
             break;
         }
         }
 
         // compartment 4
         ItkDoubleImgType::Pointer comp4VolumeImage = NULL;
         ItkDoubleImgType::Pointer comp3VolumeImage = NULL;
         if (m_Controls->m_Compartment4Box->currentIndex()>0)
         {
             mitk::DataNode::Pointer volumeNode = m_Controls->m_Comp4VolumeFraction->GetSelectedNode();
             if (volumeNode.IsNull())
             {
                 QMessageBox::information( NULL, "Information", "No volume fraction image selected! Second extra-axonal compartment has been disabled for this simultation.");
                 MITK_WARN << "No volume fraction image selected! Second extra-axonal compartment has been disabled.";
             }
             else
             {
                 MITK_INFO << "Rescaling volume fraction image...";
                 comp4VolumeImage = ItkDoubleImgType::New();
                 mitk::Image* img = dynamic_cast<mitk::Image*>(volumeNode->GetData());
                 CastToItkImage< ItkDoubleImgType >(img, comp4VolumeImage);
 
                 double max = itk::NumericTraits<double>::min();
                 double min = itk::NumericTraits<double>::max();
 
                 itk::ImageRegionIterator< ItkDoubleImgType > it(comp4VolumeImage, comp4VolumeImage->GetLargestPossibleRegion());
                 while(!it.IsAtEnd())
                 {
                     if (parameters.m_SignalGen.m_MaskImage.IsNotNull() && parameters.m_SignalGen.m_MaskImage->GetPixel(it.GetIndex())<=0)
                     {
                         it.Set(0.0);
                         ++it;
                         continue;
                     }
                     if (it.Get()>900)
                         it.Set(900);
 
                     if (it.Get()>max)
                         max = it.Get();
                     if (it.Get()<min)
                         min = it.Get();
                     ++it;
                 }
                 itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer scaler = itk::ShiftScaleImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 scaler->SetInput(comp4VolumeImage);
                 scaler->SetShift(-min);
                 scaler->SetScale(1.0/(max-min));
                 scaler->Update();
                 comp4VolumeImage = scaler->GetOutput();
 
 //                itk::ImageFileWriter< ItkDoubleImgType >::Pointer wr = itk::ImageFileWriter< ItkDoubleImgType >::New();
 //                wr->SetInput(comp4VolumeImage);
 //                wr->SetFileName("/local/comp4.nrrd");
 //                wr->Update();
 
                 //            if (max>1 || min<0) // are volume fractions between 0 and 1?
                 //            {
                 //                itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::Pointer rescaler = itk::RescaleIntensityImageFilter<ItkDoubleImgType,ItkDoubleImgType>::New();
                 //                rescaler->SetInput(0, comp4VolumeImage);
                 //                rescaler->SetOutputMaximum(1);
                 //                rescaler->SetOutputMinimum(0);
                 //                rescaler->Update();
                 //                comp4VolumeImage = rescaler->GetOutput();
                 //            }
 
                 itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::Pointer inverter = itk::InvertIntensityImageFilter< ItkDoubleImgType, ItkDoubleImgType >::New();
                 inverter->SetMaximum(1.0);
                 inverter->SetInput(comp4VolumeImage);
                 inverter->Update();
                 comp3VolumeImage = inverter->GetOutput();
             }
         }
 
         if (comp4VolumeImage.IsNotNull())
         {
             switch (m_Controls->m_Compartment4Box->currentIndex())
             {
             case 0:
                 break;
             case 1:
             {
                 mitk::BallModel<ScalarType>* model = new mitk::BallModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_BallWidget2->GetD());
                 model->SetT2(m_Controls->m_BallWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Ball";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Ball") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_BallWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 2:
             {
                 mitk::AstroStickModel<ScalarType>* model = new mitk::AstroStickModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetBvalue(parameters.m_SignalGen.m_Bvalue);
                 model->SetDiffusivity(m_Controls->m_AstrosticksWidget2->GetD());
                 model->SetT2(m_Controls->m_AstrosticksWidget2->GetT2());
                 model->SetRandomizeSticks(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks());
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Astrosticks";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Astrosticks") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.D", DoubleProperty::New(m_Controls->m_AstrosticksWidget2->GetD()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.RandomSticks", BoolProperty::New(m_Controls->m_AstrosticksWidget2->GetRandomizeSticks()) );
                 break;
             }
             case 3:
             {
                 mitk::DotModel<ScalarType>* model = new mitk::DotModel<ScalarType>();
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetT2(m_Controls->m_DotWidget2->GetT2());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Dot";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Dot") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.T2", DoubleProperty::New(model->GetT2()) );
                 break;
             }
             case 4:
             {
                 mitk::RawShModel<ScalarType>* model = new mitk::RawShModel<ScalarType>();
                 parameters.m_SignalGen.m_DoSimulateRelaxation = false;
                 model->SetGradientList(parameters.m_SignalGen.GetGradientDirections());
                 model->SetMaxNumKernels(m_Controls->m_PrototypeWidget4->GetNumberOfSamples());
                 model->SetFaRange(m_Controls->m_PrototypeWidget4->GetMinFa(), m_Controls->m_PrototypeWidget4->GetMaxFa());
                 model->SetAdcRange(m_Controls->m_PrototypeWidget4->GetMinAdc(), m_Controls->m_PrototypeWidget4->GetMaxAdc());
                 model->SetVolumeFractionImage(comp4VolumeImage);
                 model->m_CompartmentId = 4;
                 parameters.m_NonFiberModelList.back()->SetVolumeFractionImage(comp3VolumeImage);
                 parameters.m_NonFiberModelList.push_back(model);
                 parameters.m_Misc.m_SignalModelString += "Prototype";
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Description", StringProperty::New("Extra-axonal compartment 2") );
                 parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Compartment4.Model", StringProperty::New("Prototype") );
                 break;
             }
             }
         }
     }
 
     parameters.m_SignalGen.m_FiberSeparationThreshold = m_Controls->m_SeparationAngleBox->value();
     switch (m_Controls->m_DiffusionDirectionBox->currentIndex())
     {
     case 0:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
         break;
     case 1:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::MAIN_FIBER_DIRECTIONS;
         break;
     case 2:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::RANDOM_DIRECTIONS;
         parameters.m_SignalGen.m_DoAddMotion = false;
         parameters.m_SignalGen.m_DoAddGibbsRinging = false;
         parameters.m_SignalGen.m_KspaceLineOffset = 0.0;
         parameters.m_SignalGen.m_FrequencyMap = NULL;
         parameters.m_SignalGen.m_CroppingFactor = 1.0;
         parameters.m_SignalGen.m_EddyStrength = 0;
         break;
     default:
         parameters.m_SignalGen.m_DiffusionDirectionMode = SignalGenerationParameters::FIBER_TANGENT_DIRECTIONS;
     }
 
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.SignalScale", IntProperty::New(parameters.m_SignalGen.m_SignalScale));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.FiberRadius", IntProperty::New(parameters.m_SignalGen.m_AxonRadius));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tinhom", DoubleProperty::New(parameters.m_SignalGen.m_tInhom));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Tline", DoubleProperty::New(parameters.m_SignalGen.m_tLine));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.TE", DoubleProperty::New(parameters.m_SignalGen.m_tEcho));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.b-value", DoubleProperty::New(parameters.m_SignalGen.m_Bvalue));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.NoPartialVolume", BoolProperty::New(parameters.m_SignalGen.m_DoDisablePartialVolume));
     parameters.m_Misc.m_ResultNode->AddProperty("Fiberfox.Relaxation", BoolProperty::New(parameters.m_SignalGen.m_DoSimulateRelaxation));
     parameters.m_Misc.m_ResultNode->AddProperty("binary", BoolProperty::New(false));
 
     parameters.m_Misc.m_CheckRealTimeFibersBox = m_Controls->m_RealTimeFibers->isChecked();
     parameters.m_Misc.m_CheckAdvancedFiberOptionsBox = m_Controls->m_AdvancedOptionsBox->isChecked();
     parameters.m_Misc.m_CheckIncludeFiducialsBox = m_Controls->m_IncludeFiducials->isChecked();
     parameters.m_Misc.m_CheckConstantRadiusBox = m_Controls->m_ConstantRadiusBox->isChecked();
 
     switch(m_Controls->m_DistributionBox->currentIndex())
     {
     case 0:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
         break;
     case 1:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_GAUSSIAN;
         break;
     default:
         parameters.m_FiberGen.m_Distribution = FiberGenerationParameters::DISTRIBUTE_UNIFORM;
     }
     parameters.m_FiberGen.m_Variance = m_Controls->m_VarianceBox->value();
     parameters.m_FiberGen.m_Density = m_Controls->m_FiberDensityBox->value();
     parameters.m_FiberGen.m_Sampling = m_Controls->m_FiberSamplingBox->value();
     parameters.m_FiberGen.m_Tension = m_Controls->m_TensionBox->value();
     parameters.m_FiberGen.m_Continuity = m_Controls->m_ContinuityBox->value();
     parameters.m_FiberGen.m_Bias = m_Controls->m_BiasBox->value();
     parameters.m_FiberGen.m_Rotation[0] = m_Controls->m_XrotBox->value();
     parameters.m_FiberGen.m_Rotation[1] = m_Controls->m_YrotBox->value();
     parameters.m_FiberGen.m_Rotation[2] = m_Controls->m_ZrotBox->value();
     parameters.m_FiberGen.m_Translation[0] = m_Controls->m_XtransBox->value();
     parameters.m_FiberGen.m_Translation[1] = m_Controls->m_YtransBox->value();
     parameters.m_FiberGen.m_Translation[2] = m_Controls->m_ZtransBox->value();
     parameters.m_FiberGen.m_Scale[0] = m_Controls->m_XscaleBox->value();
     parameters.m_FiberGen.m_Scale[1] = m_Controls->m_YscaleBox->value();
     parameters.m_FiberGen.m_Scale[2] = m_Controls->m_ZscaleBox->value();
 
     return parameters;
 }
 
 void QmitkFiberfoxView::SaveParameters()
 {
     FiberfoxParameters<> ffParamaters = UpdateImageParameters<double>();
 
     QString filename = QFileDialog::getSaveFileName(
                 0,
                 tr("Save Parameters"),
                 m_ParameterFile,
                 tr("Fiberfox Parameters (*.ffp)") );
 
     bool ok = true;
     bool first = true;
     bool dosampling = false;
     mitk::Image::Pointer diffImg = NULL;
     itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
     const int shOrder = 2;
     typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
     QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
     ItkDoubleImgType::Pointer adcImage = NULL;
 
     for (unsigned int i=0; i<ffParamaters.m_FiberModelList.size()+ffParamaters.m_NonFiberModelList.size(); i++)
     {
         mitk::RawShModel<>* model = NULL;
         if (i<ffParamaters.m_FiberModelList.size())
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_FiberModelList.at(i));
         else
             model = dynamic_cast<  mitk::RawShModel<>* >(ffParamaters.m_NonFiberModelList.at(i-ffParamaters.m_FiberModelList.size()));
 
         if (model!=0 && model->GetNumberOfKernels()<=0)
         {
             if (first==true)
             {
                 if (QMessageBox::question(NULL, "Prototype signal sampling", "Do you want to sample prototype signals from the selected diffusion-weighted imag and save them?",QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
                     dosampling = true;
 
                 first = false;
                 if (dosampling && (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNull() || !mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData()))))
                 {
                     QMessageBox::information(NULL, "Parameter file not saved", "No diffusion-weighted image selected to sample signal from.");
                     return;
                 }
                 else if (dosampling)
                 {
                   diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
 
                   typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
                   TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
                   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
                   mitk::CastToItkImage(diffImg, itkVectorImagePointer);
                   filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                   filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
 
                   filter->Update();
                   tensorImage = filter->GetOutput();
 
                   const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
                   QballFilterType::Pointer qballfilter = QballFilterType::New();
                   qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                   qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                   qballfilter->SetLambda(0.006);
                   qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
                   qballfilter->Update();
                   itkFeatureImage = qballfilter->GetCoefficientImage();
 
                   itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
                   adcFilter->SetInput( itkVectorImagePointer );
                   adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
                   adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                   adcFilter->Update();
                   adcImage = adcFilter->GetOutput();
                 }
             }
 
             if (dosampling && diffImg.IsNotNull())
             {
                 ok = model->SampleKernels(diffImg, ffParamaters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                 {
                     QMessageBox::information( NULL, "Parameter file not saved", "No valid prototype signals could be sampled.");
                     return;
                 }
             }
         }
     }
 
     ffParamaters.SaveParameters(filename.toStdString());
     m_ParameterFile = filename;
 }
 
 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;
 
     FiberfoxParameters<> parameters;
     parameters.LoadParameters(filename.toStdString());
 
     m_Controls->m_RealTimeFibers->setChecked(parameters.m_Misc.m_CheckRealTimeFibersBox);
     m_Controls->m_AdvancedOptionsBox->setChecked(parameters.m_Misc.m_CheckAdvancedFiberOptionsBox);
     m_Controls->m_IncludeFiducials->setChecked(parameters.m_Misc.m_CheckIncludeFiducialsBox);
     m_Controls->m_ConstantRadiusBox->setChecked(parameters.m_Misc.m_CheckConstantRadiusBox);
 
     m_Controls->m_DistributionBox->setCurrentIndex(parameters.m_FiberGen.m_Distribution);
     m_Controls->m_VarianceBox->setValue(parameters.m_FiberGen.m_Variance);
     m_Controls->m_FiberDensityBox->setValue(parameters.m_FiberGen.m_Density);
     m_Controls->m_FiberSamplingBox->setValue(parameters.m_FiberGen.m_Sampling);
     m_Controls->m_TensionBox->setValue(parameters.m_FiberGen.m_Tension);
     m_Controls->m_ContinuityBox->setValue(parameters.m_FiberGen.m_Continuity);
     m_Controls->m_BiasBox->setValue(parameters.m_FiberGen.m_Bias);
     m_Controls->m_XrotBox->setValue(parameters.m_FiberGen.m_Rotation[0]);
     m_Controls->m_YrotBox->setValue(parameters.m_FiberGen.m_Rotation[1]);
     m_Controls->m_ZrotBox->setValue(parameters.m_FiberGen.m_Rotation[2]);
     m_Controls->m_XtransBox->setValue(parameters.m_FiberGen.m_Translation[0]);
     m_Controls->m_YtransBox->setValue(parameters.m_FiberGen.m_Translation[1]);
     m_Controls->m_ZtransBox->setValue(parameters.m_FiberGen.m_Translation[2]);
     m_Controls->m_XscaleBox->setValue(parameters.m_FiberGen.m_Scale[0]);
     m_Controls->m_YscaleBox->setValue(parameters.m_FiberGen.m_Scale[1]);
     m_Controls->m_ZscaleBox->setValue(parameters.m_FiberGen.m_Scale[2]);
 
     // image generation parameters
     m_Controls->m_SizeX->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(0));
     m_Controls->m_SizeY->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(1));
     m_Controls->m_SizeZ->setValue(parameters.m_SignalGen.m_ImageRegion.GetSize(2));
     m_Controls->m_SpacingX->setValue(parameters.m_SignalGen.m_ImageSpacing[0]);
     m_Controls->m_SpacingY->setValue(parameters.m_SignalGen.m_ImageSpacing[1]);
     m_Controls->m_SpacingZ->setValue(parameters.m_SignalGen.m_ImageSpacing[2]);
     m_Controls->m_NumGradientsBox->setValue(parameters.m_SignalGen.GetNumWeightedVolumes());
     m_Controls->m_BvalueBox->setValue(parameters.m_SignalGen.m_Bvalue);
     m_Controls->m_SignalScaleBox->setValue(parameters.m_SignalGen.m_SignalScale);
     m_Controls->m_TEbox->setValue(parameters.m_SignalGen.m_tEcho);
     m_Controls->m_LineReadoutTimeBox->setValue(parameters.m_SignalGen.m_tLine);
     m_Controls->m_T2starBox->setValue(parameters.m_SignalGen.m_tInhom);
     m_Controls->m_FiberRadius->setValue(parameters.m_SignalGen.m_AxonRadius);
     m_Controls->m_RelaxationBox->setChecked(parameters.m_SignalGen.m_DoSimulateRelaxation);
     m_Controls->m_EnforcePureFiberVoxelsBox->setChecked(parameters.m_SignalGen.m_DoDisablePartialVolume);
 
     if (parameters.m_NoiseModel!=NULL)
     {
         m_Controls->m_AddNoise->setChecked(parameters.m_Misc.m_CheckAddNoiseBox);
         if (dynamic_cast<mitk::RicianNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(0);
         else if (dynamic_cast<mitk::ChiSquareNoiseModel<double>*>(parameters.m_NoiseModel))
             m_Controls->m_NoiseDistributionBox->setCurrentIndex(1);
         m_Controls->m_NoiseLevel->setValue(parameters.m_NoiseModel->GetNoiseVariance());
     }
     else
         m_Controls->m_AddNoise->setChecked(false);
 
     m_Controls->m_VolumeFractionsBox->setChecked(parameters.m_Misc.m_CheckOutputVolumeFractionsBox);
     m_Controls->m_AdvancedOptionsBox_2->setChecked(parameters.m_Misc.m_CheckAdvancedSignalOptionsBox);
     m_Controls->m_AddGhosts->setChecked(parameters.m_Misc.m_CheckAddGhostsBox);
     m_Controls->m_AddAliasing->setChecked(parameters.m_Misc.m_CheckAddAliasingBox);
     m_Controls->m_AddDistortions->setChecked(parameters.m_Misc.m_CheckAddDistortionsBox);
     m_Controls->m_AddSpikes->setChecked(parameters.m_Misc.m_CheckAddSpikesBox);
     m_Controls->m_AddEddy->setChecked(parameters.m_Misc.m_CheckAddEddyCurrentsBox);
 
     m_Controls->m_kOffsetBox->setValue(parameters.m_SignalGen.m_KspaceLineOffset);
     m_Controls->m_WrapBox->setValue(100*(1-parameters.m_SignalGen.m_CroppingFactor));
     m_Controls->m_SpikeNumBox->setValue(parameters.m_SignalGen.m_Spikes);
     m_Controls->m_SpikeScaleBox->setValue(parameters.m_SignalGen.m_SpikeAmplitude);
     m_Controls->m_EddyGradientStrength->setValue(parameters.m_SignalGen.m_EddyStrength);
     m_Controls->m_AddGibbsRinging->setChecked(parameters.m_SignalGen.m_DoAddGibbsRinging);
     m_Controls->m_AddMotion->setChecked(parameters.m_SignalGen.m_DoAddMotion);
     m_Controls->m_RandomMotion->setChecked(parameters.m_SignalGen.m_DoRandomizeMotion);
     m_Controls->m_MaxTranslationBoxX->setValue(parameters.m_SignalGen.m_Translation[0]);
     m_Controls->m_MaxTranslationBoxY->setValue(parameters.m_SignalGen.m_Translation[1]);
     m_Controls->m_MaxTranslationBoxZ->setValue(parameters.m_SignalGen.m_Translation[2]);
     m_Controls->m_MaxRotationBoxX->setValue(parameters.m_SignalGen.m_Rotation[0]);
     m_Controls->m_MaxRotationBoxY->setValue(parameters.m_SignalGen.m_Rotation[1]);
     m_Controls->m_MaxRotationBoxZ->setValue(parameters.m_SignalGen.m_Rotation[2]);
     m_Controls->m_DiffusionDirectionBox->setCurrentIndex(parameters.m_SignalGen.m_DiffusionDirectionMode);
     m_Controls->m_SeparationAngleBox->setValue(parameters.m_SignalGen.m_FiberSeparationThreshold);
 
     m_Controls->m_Compartment1Box->setCurrentIndex(0);
     m_Controls->m_Compartment2Box->setCurrentIndex(0);
     m_Controls->m_Compartment3Box->setCurrentIndex(0);
     m_Controls->m_Compartment4Box->setCurrentIndex(0);
 
     for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
     {
         mitk::DiffusionSignalModel<ScalarType>* signalModel = NULL;
         if (i<parameters.m_FiberModelList.size())
             signalModel = parameters.m_FiberModelList.at(i);
         else
             signalModel = parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size());
 
         switch (signalModel->m_CompartmentId)
         {
         case 1:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget1->SetT2(model->GetT2());
                 m_Controls->m_StickWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment1Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget1->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget1->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget1->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget1->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment1Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget1->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget1->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget1->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget1->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment1Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 2:
         {
             if (dynamic_cast<mitk::StickModel<>*>(signalModel))
             {
                 mitk::StickModel<>* model = dynamic_cast<mitk::StickModel<>*>(signalModel);
                 m_Controls->m_StickWidget2->SetT2(model->GetT2());
                 m_Controls->m_StickWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment2Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::TensorModel<>*>(signalModel))
             {
                 mitk::TensorModel<>* model = dynamic_cast<mitk::TensorModel<>*>(signalModel);
                 m_Controls->m_TensorWidget2->SetT2(model->GetT2());
                 m_Controls->m_TensorWidget2->SetD1(model->GetDiffusivity1());
                 m_Controls->m_TensorWidget2->SetD2(model->GetDiffusivity2());
                 m_Controls->m_TensorWidget2->SetD3(model->GetDiffusivity3());
                 m_Controls->m_Compartment2Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 3:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget1->SetT2(model->GetT2());
                 m_Controls->m_BallWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment3Box->setCurrentIndex(0);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget1->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget1->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget1->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment3Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget1->SetT2(model->GetT2());
                 m_Controls->m_Compartment3Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget3->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget3->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget3->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget3->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment3Box->setCurrentIndex(3);
                 break;
             }
             break;
         }
         case 4:
         {
             if (dynamic_cast<mitk::BallModel<>*>(signalModel))
             {
                 mitk::BallModel<>* model = dynamic_cast<mitk::BallModel<>*>(signalModel);
                 m_Controls->m_BallWidget2->SetT2(model->GetT2());
                 m_Controls->m_BallWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_Compartment4Box->setCurrentIndex(1);
                 break;
             }
             else if (dynamic_cast<mitk::AstroStickModel<>*>(signalModel))
             {
                 mitk::AstroStickModel<>* model = dynamic_cast<mitk::AstroStickModel<>*>(signalModel);
                 m_Controls->m_AstrosticksWidget2->SetT2(model->GetT2());
                 m_Controls->m_AstrosticksWidget2->SetD(model->GetDiffusivity());
                 m_Controls->m_AstrosticksWidget2->SetRandomizeSticks(model->GetRandomizeSticks());
                 m_Controls->m_Compartment4Box->setCurrentIndex(2);
                 break;
             }
             else if (dynamic_cast<mitk::DotModel<>*>(signalModel))
             {
                 mitk::DotModel<>* model = dynamic_cast<mitk::DotModel<>*>(signalModel);
                 m_Controls->m_DotWidget2->SetT2(model->GetT2());
                 m_Controls->m_Compartment4Box->setCurrentIndex(3);
                 break;
             }
             else if (dynamic_cast<mitk::RawShModel<>*>(signalModel))
             {
                 mitk::RawShModel<>* model = dynamic_cast<mitk::RawShModel<>*>(signalModel);
                 m_Controls->m_PrototypeWidget4->SetNumberOfSamples(model->GetMaxNumKernels());
                 m_Controls->m_PrototypeWidget4->SetMinFa(model->GetFaRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxFa(model->GetFaRange().second);
                 m_Controls->m_PrototypeWidget4->SetMinAdc(model->GetAdcRange().first);
                 m_Controls->m_PrototypeWidget4->SetMaxAdc(model->GetAdcRange().second);
                 m_Controls->m_Compartment4Box->setCurrentIndex(4);
                 break;
             }
             break;
         }
         }
     }
 }
 
 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);
     m_Controls->m_PrototypeWidget1->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;
     case 3:
         m_Controls->m_PrototypeWidget1->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);
     m_Controls->m_PrototypeWidget3->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;
     case 3:
         m_Controls->m_PrototypeWidget3->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_PrototypeWidget4->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;
     case 4:
         m_Controls->m_PrototypeWidget4->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)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberDensityChanged(int)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnFiberSamplingChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnTensionChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnContinuityChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::OnBiasChanged(double)
 {
     if (m_Controls->m_RealTimeFibers->isChecked())
         GenerateFibers();
 }
 
 void QmitkFiberfoxView::AlignOnGrid()
 {
     for (unsigned 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::BaseGeometry::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(unsigned 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::BaseGeometry::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(unsigned 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::BaseGeometry::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())
+    if (m_SelectedImageNode.IsNull())
         return;
 
-    mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImage);
+    mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_SelectedImageNode);
 
     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);
+    GetDataStorage()->Add(node, m_SelectedImageNode);
 }
 
 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 );
     node->SetBoolProperty("planarfigure.3drendering", true);
 
     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( "MitkPlanarFigure" );
         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;
     }
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     for (unsigned 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);
                         ellipse->Modified();
                     }
                     else
                     {
                         v.Normalize();
                         v *= radius;
                         ellipse->SetControlPoint(1, c+v);
                         ellipse->Modified();
                     }
                 }
                 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)
         {
             parameters.m_FiberGen.m_Fiducials.push_back(fib);
             parameters.m_FiberGen.m_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->SetParameters(parameters.m_FiberGen);
     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_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNull() && m_Controls->m_TemplateComboBox->GetSelectedNode().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::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;
+        m_SelectedImageNode = node;
 
         mitk::BaseData::Pointer basedata = node->GetData();
         if (basedata.IsNotNull())
         {
             mitk::RenderingManager::GetInstance()->InitializeViews( basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
             mitk::RenderingManager::GetInstance()->RequestUpdateAll();
         }
         UpdateGui();
     }
     else if (m_Controls->m_FiberBundleComboBox->GetSelectedNode().IsNotNull())
         SimulateImageFromFibers(m_Controls->m_FiberBundleComboBox->GetSelectedNode());
     else if ( m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() )
         SimulateForExistingDwi(m_Controls->m_TemplateComboBox->GetSelectedNode());
 }
 
 void QmitkFiberfoxView::SimulateForExistingDwi(mitk::DataNode* imageNode)
 {
   bool isDiffusionImage( mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(imageNode->GetData())) );
   if ( !isDiffusionImage )
   {
     return;
   }
 
     FiberfoxParameters<short> parameters = UpdateImageParameters<short>();
 
     if (parameters.m_NoiseModel==NULL &&
             parameters.m_SignalGen.m_Spikes==0 &&
             parameters.m_SignalGen.m_FrequencyMap.IsNull() &&
             parameters.m_SignalGen.m_KspaceLineOffset<=0.000001 &&
             !parameters.m_SignalGen.m_DoAddGibbsRinging &&
             !(parameters.m_SignalGen.m_EddyStrength>0) &&
             parameters.m_SignalGen.m_CroppingFactor>0.999)
     {
         QMessageBox::information( NULL, "Simulation cancelled", "No valid artifact enabled! Motion artifacts and relaxation effects can NOT be added to an existing diffusion weighted image.");
         return;
     }
 
     mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(imageNode->GetData());
 
     ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
     mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
     m_ArtifactsToDwiFilter = itk::AddArtifactsToDwiImageFilter< short >::New();
     m_ArtifactsToDwiFilter->SetInput(itkVectorImagePointer);
     parameters.m_Misc.m_ParentNode = imageNode;
     m_ArtifactsToDwiFilter->SetParameters(parameters);
     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;
 
     FiberfoxParameters<double> parameters = UpdateImageParameters<double>();
 
     m_TractsToDwiFilter = itk::TractsToDWIImageFilter< short >::New();
     parameters.m_Misc.m_ParentNode = fiberNode;
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         bool first = true;
         bool ok = true;
         mitk::Image::Pointer diffImg = dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData());
         itk::Image< itk::DiffusionTensor3D< double >, 3 >::Pointer tensorImage = NULL;
         const int shOrder = 2;
         typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,shOrder,QBALL_ODFSIZE> QballFilterType;
         QballFilterType::CoefficientImageType::Pointer itkFeatureImage = NULL;
         ItkDoubleImgType::Pointer adcImage = NULL;
 
         for (unsigned int i=0; i<parameters.m_FiberModelList.size()+parameters.m_NonFiberModelList.size(); i++)
         {
             mitk::RawShModel<>* model = NULL;
             if (i<parameters.m_FiberModelList.size())
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_FiberModelList.at(i));
             else
                 model = dynamic_cast<  mitk::RawShModel<>* >(parameters.m_NonFiberModelList.at(i-parameters.m_FiberModelList.size()));
 
             if (model!=0 && model->GetNumberOfKernels()<=0)
             {
                 if (first==true)
                 {
                   ItkDwiType::Pointer itkVectorImagePointer = ItkDwiType::New();
                   mitk::CastToItkImage(diffImg, itkVectorImagePointer);
 
                     typedef itk::DiffusionTensor3DReconstructionImageFilter< short, short, double > TensorReconstructionImageFilterType;
                     TensorReconstructionImageFilterType::Pointer filter = TensorReconstructionImageFilterType::New();
                     filter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                     filter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     filter->Update();
                     tensorImage = filter->GetOutput();
 
                     const int NumCoeffs = (shOrder*shOrder + shOrder + 2)/2 + shOrder;
                     QballFilterType::Pointer qballfilter = QballFilterType::New();
                     qballfilter->SetGradientImage( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer(), itkVectorImagePointer );
                     qballfilter->SetBValue( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     qballfilter->SetLambda(0.006);
                     qballfilter->SetNormalizationMethod(QballFilterType::QBAR_RAW_SIGNAL);
                     qballfilter->Update();
                     itkFeatureImage = qballfilter->GetCoefficientImage();
 
                     itk::AdcImageFilter< short, double >::Pointer adcFilter = itk::AdcImageFilter< short, double >::New();
                     adcFilter->SetInput( itkVectorImagePointer );
                     adcFilter->SetGradientDirections( static_cast<mitk::GradientDirectionsProperty*>( diffImg->GetProperty(mitk::DiffusionPropertyHelper::GRADIENTCONTAINERPROPERTYNAME.c_str()).GetPointer() )->GetGradientDirectionsContainer() );
                     adcFilter->SetB_value( static_cast<mitk::FloatProperty*>(diffImg->GetProperty(mitk::DiffusionPropertyHelper::REFERENCEBVALUEPROPERTYNAME.c_str()).GetPointer() )->GetValue() );
                     adcFilter->Update();
                     adcImage = adcFilter->GetOutput();
                 }
                 ok = model->SampleKernels(diffImg, parameters.m_SignalGen.m_MaskImage, tensorImage, itkFeatureImage, adcImage);
                 if (!ok)
                     break;
             }
         }
 
         if (!ok)
         {
             QMessageBox::information( NULL, "Simulation cancelled", "No valid prototype signals could be sampled.");
             return;
         }
     }
     else if ( m_Controls->m_Compartment1Box->currentIndex()==3 || m_Controls->m_Compartment3Box->currentIndex()==3 || m_Controls->m_Compartment4Box->currentIndex()==4 )
     {
         QMessageBox::information( NULL, "Simulation cancelled", "Prototype signal but no diffusion-weighted image selected to sample signal from.");
         return;
     }
 
+    if (m_SelectedImageNode.IsNotNull())
+    {
+        ItkFloatImgType::Pointer itkImg = ItkFloatImgType::New();
+        mitk::Image::Pointer mitkImg = dynamic_cast<mitk::Image*>(m_SelectedImageNode->GetData());
+        mitk::CastToItkImage<ItkFloatImgType>(mitkImg, itkImg);
+        m_TractsToDwiFilter->SetHelperTdi(itkImg);
+    }
     m_TractsToDwiFilter->SetParameters(parameters);
     m_TractsToDwiFilter->SetFiberBundle(fiberBundle);
     m_Worker.m_FilterType = 0;
     m_Thread.start(QThread::LowestPriority);
 }
 
 void QmitkFiberfoxView::ApplyTransform()
 {
     vector< mitk::DataNode::Pointer > selectedBundles;
     for(unsigned 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())
     {
         for (std::vector<mitk::DataNode::Pointer>::const_iterator it = selectedBundles.begin(); 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::BaseGeometry* 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);
 
                         pe->Modified();
                     }
                 }
             }
         }
     }
     else
     {
         for (unsigned int i=0; i<m_SelectedFiducials.size(); i++)
         {
             mitk::PlanarEllipse* pe = dynamic_cast<mitk::PlanarEllipse*>(m_SelectedFiducials.at(i)->GetData());
             mitk::BaseGeometry* 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());
             pe->Modified();
         }
         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("QmitkFiberFoxView") << "Select at least one fiber bundle!";
         return;
     }
 
     for (std::vector<mitk::DataNode::Pointer>::const_iterator it = m_SelectedBundles.begin(); 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 = dynamic_cast<mitk::PlanarEllipse*>(fiducialNode->GetData())->Clone();
                     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
                     newNode->SetData(pe);
                     newNode->SetName(fiducialNode->GetName());
                     newNode->SetBoolProperty("planarfigure.3drendering", true);
                     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("QmitkFiberFoxView") << "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!=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_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);
 
     // Fiber generation gui
     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())
+    if (m_SelectedImageNode.IsNotNull() || !m_SelectedBundles.empty())
     {
         m_Controls->m_CircleButton->setEnabled(true);
         m_Controls->m_FiberGenMessage->setVisible(false);
     }
-    if (m_SelectedImage.IsNotNull() && !m_SelectedBundles.empty())
+    if (m_SelectedImageNode.IsNotNull() && !m_SelectedBundles.empty())
         m_Controls->m_AlignOnGrid->setEnabled(true);
 
     if (!m_SelectedBundles.empty())
     {
         m_Controls->m_TransformBundlesButton->setEnabled(true);
         m_Controls->m_CopyBundlesButton->setEnabled(true);
         m_Controls->m_GenerateFibersButton->setEnabled(true);
 
         if (m_SelectedBundles.size()>1)
             m_Controls->m_JoinBundlesButton->setEnabled(true);
     }
 
     // Signal generation gui
     if (m_Controls->m_MaskComboBox->GetSelectedNode().IsNotNull() || m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull())
     {
         m_Controls->m_GeometryMessage->setVisible(true);
         m_Controls->m_GeometryFrame->setEnabled(false);
     }
 
     if (m_Controls->m_TemplateComboBox->GetSelectedNode().IsNotNull() && mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image*>(m_Controls->m_TemplateComboBox->GetSelectedNode()->GetData())))
     {
         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);
     }
 }
 
 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_SelectedBundles.clear();
-    m_SelectedImage = NULL;
+    m_SelectedImageNode = NULL;
 
     // iterate all selected objects, adjust warning visibility
     for( int i=0; i<nodes.size(); i++)
     {
         mitk::DataNode::Pointer node = nodes.at(i);
 
 //        bool isDiffusionImage(false);
 //        if ( node.IsNotNull() )
 //        {
 //          isDiffusionImage = mitk::DiffusionPropertyHelper::IsDiffusionWeightedImage( dynamic_cast<mitk::Image *>(node->GetData()));
 //        }
 
 //        if ( node.IsNotNull() && isDiffusionImage )
 //        {
 //            m_SelectedDWI = node;
 //            m_SelectedImage = node;
 //            m_SelectedImages.push_back(node);
 //        }
 
         if( node.IsNotNull() && dynamic_cast<mitk::Image*>(node->GetData()) )
         {
             m_SelectedImages.push_back(node);
-            m_SelectedImage = node;
+            m_SelectedImageNode = node;
         }
         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( "MitkPlanarFigure" );
             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
 
     string outputPath = QFileDialog::getExistingDirectory(NULL, "Save images to...", QString(outputPath.c_str())).toStdString();
 
     if (outputPath.empty())
         m_Controls->m_SavePathEdit->setText("-");
     else
     {
         outputPath += "/";
         m_Controls->m_SavePathEdit->setText(QString(outputPath.c_str()));
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
index edff70dd72..98ce0418d2 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxView.h
@@ -1,214 +1,215 @@
 /*===================================================================
 
 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 <berryISelectionListener.h>
 #include <berryIStructuredSelection.h>
 
 #include <QmitkAbstractView.h>
 #include "ui_QmitkFiberfoxViewControls.h"
 #include <itkVectorImage.h>
 #include <itkVectorContainer.h>
 #include <itkOrientationDistributionFunction.h>
 #include <mitkFiberBundleX.h>
 #include <mitkPlanarEllipse.h>
 #include <mitkDiffusionNoiseModel.h>
 #include <mitkDiffusionSignalModel.h>
 #include <mitkRicianNoiseModel.h>
 #include <itkTractsToDWIImageFilter.h>
 #include <itkAddArtifactsToDwiImageFilter.h>
 #include <mitkTensorModel.h>
 #include <mitkBallModel.h>
 #include <mitkStickModel.h>
 #include <mitkAstroStickModel.h>
 #include <mitkDotModel.h>
 #include <QThread>
 #include <QObject>
 #include <QTimer>
 #include <QTime>
 #include <mitkFiberfoxParameters.h>
 #include <itkStatisticsImageFilter.h>
 #include <mitkDiffusionPropertyHelper.h>
 
 /*!
 \brief View for fiber based diffusion software phantoms (Fiberfox). See "Fiberfox: Facilitating the creation of realistic white matter software phantoms" (DOI: 10.1002/mrm.25045) for details.
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 // Forward Qt class declarations
 
 using namespace std;
 
 class QmitkFiberfoxView;
 
 class QmitkFiberfoxWorker : public QObject
 {
     Q_OBJECT
 
 public:
 
     QmitkFiberfoxWorker(QmitkFiberfoxView* view);
     int m_FilterType;
 
 public slots:
 
     void run();
 
 private:
 
     QmitkFiberfoxView*                  m_View;
 };
 
 class QmitkFiberfoxView : public QmitkAbstractView
 {
 
     // this is needed for all Qt objects that should have a Qt meta-object
     // (everything that derives from QObject and wants to have signal/slots)
     Q_OBJECT
 
 public:
 
     static const string VIEW_ID;
 
     QmitkFiberfoxView();
     virtual ~QmitkFiberfoxView();
 
     virtual void CreateQtPartControl(QWidget *parent);
     void SetFocus();
 
     typedef mitk::DiffusionPropertyHelper::GradientDirectionType            GradientDirectionType;
     typedef mitk::DiffusionPropertyHelper::GradientDirectionsContainerType  GradientDirectionContainerType;
     typedef itk::Vector<double,3>           GradientType;
     typedef vector<GradientType>            GradientListType;
-    typedef itk::VectorImage< short, 3 >                                    ItkDwiType;
+    typedef itk::VectorImage< short, 3 >    ItkDwiType;
     typedef itk::Image<double, 3>           ItkDoubleImgType;
+    typedef itk::Image<float, 3>            ItkFloatImgType;
     typedef itk::Image<unsigned char, 3>    ItkUcharImgType;
 
     template<int ndirs> vector<itk::Vector<double,3> > MakeGradientList();
 
 protected slots:
 
     void SetOutputPath();           ///< path where image is automatically saved to after the simulation is finished
     void LoadParameters();          ///< load fiberfox parameters
     void SaveParameters();          ///< save fiberfox parameters
 
     void BeforeThread();
     void AfterThread();
     void KillThread();              ///< abort simulation
     void UpdateSimulationStatus();  ///< print simulation progress and satus messages
 
     void OnDrawROI();               ///< adds new ROI, handles interactors etc.
     void OnAddBundle();             ///< adds new fiber bundle to datastorage
     void OnFlipButton();            ///< negate one coordinate of the fiber waypoints in the selcted planar figure. needed in case of unresolvable twists
     void GenerateFibers();          ///< generate fibers from the selected ROIs
     void GenerateImage();           ///< start image simulation
     void JoinBundles();             ///< merges selcted fiber bundles into one
     void CopyBundles();             ///< add copy of the selected bundle to the datamanager
     void ApplyTransform();          ///< rotate and shift selected bundles
     void AlignOnGrid();             ///< shift selected fiducials to nearest voxel center
     void Comp1ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 1
     void Comp2ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 2
     void Comp3ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 3
     void Comp4ModelFrameVisibility(int index);  ///< only show parameters of selected signal model for compartment 4
     void ShowAdvancedOptions(int state);
 
     /** update fibers if any parameter changes */
     void OnFiberDensityChanged(int value);
     void OnFiberSamplingChanged(double value);
     void OnTensionChanged(double value);
     void OnContinuityChanged(double value);
     void OnBiasChanged(double value);
     void OnVarianceChanged(double value);
     void OnDistributionChanged(int value);
     void OnConstantRadius(int value);
 
     /** update GUI elements */
     void OnAddNoise(int value);
     void OnAddGhosts(int value);
     void OnAddDistortions(int value);
     void OnAddEddy(int value);
     void OnAddSpikes(int value);
     void OnAddAliasing(int value);
     void OnAddMotion(int value);
     void OnMaskSelected(int value);
     void OnFibSelected(int value);
     void OnTemplateSelected(int value);
 
 protected:
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>&);
 
     GradientListType GenerateHalfShell(int NPoints);    ///< generate vectors distributed over the halfsphere
 
     Ui::QmitkFiberfoxViewControls* m_Controls;
 
     void SimulateForExistingDwi(mitk::DataNode* imageNode);     ///< add artifacts to existing diffusion weighted image
     void SimulateImageFromFibers(mitk::DataNode* fiberNode);    ///< simulate new diffusion weighted image
     template< class ScalarType > FiberfoxParameters< ScalarType > UpdateImageParameters();  ///< update fiberfox paramater object (template parameter defines noise model type)
     void UpdateGui();                                           ///< enable/disbale buttons etc. according to current datamanager selection
     void PlanarFigureSelected( itk::Object* object, const itk::EventObject& );
     void EnableCrosshairNavigation();               ///< enable crosshair navigation if planar figure interaction ends
     void DisableCrosshairNavigation();              ///< disable crosshair navigation if planar figure interaction starts
     void NodeAdded( const mitk::DataNode* node );   ///< add observers
     void NodeRemoved(const mitk::DataNode* node);   ///< remove observers
 
     /** structure to keep track of planar figures and observers */
     struct QmitkPlanarFigureData
     {
         QmitkPlanarFigureData()
             : m_Figure(0)
             , m_EndPlacementObserverTag(0)
             , m_SelectObserverTag(0)
             , m_StartInteractionObserverTag(0)
             , m_EndInteractionObserverTag(0)
             , m_Flipped(0)
         {
         }
         mitk::PlanarFigure* m_Figure;
         unsigned int m_EndPlacementObserverTag;
         unsigned int m_SelectObserverTag;
         unsigned int m_StartInteractionObserverTag;
         unsigned int m_EndInteractionObserverTag;
         unsigned int m_Flipped;
     };
 
     std::map<mitk::DataNode*, QmitkPlanarFigureData>    m_DataNodeToPlanarFigureData;   ///< map each planar figure uniquely to a QmitkPlanarFigureData
     mitk::DataNode::Pointer                             m_SelectedFiducial;             ///< selected planar ellipse
-    mitk::DataNode::Pointer                             m_SelectedImage;
+    mitk::DataNode::Pointer                             m_SelectedImageNode;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles;
     vector< mitk::DataNode::Pointer >                   m_SelectedBundles2;
     vector< mitk::DataNode::Pointer >                   m_SelectedFiducials;
     vector< mitk::DataNode::Pointer >                   m_SelectedImages;
 
     QString m_ParameterFile;    ///< parameter file name
 
     // GUI thread
     QmitkFiberfoxWorker     m_Worker;   ///< runs filter
     QThread                 m_Thread;   ///< worker thread
     bool                    m_ThreadIsRunning;
     QTimer*                 m_SimulationTimer;
     QTime                   m_SimulationTime;
     QString                 m_SimulationStatusText;
 
     /** Image filters that do all the simulations. */
     itk::TractsToDWIImageFilter< short >::Pointer           m_TractsToDwiFilter;
     itk::AddArtifactsToDwiImageFilter< short >::Pointer     m_ArtifactsToDwiFilter;
 
     friend class QmitkFiberfoxWorker;
 };