diff --git a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
index 7d0c024ed6..2c28c0926b 100755
--- a/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
+++ b/Modules/DiffusionImaging/FiberTracking/IODataStructures/FiberBundleX/mitkFiberBundleX.cpp
@@ -1,1905 +1,1924 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #define _USE_MATH_DEFINES
 #include "mitkFiberBundleX.h"
 
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarFigureComposite.h>
 #include "mitkImagePixelReadAccessor.h"
 #include <mitkPixelTypeMultiplex.h>
 
 #include <vtkPointData.h>
 #include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
 #include <vtkPolyLine.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkIdFilter.h>
 #include <vtkClipPolyData.h>
 #include <vtkPlane.h>
 #include <vtkDoubleArray.h>
 #include <vtkKochanekSpline.h>
 #include <vtkParametricFunctionSource.h>
 #include <vtkParametricSpline.h>
 #include <vtkPolygon.h>
 #include <vtkCleanPolyData.h>
 #include <cmath>
 #include <boost/progress.hpp>
 #include <vtkTransformPolyDataFilter.h>
 #include <mitkTransferFunction.h>
 #include <vtkLookupTable.h>
 #include <mitkLookupTable.h>
 #include <itkMersenneTwisterRandomVariateGenerator.h>
 
 const char* mitk::FiberBundleX::FIBER_ID_ARRAY = "Fiber_IDs";
 
 using namespace std;
 
 mitk::FiberBundleX::FiberBundleX( vtkPolyData* fiberPolyData )
     : m_NumFibers(0)
+    , m_ReferenceGeometry(NULL)
 {
     m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
     m_FiberWeights->SetName("FIBER_WEIGHTS");
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     if (fiberPolyData != NULL)
     {
         m_FiberPolyData = fiberPolyData;
         this->DoColorCodingOrientationBased();
     }
 
     this->UpdateFiberGeometry();
     this->GenerateFiberIds();
 }
 
 mitk::FiberBundleX::~FiberBundleX()
 {
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::GetDeepCopy()
 {
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(m_FiberPolyData);
     newFib->SetFiberColors(this->m_FiberColors);
     newFib->SetFiberWeights(this->m_FiberWeights);
     return newFib;
 }
 
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GeneratePolyDataByIds(std::vector<long> fiberIds)
 {
     vtkSmartPointer<vtkPolyData> newFiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> newLineSet = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> newPointSet = vtkSmartPointer<vtkPoints>::New();
 
     std::vector<long>::iterator finIt = fiberIds.begin();
     while ( finIt != fiberIds.end() )
     {
         if (*finIt < 0 || *finIt>GetNumFibers()){
             MITK_INFO << "FiberID can not be negative or >NumFibers!!! check id Extraction!" << *finIt;
             break;
         }
 
         vtkSmartPointer<vtkCell> fiber = m_FiberIdDataSet->GetCell(*finIt);//->DeepCopy(fiber);
         vtkSmartPointer<vtkPoints> fibPoints = fiber->GetPoints();
         vtkSmartPointer<vtkPolyLine> newFiber = vtkSmartPointer<vtkPolyLine>::New();
         newFiber->GetPointIds()->SetNumberOfIds( fibPoints->GetNumberOfPoints() );
 
         for(int i=0; i<fibPoints->GetNumberOfPoints(); i++)
         {
             newFiber->GetPointIds()->SetId(i, newPointSet->GetNumberOfPoints());
             newPointSet->InsertNextPoint(fibPoints->GetPoint(i)[0], fibPoints->GetPoint(i)[1], fibPoints->GetPoint(i)[2]);
         }
 
         newLineSet->InsertNextCell(newFiber);
         ++finIt;
     }
 
     newFiberPolyData->SetPoints(newPointSet);
     newFiberPolyData->SetLines(newLineSet);
     return newFiberPolyData;
 }
 
 // merge two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::AddBundle(mitk::FiberBundleX* fib)
 {
     if (fib==NULL)
     {
         MITK_WARN << "trying to call AddBundle with NULL argument";
         return NULL;
     }
     MITK_INFO << "Adding fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // add current fiber bundle
     vtkSmartPointer<vtkFloatArray> weights = vtkSmartPointer<vtkFloatArray>::New();
     weights->SetNumberOfValues(this->GetNumFibers()+fib->GetNumFibers());
 
     unsigned int counter = 0;
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         weights->InsertValue(counter, this->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
     }
 
     // add new fiber bundle
     for (int i=0; i<fib->GetFiberPolyData()->GetNumberOfCells(); i++)
     {
         vtkCell* cell = fib->GetFiberPolyData()->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             vtkIdType id = vNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         weights->InsertValue(counter, fib->GetFiberWeight(i));
         vNewLines->InsertNextCell(container);
         counter++;
     }
 
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(vNewPolyData);
     newFib->SetFiberWeights(weights);
     return newFib;
 }
 
 // subtract two fiber bundles
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::SubtractBundle(mitk::FiberBundleX* fib)
 {
     MITK_INFO << "Subtracting fibers";
 
     vtkSmartPointer<vtkPolyData> vNewPolyData = vtkSmartPointer<vtkPolyData>::New();
     vtkSmartPointer<vtkCellArray> vNewLines = vtkSmartPointer<vtkCellArray>::New();
     vtkSmartPointer<vtkPoints> vNewPoints = vtkSmartPointer<vtkPoints>::New();
 
     // iterate over current fibers
     boost::progress_display disp(m_NumFibers);
     for( int i=0; i<m_NumFibers; i++ )
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (points==NULL || numPoints<=0)
             continue;
 
         int numFibers2 = fib->GetNumFibers();
         bool contained = false;
         for( int i2=0; i2<numFibers2; i2++ )
         {
             vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i2);
             int numPoints2 = cell2->GetNumberOfPoints();
             vtkPoints* points2 = cell2->GetPoints();
 
             if (points2==NULL)// || numPoints2<=0)
                 continue;
 
             // check endpoints
             if (numPoints2==numPoints)
             {
                 itk::Point<float, 3> point_start = GetItkPoint(points->GetPoint(0));
                 itk::Point<float, 3> point_end = GetItkPoint(points->GetPoint(numPoints-1));
                 itk::Point<float, 3> point2_start = GetItkPoint(points2->GetPoint(0));
                 itk::Point<float, 3> point2_end = GetItkPoint(points2->GetPoint(numPoints2-1));
 
                 if ((point_start.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps) ||
                         (point_start.SquaredEuclideanDistanceTo(point2_end)<=mitk::eps && point_end.SquaredEuclideanDistanceTo(point2_start)<=mitk::eps))
                 {
                     // further checking ???
                     contained = true;
                     break;
                 }
             }
         }
 
         // add to result because fiber is not subtracted
         if (!contained)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for( int j=0; j<numPoints; j++)
             {
                 vtkIdType id = vNewPoints->InsertNextPoint(points->GetPoint(j));
                 container->GetPointIds()->InsertNextId(id);
             }
             vNewLines->InsertNextCell(container);
         }
     }
     if(vNewLines->GetNumberOfCells()==0)
         return NULL;
     // initialize polydata
     vNewPolyData->SetPoints(vNewPoints);
     vNewPolyData->SetLines(vNewLines);
 
     // initialize fiber bundle
     return mitk::FiberBundleX::New(vNewPolyData);
 }
 
 itk::Point<float, 3> mitk::FiberBundleX::GetItkPoint(double point[3])
 {
     itk::Point<float, 3> itkPoint;
     itkPoint[0] = point[0];
     itkPoint[1] = point[1];
     itkPoint[2] = point[2];
     return itkPoint;
 }
 
 /*
  * set polydata (additional flag to recompute fiber geometry, default = true)
  */
 void mitk::FiberBundleX::SetFiberPolyData(vtkSmartPointer<vtkPolyData> fiberPD, bool updateGeometry)
 {
     if (fiberPD == NULL)
         this->m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     else
     {
         m_FiberPolyData->DeepCopy(fiberPD);
         DoColorCodingOrientationBased();
     }
 
     m_NumFibers = m_FiberPolyData->GetNumberOfLines();
 
     if (updateGeometry)
         UpdateFiberGeometry();
     GenerateFiberIds();
 }
 
 /*
  * return vtkPolyData
  */
 vtkSmartPointer<vtkPolyData> mitk::FiberBundleX::GetFiberPolyData() const
 {
     return m_FiberPolyData;
 }
 
 void mitk::FiberBundleX::DoColorCodingOrientationBased()
 {
     //===== FOR WRITING A TEST ========================
     //  colorT size == tupelComponents * tupelElements
     //  compare color results
     //  to cover this code 100% also polydata needed, where colorarray already exists
     //  + one fiber with exactly 1 point
     //  + one fiber with 0 points
     //=================================================
 
     vtkPoints* extrPoints = NULL;
     extrPoints = m_FiberPolyData->GetPoints();
     int numOfPoints = 0;
     if (extrPoints!=NULL)
         numOfPoints = extrPoints->GetNumberOfPoints();
 
     //colors and alpha value for each single point, RGBA = 4 components
     unsigned char rgba[4] = {0,0,0,0};
     int componentSize = 4;
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(numOfPoints * componentSize);
     m_FiberColors->SetNumberOfComponents(componentSize);
     m_FiberColors->SetName("FIBER_COLORS");
 
     int numOfFibers = m_FiberPolyData->GetNumberOfLines();
     if (numOfFibers < 1)
         return;
 
     /* extract single fibers of fiberBundle */
     vtkCellArray* fiberList = m_FiberPolyData->GetLines();
     fiberList->InitTraversal();
     for (int fi=0; fi<numOfFibers; ++fi) {
 
         vtkIdType* idList; // contains the point id's of the line
         vtkIdType pointsPerFiber; // number of points for current line
         fiberList->GetNextCell(pointsPerFiber, idList);
 
         /* single fiber checkpoints: is number of points valid */
         if (pointsPerFiber > 1)
         {
             /* operate on points of single fiber */
             for (int i=0; i <pointsPerFiber; ++i)
             {
                 /* process all points except starting and endpoint for calculating color value take current point, previous point and next point */
                 if (i<pointsPerFiber-1 && i > 0)
                 {
                     /* The color value of the current point is influenced by the previous point and next point. */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
 
                     vnl_vector_fixed< double, 3 > diff;
                     diff = (diff1 - diff2) / 2.0;
                     diff.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 else if (i==0)
                 {
                     /* First point has no previous point, therefore only diff1 is taken */
 
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > nextPntvtk(extrPoints->GetPoint(idList[i+1])[0], extrPoints->GetPoint(idList[i+1])[1], extrPoints->GetPoint(idList[i+1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff1;
                     diff1 = currentPntvtk - nextPntvtk;
                     diff1.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff1[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff1[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff1[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 else if (i==pointsPerFiber-1)
                 {
                     /* Last point has no next point, therefore only diff2 is taken */
                     vnl_vector_fixed< double, 3 > currentPntvtk(extrPoints->GetPoint(idList[i])[0], extrPoints->GetPoint(idList[i])[1],extrPoints->GetPoint(idList[i])[2]);
                     vnl_vector_fixed< double, 3 > prevPntvtk(extrPoints->GetPoint(idList[i-1])[0], extrPoints->GetPoint(idList[i-1])[1], extrPoints->GetPoint(idList[i-1])[2]);
 
                     vnl_vector_fixed< double, 3 > diff2;
                     diff2 = currentPntvtk - prevPntvtk;
                     diff2.normalize();
 
                     rgba[0] = (unsigned char) (255.0 * std::fabs(diff2[0]));
                     rgba[1] = (unsigned char) (255.0 * std::fabs(diff2[1]));
                     rgba[2] = (unsigned char) (255.0 * std::fabs(diff2[2]));
                     rgba[3] = (unsigned char) (255.0);
                 }
                 m_FiberColors->InsertTupleValue(idList[i], rgba);
             }
         }
         else if (pointsPerFiber == 1)
         {
             /* a single point does not define a fiber (use vertex mechanisms instead */
             continue;
         }
         else
         {
             MITK_DEBUG << "Fiber with 0 points detected... please check your tractography algorithm!" ;
             continue;
         }
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundleX::SetFiberOpacity(vtkDoubleArray* FAValArray)
 {
     for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
     {
         double faValue = FAValArray->GetValue(i);
         faValue = faValue * 255.0;
         m_FiberColors->SetComponent(i,3, (unsigned char) faValue );
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundleX::ResetFiberOpacity()
 {
     for(long i=0; i<m_FiberColors->GetNumberOfTuples(); i++)
         m_FiberColors->SetComponent(i,3, 255.0 );
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundleX::ColorFibersByScalarMap(mitk::Image::Pointer FAimage, bool opacity)
 {
     mitkPixelTypeMultiplex2( ColorFibersByScalarMap, FAimage->GetPixelType(), FAimage, opacity );
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 template <typename TPixel>
 void mitk::FiberBundleX::ColorFibersByScalarMap(const mitk::PixelType, mitk::Image::Pointer image, bool opacity)
 {
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
     m_FiberColors->SetNumberOfComponents(4);
     m_FiberColors->SetName("FIBER_COLORS");
 
     mitk::ImagePixelReadAccessor<TPixel,3> readimage(image, image->GetVolumeData(0));
 
     unsigned char rgba[4] = {0,0,0,0};
     vtkPoints* pointSet = m_FiberPolyData->GetPoints();
 
     mitk::LookupTable::Pointer mitkLookup = mitk::LookupTable::New();
     vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
     lookupTable->SetTableRange(0.0, 0.8);
     lookupTable->Build();
     mitkLookup->SetVtkLookupTable(lookupTable);
     mitkLookup->SetType(mitk::LookupTable::JET);
 
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         Point3D px;
         px[0] = pointSet->GetPoint(i)[0];
         px[1] = pointSet->GetPoint(i)[1];
         px[2] = pointSet->GetPoint(i)[2];
         double pixelValue = readimage.GetPixelByWorldCoordinates(px);
 
         double color[3];
         lookupTable->GetColor(pixelValue, color);
 
         rgba[0] = (unsigned char) (255.0 * color[0]);
         rgba[1] = (unsigned char) (255.0 * color[1]);
         rgba[2] = (unsigned char) (255.0 * color[2]);
         if (opacity)
             rgba[3] = (unsigned char) (255.0 * pixelValue);
         else
             rgba[3] = (unsigned char) (255.0);
         m_FiberColors->InsertTupleValue(i, rgba);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundleX::SetFiberColors(float r, float g, float b, float alpha)
 {
     m_FiberColors = vtkSmartPointer<vtkUnsignedCharArray>::New();
     m_FiberColors->Allocate(m_FiberPolyData->GetNumberOfPoints() * 4);
     m_FiberColors->SetNumberOfComponents(4);
     m_FiberColors->SetName("FIBER_COLORS");
 
     unsigned char rgba[4] = {0,0,0,0};
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         rgba[0] = (unsigned char) r;
         rgba[1] = (unsigned char) g;
         rgba[2] = (unsigned char) b;
         rgba[3] = (unsigned char) alpha;
         m_FiberColors->InsertTupleValue(i, rgba);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 void mitk::FiberBundleX::GenerateFiberIds()
 {
     if (m_FiberPolyData == NULL)
         return;
 
     vtkSmartPointer<vtkIdFilter> idFiberFilter = vtkSmartPointer<vtkIdFilter>::New();
     idFiberFilter->SetInputData(m_FiberPolyData);
     idFiberFilter->CellIdsOn();
     //  idFiberFilter->PointIdsOn(); // point id's are not needed
     idFiberFilter->SetIdsArrayName(FIBER_ID_ARRAY);
     idFiberFilter->FieldDataOn();
     idFiberFilter->Update();
 
     m_FiberIdDataSet = idFiberFilter->GetOutput();
 
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(ItkUcharImgType* mask, bool anyPoint, bool invert)
 {
     vtkSmartPointer<vtkPolyData> polyData = m_FiberPolyData;
     if (anyPoint)
     {
         float minSpacing = 1;
         if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[0];
         else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
             minSpacing = mask->GetSpacing()[1];
         else
             minSpacing = mask->GetSpacing()[2];
 
         mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
         fibCopy->ResampleSpline(minSpacing/5);
         polyData = fibCopy->GetFiberPolyData();
     }
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Extracting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkCell* cellOriginal = m_FiberPolyData->GetCell(i);
         int numPointsOriginal = cellOriginal->GetNumberOfPoints();
         vtkPoints* pointsOriginal = cellOriginal->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         if (numPoints>1 && numPointsOriginal)
         {
             if (anyPoint)
             {
                 if (!invert)
                 {
                     for (int j=0; j<numPoints; j++)
                     {
                         double* p = points->GetPoint(j);
 
                         itk::Point<float, 3> itkP;
                         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                         itk::Index<3> idx;
                         mask->TransformPhysicalPointToIndex(itkP, idx);
 
                         if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
                         {
                             for (int k=0; k<numPointsOriginal; k++)
                             {
                                 double* p = pointsOriginal->GetPoint(k);
                                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                                 container->GetPointIds()->InsertNextId(id);
                             }
                             break;
                         }
                     }
                 }
                 else
                 {
                     bool includeFiber = true;
                     for (int j=0; j<numPoints; j++)
                     {
                         double* p = points->GetPoint(j);
 
                         itk::Point<float, 3> itkP;
                         itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                         itk::Index<3> idx;
                         mask->TransformPhysicalPointToIndex(itkP, idx);
 
                         if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) )
                         {
                             includeFiber = false;
                             break;
                         }
                     }
                     if (includeFiber)
                     {
 
                         for (int k=0; k<numPointsOriginal; k++)
                         {
                             double* p = pointsOriginal->GetPoint(k);
                             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                     }
                 }
             }
             else
             {
                 double* start = pointsOriginal->GetPoint(0);
                 itk::Point<float, 3> itkStart;
                 itkStart[0] = start[0]; itkStart[1] = start[1]; itkStart[2] = start[2];
                 itk::Index<3> idxStart;
                 mask->TransformPhysicalPointToIndex(itkStart, idxStart);
 
                 double* end = pointsOriginal->GetPoint(numPointsOriginal-1);
                 itk::Point<float, 3> itkEnd;
                 itkEnd[0] = end[0]; itkEnd[1] = end[1]; itkEnd[2] = end[2];
                 itk::Index<3> idxEnd;
                 mask->TransformPhysicalPointToIndex(itkEnd, idxEnd);
 
                 if (invert)
                 {
                     if ( mask->GetPixel(idxStart)==0 && mask->GetPixel(idxEnd)==0 && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                     {
                         for (int j=0; j<numPointsOriginal; j++)
                         {
                             double* p = pointsOriginal->GetPoint(j);
                             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                     }
                 }
                 else
                 {
                     if ( (mask->GetPixel(idxStart)>0 || mask->GetPixel(idxEnd)>0) && mask->GetLargestPossibleRegion().IsInside(idxStart) && mask->GetLargestPossibleRegion().IsInside(idxEnd) )
                     {
                         for (int j=0; j<numPointsOriginal; j++)
                         {
                             double* p = pointsOriginal->GetPoint(j);
                             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                             container->GetPointIds()->InsertNextId(id);
                         }
                     }
                 }
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     return mitk::FiberBundleX::New(newPolyData);
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::RemoveFibersOutside(ItkUcharImgType* mask, bool invert)
 {
     float minSpacing = 1;
     if(mask->GetSpacing()[0]<mask->GetSpacing()[1] && mask->GetSpacing()[0]<mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[0];
     else if (mask->GetSpacing()[1] < mask->GetSpacing()[2])
         minSpacing = mask->GetSpacing()[1];
     else
         minSpacing = mask->GetSpacing()[2];
 
     mitk::FiberBundleX::Pointer fibCopy = this->GetDeepCopy();
     fibCopy->ResampleSpline(minSpacing/10);
     vtkSmartPointer<vtkPolyData> polyData =fibCopy->GetFiberPolyData();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Cutting fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
 
         vtkCell* cell = polyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         if (numPoints>1)
         {
             int newNumPoints = 0;
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
 
                 itk::Point<float, 3> itkP;
                 itkP[0] = p[0]; itkP[1] = p[1]; itkP[2] = p[2];
                 itk::Index<3> idx;
                 mask->TransformPhysicalPointToIndex(itkP, idx);
 
                 if ( mask->GetPixel(idx)>0 && mask->GetLargestPossibleRegion().IsInside(idx) && !invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if ( (mask->GetPixel(idx)<=0 || !mask->GetLargestPossibleRegion().IsInside(idx)) && invert )
                 {
                     vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                     container->GetPointIds()->InsertNextId(id);
                     newNumPoints++;
                 }
                 else if (newNumPoints>0)
                 {
                     vtkNewCells->InsertNextCell(container);
 
                     newNumPoints = 0;
                     container = vtkSmartPointer<vtkPolyLine>::New();
                 }
             }
 
             if (newNumPoints>0)
                 vtkNewCells->InsertNextCell(container);
         }
 
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return NULL;
 
     vtkSmartPointer<vtkPolyData> newPolyData = vtkSmartPointer<vtkPolyData>::New();
     newPolyData->SetPoints(vtkNewPoints);
     newPolyData->SetLines(vtkNewCells);
     mitk::FiberBundleX::Pointer newFib = mitk::FiberBundleX::New(newPolyData);
     newFib->ResampleSpline(minSpacing/2);
     return newFib;
 }
 
 mitk::FiberBundleX::Pointer mitk::FiberBundleX::ExtractFiberSubset(BaseData* roi)
 {
     if (roi==NULL || !(dynamic_cast<PlanarFigure*>(roi) || dynamic_cast<PlanarFigureComposite*>(roi)) )
         return NULL;
 
     std::vector<long> tmp = ExtractFiberIdSubset(roi);
 
     if (tmp.size()<=0)
         return mitk::FiberBundleX::New();
     vtkSmartPointer<vtkPolyData> pTmp = GeneratePolyDataByIds(tmp);
     return mitk::FiberBundleX::New(pTmp);
 }
 
 std::vector<long> mitk::FiberBundleX::ExtractFiberIdSubset(BaseData* roi)
 {
     std::vector<long> result;
     if (roi==NULL)
         return result;
 
     mitk::PlanarFigureComposite::Pointer pfc = dynamic_cast<mitk::PlanarFigureComposite*>(roi);
     if (!pfc.IsNull()) // handle composite
     {
         switch (pfc->getOperationType())
         {
         case 0: // AND
         {
             result = this->ExtractFiberIdSubset(pfc->getChildAt(0));
             std::vector<long>::iterator it;
             for (int i=1; i<pfc->getNumberOfChildren(); ++i)
             {
                 std::vector<long> inRoi = this->ExtractFiberIdSubset(pfc->getChildAt(i));
 
                 std::vector<long> rest(std::min(result.size(),inRoi.size()));
                 it = std::set_intersection(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
                 rest.resize( it - rest.begin() );
                 result = rest;
             }
             break;
         }
         case 1: // OR
         {
             result = ExtractFiberIdSubset(pfc->getChildAt(0));
             std::vector<long>::iterator it;
             for (int i=1; i<pfc->getNumberOfChildren(); ++i)
             {
                 it = result.end();
                 std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
                 result.insert(it, inRoi.begin(), inRoi.end());
             }
 
             // remove duplicates
             sort(result.begin(), result.end());
             it = unique(result.begin(), result.end());
             result.resize( it - result.begin() );
             break;
         }
         case 2: // NOT
         {
             for(long i=0; i<this->GetNumFibers(); i++)
                 result.push_back(i);
 
             std::vector<long>::iterator it;
             for (long i=0; i<pfc->getNumberOfChildren(); ++i)
             {
                 std::vector<long> inRoi = ExtractFiberIdSubset(pfc->getChildAt(i));
 
                 std::vector<long> rest(result.size()-inRoi.size());
                 it = std::set_difference(result.begin(), result.end(), inRoi.begin(), inRoi.end(), rest.begin() );
                 rest.resize( it - rest.begin() );
                 result = rest;
             }
             break;
         }
         }
     }
     else if ( dynamic_cast<mitk::PlanarFigure*>(roi) )  // actual extraction
     {
         if ( dynamic_cast<mitk::PlanarPolygon*>(roi) )
         {
             mitk::PlanarFigure::Pointer planarPoly = dynamic_cast<mitk::PlanarFigure*>(roi);
 
             //create vtkPolygon using controlpoints from planarFigure polygon
             vtkSmartPointer<vtkPolygon> polygonVtk = vtkSmartPointer<vtkPolygon>::New();
             for (unsigned int i=0; i<planarPoly->GetNumberOfControlPoints(); ++i)
             {
                 itk::Point<double,3> p = planarPoly->GetWorldControlPoint(i);
                 vtkIdType id = polygonVtk->GetPoints()->InsertNextPoint(p[0], p[1], p[2] );
                 polygonVtk->GetPointIds()->InsertNextId(id);
             }
 
             MITK_INFO << "Extracting with polygon";
             boost::progress_display disp(m_NumFibers);
             for (int i=0; i<m_NumFibers; i++)
             {
                 ++disp ;
                 vtkCell* cell = m_FiberPolyData->GetCell(i);
                 int numPoints = cell->GetNumberOfPoints();
                 vtkPoints* points = cell->GetPoints();
 
                 for (int j=0; j<numPoints-1; j++)
                 {
                     // Inputs
                     double p1[3] = {0,0,0};
                     points->GetPoint(j, p1);
                     double p2[3] = {0,0,0};
                     points->GetPoint(j+1, p2);
                     double tolerance = 0.001;
 
                     // Outputs
                     double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
                     double x[3] = {0,0,0}; // The coordinate of the intersection
                     double pcoords[3] = {0,0,0};
                     int subId = 0;
 
                     int iD = polygonVtk->IntersectWithLine(p1, p2, tolerance, t, x, pcoords, subId);
                     if (iD!=0)
                     {
                         result.push_back(i);
                         break;
                     }
                 }
             }
         }
         else if ( dynamic_cast<mitk::PlanarCircle*>(roi) )
         {
             mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(roi);
             Vector3D planeNormal = planarFigure->GetPlaneGeometry()->GetNormal();
             planeNormal.Normalize();
 
             //calculate circle radius
             mitk::Point3D V1w = planarFigure->GetWorldControlPoint(0); //centerPoint
             mitk::Point3D V2w  = planarFigure->GetWorldControlPoint(1); //radiusPoint
 
             double radius = V1w.EuclideanDistanceTo(V2w);
             radius *= radius;
 
             MITK_INFO << "Extracting with circle";
             boost::progress_display disp(m_NumFibers);
             for (int i=0; i<m_NumFibers; i++)
             {
                 ++disp ;
                 vtkCell* cell = m_FiberPolyData->GetCell(i);
                 int numPoints = cell->GetNumberOfPoints();
                 vtkPoints* points = cell->GetPoints();
 
                 for (int j=0; j<numPoints-1; j++)
                 {
                     // Inputs
                     double p1[3] = {0,0,0};
                     points->GetPoint(j, p1);
                     double p2[3] = {0,0,0};
                     points->GetPoint(j+1, p2);
 
                     // Outputs
                     double t = 0; // Parametric coordinate of intersection (0 (corresponding to p1) to 1 (corresponding to p2))
                     double x[3] = {0,0,0}; // The coordinate of the intersection
 
                     int iD = vtkPlane::IntersectWithLine(p1,p2,planeNormal.GetDataPointer(),V1w.GetDataPointer(),t,x);
 
                     if (iD!=0)
                     {
                         double dist = (x[0]-V1w[0])*(x[0]-V1w[0])+(x[1]-V1w[1])*(x[1]-V1w[1])+(x[2]-V1w[2])*(x[2]-V1w[2]);
                         if( dist <= radius)
                         {
                             result.push_back(i);
                             break;
                         }
                     }
                 }
             }
         }
         return result;
     }
 
     return result;
 }
 
 void mitk::FiberBundleX::UpdateFiberGeometry()
 {
     vtkSmartPointer<vtkCleanPolyData> cleaner = vtkSmartPointer<vtkCleanPolyData>::New();
     cleaner->SetInputData(m_FiberPolyData);
     cleaner->PointMergingOff();
     cleaner->Update();
     m_FiberPolyData = cleaner->GetOutput();
 
     m_FiberLengths.clear();
     m_MeanFiberLength = 0;
     m_MedianFiberLength = 0;
     m_LengthStDev = 0;
     m_NumFibers = m_FiberPolyData->GetNumberOfCells();
 
     if (m_FiberColors==NULL || m_FiberColors->GetNumberOfTuples()!=m_FiberPolyData->GetNumberOfPoints())
         this->DoColorCodingOrientationBased();
 
     if (m_FiberWeights->GetSize()!=m_NumFibers)
     {
         m_FiberWeights = vtkSmartPointer<vtkFloatArray>::New();
         m_FiberWeights->SetName("FIBER_WEIGHTS");
         m_FiberWeights->SetNumberOfValues(m_NumFibers);
         this->SetFiberWeights(1);
     }
 
     if (m_NumFibers<=0) // no fibers present; apply default geometry
     {
         m_MinFiberLength = 0;
         m_MaxFiberLength = 0;
         mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
         geometry->SetImageGeometry(false);
         float b[] = {0, 1, 0, 1, 0, 1};
         geometry->SetFloatBounds(b);
         SetGeometry(geometry);
         return;
     }
     double b[6];
     m_FiberPolyData->GetBounds(b);
 
     // calculate statistics
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int p = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
         float length = 0;
         for (int j=0; j<p-1; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
 
             float dist = std::sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1])+(p1[2]-p2[2])*(p1[2]-p2[2]));
             length += dist;
         }
         m_FiberLengths.push_back(length);
         m_MeanFiberLength += length;
         if (i==0)
         {
             m_MinFiberLength = length;
             m_MaxFiberLength = length;
         }
         else
         {
             if (length<m_MinFiberLength)
                 m_MinFiberLength = length;
             if (length>m_MaxFiberLength)
                 m_MaxFiberLength = length;
         }
     }
     m_MeanFiberLength /= m_NumFibers;
 
     std::vector< float > sortedLengths = m_FiberLengths;
     std::sort(sortedLengths.begin(), sortedLengths.end());
     for (int i=0; i<m_NumFibers; i++)
         m_LengthStDev += (m_MeanFiberLength-sortedLengths.at(i))*(m_MeanFiberLength-sortedLengths.at(i));
     if (m_NumFibers>1)
         m_LengthStDev /= (m_NumFibers-1);
     else
         m_LengthStDev = 0;
     m_LengthStDev = std::sqrt(m_LengthStDev);
     m_MedianFiberLength = sortedLengths.at(m_NumFibers/2);
 
     mitk::Geometry3D::Pointer geometry = mitk::Geometry3D::New();
     geometry->SetFloatBounds(b);
     this->SetGeometry(geometry);
 
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 float mitk::FiberBundleX::GetFiberWeight(unsigned int fiber)
 {
     return m_FiberWeights->GetValue(fiber);
 }
 
 void mitk::FiberBundleX::SetFiberWeights(float newWeight)
 {
     for (int i=0; i<m_FiberWeights->GetSize(); i++)
         m_FiberWeights->SetValue(i, newWeight);
 }
 
 void mitk::FiberBundleX::SetFiberWeights(vtkSmartPointer<vtkFloatArray> weights)
 {
     if (m_NumFibers!=weights->GetSize())
         return;
 
     for (int i=0; i<weights->GetSize(); i++)
         m_FiberWeights->SetValue(i, weights->GetValue(i));
 
     m_FiberWeights->SetName("FIBER_WEIGHTS");
 }
 
 void mitk::FiberBundleX::SetFiberWeight(unsigned int fiber, float weight)
 {
     m_FiberWeights->SetValue(fiber, weight);
 }
 
 void mitk::FiberBundleX::SetFiberColors(vtkSmartPointer<vtkUnsignedCharArray> fiberColors)
 {
     for(long i=0; i<m_FiberPolyData->GetNumberOfPoints(); ++i)
     {
         unsigned char source[4] = {0,0,0,0};
         fiberColors->GetTupleValue(i, source);
 
         unsigned char target[4] = {0,0,0,0};
         target[0] = source[0];
         target[1] = source[1];
         target[2] = source[2];
         target[3] = source[3];
         m_FiberColors->InsertTupleValue(i, target);
     }
     m_UpdateTime3D.Modified();
     m_UpdateTime2D.Modified();
 }
 
 itk::Matrix< double, 3, 3 > mitk::FiberBundleX::TransformMatrix(itk::Matrix< double, 3, 3 > m, double rx, double ry, double rz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     itk::Matrix< double, 3, 3 > rotX; rotX.SetIdentity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     itk::Matrix< double, 3, 3 > rotY; rotY.SetIdentity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     itk::Matrix< double, 3, 3 > rotZ; rotZ.SetIdentity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     itk::Matrix< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     m = rot*m;
 
     return m;
 }
 
 itk::Point<float, 3> mitk::FiberBundleX::TransformPoint(vnl_vector_fixed< double, 3 > point, double rx, double ry, double rz, double tx, double ty, double tz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     point[0] -= center[0];
     point[1] -= center[1];
     point[2] -= center[2];
     point = rot*point;
     point[0] += center[0]+tx;
     point[1] += center[1]+ty;
     point[2] += center[2]+tz;
     itk::Point<float, 3> out; out[0] = point[0]; out[1] = point[1]; out[2] = point[2];
     return out;
 }
 
 void mitk::FiberBundleX::TransformFibers(double rx, double ry, double rz, double tx, double ty, double tz)
 {
     rx = rx*M_PI/180;
     ry = ry*M_PI/180;
     rz = rz*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(rx);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(rx);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(ry);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(ry);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(rz);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(rz);
     rotZ[1][0] = -rotZ[0][1];
 
     vnl_matrix_fixed< double, 3, 3 > rot = rotZ*rotY*rotX;
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             vnl_vector_fixed< double, 3 > dir;
             dir[0] = p[0]-center[0];
             dir[1] = p[1]-center[1];
             dir[2] = p[2]-center[2];
             dir = rot*dir;
             dir[0] += center[0]+tx;
             dir[1] += center[1]+ty;
             dir[2] += center[2]+tz;
             vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::RotateAroundAxis(double x, double y, double z)
 {
     x = x*M_PI/180;
     y = y*M_PI/180;
     z = z*M_PI/180;
 
     vnl_matrix_fixed< double, 3, 3 > rotX; rotX.set_identity();
     rotX[1][1] = cos(x);
     rotX[2][2] = rotX[1][1];
     rotX[1][2] = -sin(x);
     rotX[2][1] = -rotX[1][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotY; rotY.set_identity();
     rotY[0][0] = cos(y);
     rotY[2][2] = rotY[0][0];
     rotY[0][2] = sin(y);
     rotY[2][0] = -rotY[0][2];
 
     vnl_matrix_fixed< double, 3, 3 > rotZ; rotZ.set_identity();
     rotZ[0][0] = cos(z);
     rotZ[1][1] = rotZ[0][0];
     rotZ[0][1] = -sin(z);
     rotZ[1][0] = -rotZ[0][1];
 
     mitk::BaseGeometry::Pointer geom = this->GetGeometry();
     mitk::Point3D center = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             vnl_vector_fixed< double, 3 > dir;
             dir[0] = p[0]-center[0];
             dir[1] = p[1]-center[1];
             dir[2] = p[2]-center[2];
             dir = rotZ*rotY*rotX*dir;
             dir[0] += center[0];
             dir[1] += center[1];
             dir[2] += center[2];
             vtkIdType id = vtkNewPoints->InsertNextPoint(dir.data_block());
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::ScaleFibers(double x, double y, double z, bool subtractCenter)
 {
     MITK_INFO << "Scaling fibers";
     boost::progress_display disp(m_NumFibers);
 
     mitk::BaseGeometry* geom = this->GetGeometry();
     mitk::Point3D c = geom->GetCenter();
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             if (subtractCenter)
             {
                 p[0] -= c[0]; p[1] -= c[1]; p[2] -= c[2];
             }
             p[0] *= x;
             p[1] *= y;
             p[2] *= z;
             if (subtractCenter)
             {
                 p[0] += c[0]; p[1] += c[1]; p[2] += c[2];
             }
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::TranslateFibers(double x, double y, double z)
 {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
             p[0] += x;
             p[1] += y;
             p[2] += z;
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::MirrorFibers(unsigned int axis)
 {
     if (axis>2)
         return;
 
+    mitk::Point3D c; c.Fill(0);
+    if (m_ReferenceGeometry.IsNotNull()){
+//        c = m_ReferenceGeometry->GetCenter();
+        c = m_ReferenceGeometry->GetBoundingBox()->GetCenter();
+        c[0] -= 0.5;
+        c[1] -= 0.5;
+        c[2] -= 0.5;
+        m_ReferenceGeometry->IndexToWorld(c, c);
+    }
+    MITK_INFO << c;
+
+
     MITK_INFO << "Mirroring fibers";
     boost::progress_display disp(m_NumFibers);
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double* p = points->GetPoint(j);
+            p[0] -= c[0];
+            p[1] -= c[1];
+            p[2] -= c[2];
             p[axis] = -p[axis];
+            p[0] += c[0];
+            p[1] += c[1];
+            p[2] += c[2];
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::RemoveDir(vnl_vector_fixed<double,3> dir, double threshold)
 {
     dir.normalize();
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         bool discard = false;
         for (int j=0; j<numPoints-1; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
 
             vnl_vector_fixed< double, 3 > v1;
             v1[0] = p2[0]-p1[0];
             v1[1] = p2[1]-p1[1];
             v1[2] = p2[2]-p1[2];
             if (v1.magnitude()>0.001)
             {
                 v1.normalize();
 
                 if (fabs(dot_product(v1,dir))>threshold)
                 {
                     discard = true;
                     break;
                 }
             }
         }
         if (!discard)
         {
             for (int j=0; j<numPoints; j++)
             {
                 double p1[3];
                 points->GetPoint(j, p1);
 
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
 
     this->SetFiberPolyData(m_FiberPolyData, true);
 
     //    UpdateColorCoding();
     //    UpdateFiberGeometry();
 }
 
 bool mitk::FiberBundleX::ApplyCurvatureThreshold(float minRadius, bool deleteFibers)
 {
     if (minRadius<0)
         return true;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Applying curvature threshold";
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp ;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints-2; j++)
         {
             double p1[3];
             points->GetPoint(j, p1);
             double p2[3];
             points->GetPoint(j+1, p2);
             double p3[3];
             points->GetPoint(j+2, p3);
 
             vnl_vector_fixed< float, 3 > v1, v2, v3;
 
             v1[0] = p2[0]-p1[0];
             v1[1] = p2[1]-p1[1];
             v1[2] = p2[2]-p1[2];
 
             v2[0] = p3[0]-p2[0];
             v2[1] = p3[1]-p2[1];
             v2[2] = p3[2]-p2[2];
 
             v3[0] = p1[0]-p3[0];
             v3[1] = p1[1]-p3[1];
             v3[2] = p1[2]-p3[2];
 
             float a = v1.magnitude();
             float b = v2.magnitude();
             float c = v3.magnitude();
             float r = a*b*c/std::sqrt((a+b+c)*(a+b-c)*(b+c-a)*(a-b+c)); // radius of triangle via Heron's formula (area of triangle)
 
             vtkIdType id = vtkNewPoints->InsertNextPoint(p1);
             container->GetPointIds()->InsertNextId(id);
 
             if (deleteFibers && r<minRadius)
                 break;
 
             if (r<minRadius)
             {
                 j += 2;
                 vtkNewCells->InsertNextCell(container);
                 container = vtkSmartPointer<vtkPolyLine>::New();
             }
             else if (j==numPoints-3)
             {
                 id = vtkNewPoints->InsertNextPoint(p2);
                 container->GetPointIds()->InsertNextId(id);
                 id = vtkNewPoints->InsertNextPoint(p3);
                 container->GetPointIds()->InsertNextId(id);
                 vtkNewCells->InsertNextCell(container);
             }
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
 bool mitk::FiberBundleX::RemoveShortFibers(float lengthInMM)
 {
     MITK_INFO << "Removing short fibers";
     if (lengthInMM<=0 || lengthInMM<m_MinFiberLength)
     {
         MITK_INFO << "No fibers shorter than " << lengthInMM << " mm found!";
         return true;
     }
 
     if (lengthInMM>m_MaxFiberLength)    // can't remove all fibers
     {
         MITK_WARN << "Process aborted. No fibers would be left!";
         return false;
     }
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
     float min = m_MaxFiberLength;
 
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)>=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
             if (m_FiberLengths.at(i)<min)
                 min = m_FiberLengths.at(i);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
 bool mitk::FiberBundleX::RemoveLongFibers(float lengthInMM)
 {
     if (lengthInMM<=0 || lengthInMM>m_MaxFiberLength)
         return true;
 
     if (lengthInMM<m_MinFiberLength)    // can't remove all fibers
         return false;
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Removing long fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         if (m_FiberLengths.at(i)<=lengthInMM)
         {
             vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
             for (int j=0; j<numPoints; j++)
             {
                 double* p = points->GetPoint(j);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(p);
                 container->GetPointIds()->InsertNextId(id);
             }
             vtkNewCells->InsertNextCell(container);
         }
     }
 
     if (vtkNewCells->GetNumberOfCells()<=0)
         return false;
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
     return true;
 }
 
 void mitk::FiberBundleX::ResampleSpline(float pointDistance, double tension, double continuity, double bias )
 {
     if (pointDistance<=0)
         return;
 
     vtkSmartPointer<vtkPoints> vtkSmoothPoints = vtkSmartPointer<vtkPoints>::New(); //in smoothpoints the interpolated points representing a fiber are stored.
 
     //in vtkcells all polylines are stored, actually all id's of them are stored
     vtkSmartPointer<vtkCellArray> vtkSmoothCells = vtkSmartPointer<vtkCellArray>::New(); //cellcontainer for smoothed lines
     vtkIdType pointHelperCnt = 0;
 
 
     vtkSmartPointer<vtkKochanekSpline> xSpline = vtkSmartPointer<vtkKochanekSpline>::New();
     vtkSmartPointer<vtkKochanekSpline> ySpline = vtkSmartPointer<vtkKochanekSpline>::New();
     vtkSmartPointer<vtkKochanekSpline> zSpline = vtkSmartPointer<vtkKochanekSpline>::New();
     xSpline->SetDefaultBias(bias); xSpline->SetDefaultTension(tension); xSpline->SetDefaultContinuity(continuity);
     ySpline->SetDefaultBias(bias); ySpline->SetDefaultTension(tension); ySpline->SetDefaultContinuity(continuity);
     zSpline->SetDefaultBias(bias); zSpline->SetDefaultTension(tension); zSpline->SetDefaultContinuity(continuity);
 
     MITK_INFO << "Smoothing fibers";
     boost::progress_display disp(m_NumFibers);
     for (int i=0; i<m_NumFibers; i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         vtkPoints* points = cell->GetPoints();
 
         float length = m_FiberLengths.at(i);
         int sampling = std::ceil(length/pointDistance);
 
         vtkSmartPointer<vtkParametricSpline> spline = vtkSmartPointer<vtkParametricSpline>::New();
         spline->SetXSpline(xSpline);
         spline->SetYSpline(ySpline);
         spline->SetZSpline(zSpline);
         spline->SetPoints(points);
 
         vtkSmartPointer<vtkParametricFunctionSource> functionSource = vtkSmartPointer<vtkParametricFunctionSource>::New();
         functionSource->SetParametricFunction(spline);
         functionSource->SetUResolution(sampling);
         functionSource->SetVResolution(sampling);
         functionSource->SetWResolution(sampling);
         functionSource->Update();
 
         vtkPolyData* outputFunction = functionSource->GetOutput();
         vtkPoints* tmpSmoothPnts = outputFunction->GetPoints(); //smoothPoints of current fiber
 
         vtkSmartPointer<vtkPolyLine> smoothLine = vtkSmartPointer<vtkPolyLine>::New();
         smoothLine->GetPointIds()->SetNumberOfIds(tmpSmoothPnts->GetNumberOfPoints());
 
         for (int j=0; j<smoothLine->GetNumberOfPoints(); j++)
         {
             smoothLine->GetPointIds()->SetId(j, j+pointHelperCnt);
             vtkSmoothPoints->InsertNextPoint(tmpSmoothPnts->GetPoint(j));
         }
         vtkSmoothCells->InsertNextCell(smoothLine);
         pointHelperCnt += tmpSmoothPnts->GetNumberOfPoints();
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkSmoothPoints);
     m_FiberPolyData->SetLines(vtkSmoothCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::ResampleSpline(float pointDistance)
 {
     ResampleSpline(pointDistance, 0, 0, 0 );
 }
 
 unsigned long mitk::FiberBundleX::GetNumberOfPoints()
 {
     unsigned long points = 0;
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         points += cell->GetNumberOfPoints();
     }
     return points;
 }
 
 void mitk::FiberBundleX::Noisify(float dist)
 {
     MITK_INFO << "Noisifying fibers";
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
 
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     itk::Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = itk::Statistics::MersenneTwisterRandomVariateGenerator::New();
     randGen->SetSeed((unsigned int)0);
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         int offset = -numPoints/2;
 
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
         for (int j=0; j<numPoints; j++)
         {
             double p[3];
             points->GetPoint(j, p);
 
             if (j>0 && j<numPoints-1)
             {
                 float mod = fabs(offset+j)/(offset);
                 p[0] += randGen->GetNormalVariate(0, dist)*mod;
                 p[1] += randGen->GetNormalVariate(0, dist)*mod;
                 p[2] += randGen->GetNormalVariate(0, dist)*mod;
             }
 
             vtkIdType id = vtkNewPoints->InsertNextPoint(p);
             container->GetPointIds()->InsertNextId(id);
         }
         vtkNewCells->InsertNextCell(container);
     }
 
     m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
     m_FiberPolyData->SetPoints(vtkNewPoints);
     m_FiberPolyData->SetLines(vtkNewCells);
     this->SetFiberPolyData(m_FiberPolyData, true);
 }
 
 void mitk::FiberBundleX::Compress(float error)
 {
     vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> vtkNewCells = vtkSmartPointer<vtkCellArray>::New();
 
     MITK_INFO << "Compressing fibers";
     unsigned long numRemovedPoints = 0;
     boost::progress_display disp(m_FiberPolyData->GetNumberOfCells());
 
     for (int i=0; i<m_FiberPolyData->GetNumberOfCells(); i++)
     {
         ++disp;
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         // calculate curvatures
         std::vector< int > removedPoints; removedPoints.resize(numPoints, 0);
         removedPoints[0]=-1; removedPoints[numPoints-1]=-1;
 
         vtkSmartPointer<vtkPolyLine> container = vtkSmartPointer<vtkPolyLine>::New();
 
         bool pointFound = true;
         while (pointFound)
         {
             pointFound = false;
             double minError = error;
             int removeIndex = -1;
 
             for (int j=0; j<numPoints; j++)
             {
                 if (removedPoints[j]==0)
                 {
                     double cand[3];
                     points->GetPoint(j, cand);
                     vnl_vector_fixed< double, 3 > candV;
                     candV[0]=cand[0]; candV[1]=cand[1]; candV[2]=cand[2];
 
                     int validP = -1;
                     vnl_vector_fixed< double, 3 > pred;
                     for (int k=j-1; k>=0; k--)
                         if (removedPoints[k]<=0)
                         {
                             double ref[3];
                             points->GetPoint(k, ref);
                             pred[0]=ref[0]; pred[1]=ref[1]; pred[2]=ref[2];
                             validP = k;
                             break;
                         }
                     int validS = -1;
                     vnl_vector_fixed< double, 3 > succ;
                     for (int k=j+1; k<numPoints; k++)
                         if (removedPoints[k]<=0)
                         {
                             double ref[3];
                             points->GetPoint(k, ref);
                             succ[0]=ref[0]; succ[1]=ref[1]; succ[2]=ref[2];
                             validS = k;
                             break;
                         }
 
                     if (validP>=0 && validS>=0)
                     {
                         double a = (candV-pred).magnitude();
                         double b = (candV-succ).magnitude();
                         double c = (pred-succ).magnitude();
                         double s=0.5*(a+b+c);
                         double hc=(2.0/c)*sqrt(fabs(s*(s-a)*(s-b)*(s-c)));
 
                         if (hc<minError)
                         {
                             removeIndex = j;
                             minError = hc;
                             pointFound = true;
                         }
                     }
                 }
             }
 
             if (pointFound)
             {
                 removedPoints[removeIndex] = 1;
                 numRemovedPoints++;
             }
         }
 
         for (int j=0; j<numPoints; j++)
         {
             if (removedPoints[j]<=0)
             {
                 double cand[3];
                 points->GetPoint(j, cand);
                 vtkIdType id = vtkNewPoints->InsertNextPoint(cand);
                 container->GetPointIds()->InsertNextId(id);
             }
         }
 
         vtkNewCells->InsertNextCell(container);
     }
 
     if (vtkNewCells->GetNumberOfCells()>0)
     {
         MITK_INFO << "Removed points: " << numRemovedPoints;
         m_FiberPolyData = vtkSmartPointer<vtkPolyData>::New();
         m_FiberPolyData->SetPoints(vtkNewPoints);
         m_FiberPolyData->SetLines(vtkNewCells);
         this->SetFiberPolyData(m_FiberPolyData, true);
     }
 }
 
 // reapply selected colorcoding in case polydata structure has changed
 bool mitk::FiberBundleX::Equals(mitk::FiberBundleX* fib, double eps)
 {
     if (fib==NULL)
     {
         MITK_INFO << "Reference bundle is NULL!";
         return false;
     }
 
     if (m_NumFibers!=fib->GetNumFibers())
     {
         MITK_INFO << "Unequal number of fibers!";
         MITK_INFO << m_NumFibers << " vs. " << fib->GetNumFibers();
         return false;
     }
 
     for (int i=0; i<m_NumFibers; i++)
     {
         vtkCell* cell = m_FiberPolyData->GetCell(i);
         int numPoints = cell->GetNumberOfPoints();
         vtkPoints* points = cell->GetPoints();
 
         vtkCell* cell2 = fib->GetFiberPolyData()->GetCell(i);
         int numPoints2 = cell2->GetNumberOfPoints();
         vtkPoints* points2 = cell2->GetPoints();
 
         if (numPoints2!=numPoints)
         {
             MITK_INFO << "Unequal number of points in fiber " << i << "!";
             MITK_INFO << numPoints2 << " vs. " << numPoints;
             return false;
         }
 
         for (int j=0; j<numPoints; j++)
         {
             double* p1 = points->GetPoint(j);
             double* p2 = points2->GetPoint(j);
             if (fabs(p1[0]-p2[0])>eps || fabs(p1[1]-p2[1])>eps || fabs(p1[2]-p2[2])>eps)
             {
                 MITK_INFO << "Unequal points in fiber " << i << " at position " << j << "!";
                 MITK_INFO << "p1: " << p1[0] << ", " << p1[1] << ", " << p1[2];
                 MITK_INFO << "p2: " << p2[0] << ", " << p2[1] << ", " << p2[2];
                 return false;
             }
         }
     }
 
     return true;
 }
 
 /* ESSENTIAL IMPLEMENTATION OF SUPERCLASS METHODS */
 void mitk::FiberBundleX::UpdateOutputInformation()
 {
 
 }
 void mitk::FiberBundleX::SetRequestedRegionToLargestPossibleRegion()
 {
 
 }
 bool mitk::FiberBundleX::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
     return false;
 }
 bool mitk::FiberBundleX::VerifyRequestedRegion()
 {
     return true;
 }
 void mitk::FiberBundleX::SetRequestedRegion(const itk::DataObject* )
 {
 
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
index cba094da2e..bf9461aaeb 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingView.cpp
@@ -1,1486 +1,1488 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkFiberProcessingView.h"
 #include <QmitkStdMultiWidget.h>
 
 // Qt
 #include <QMessageBox>
 
 // MITK
 #include <mitkNodePredicateProperty.h>
 #include <mitkImageCast.h>
 #include <mitkPointSet.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkImageAccessByItk.h>
 #include <mitkDataNodeObject.h>
 #include <mitkTensorImage.h>
 #include "usModuleRegistry.h"
 #include <itkFiberCurvatureFilter.h>
 
 #include "mitkNodePredicateDataType.h"
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateOr.h>
 
 // ITK
 #include <itkResampleImageFilter.h>
 #include <itkGaussianInterpolateImageFunction.h>
 #include <itkImageRegionIteratorWithIndex.h>
 #include <itkTractsToFiberEndingsImageFilter.h>
 #include <itkTractDensityImageFilter.h>
 #include <itkImageRegion.h>
 #include <itkTractsToRgbaImageFilter.h>
 
 #define _USE_MATH_DEFINES
 #include <math.h>
 
 
 const std::string QmitkFiberProcessingView::VIEW_ID = "org.mitk.views.fiberprocessing";
 const std::string id_DataManager = "org.mitk.views.datamanager";
 using namespace mitk;
 
 QmitkFiberProcessingView::QmitkFiberProcessingView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
     , m_CircleCounter(0)
     , m_PolygonCounter(0)
     , m_UpsamplingFactor(1)
 {
 
 }
 
 // Destructor
 QmitkFiberProcessingView::~QmitkFiberProcessingView()
 {
 
 }
 
 void QmitkFiberProcessingView::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::QmitkFiberProcessingViewControls;
         m_Controls->setupUi( parent );
 
         connect( m_Controls->m_CircleButton, SIGNAL( clicked() ), this, SLOT( OnDrawCircle() ) );
         connect( m_Controls->m_PolygonButton, SIGNAL( clicked() ), this, SLOT( OnDrawPolygon() ) );
         connect(m_Controls->PFCompoANDButton, SIGNAL(clicked()), this, SLOT(GenerateAndComposite()) );
         connect(m_Controls->PFCompoORButton, SIGNAL(clicked()), this, SLOT(GenerateOrComposite()) );
         connect(m_Controls->PFCompoNOTButton, SIGNAL(clicked()), this, SLOT(GenerateNotComposite()) );
         connect(m_Controls->m_GenerateRoiImage, SIGNAL(clicked()), this, SLOT(GenerateRoiImage()) );
 
         connect(m_Controls->m_JoinBundles, SIGNAL(clicked()), this, SLOT(JoinBundles()) );
         connect(m_Controls->m_SubstractBundles, SIGNAL(clicked()), this, SLOT(SubstractBundles()) );
 
         connect(m_Controls->m_ExtractFibersButton, SIGNAL(clicked()), this, SLOT(Extract()));
         connect(m_Controls->m_RemoveButton, SIGNAL(clicked()), this, SLOT(Remove()));
         connect(m_Controls->m_ModifyButton, SIGNAL(clicked()), this, SLOT(Modify()));
 
         connect(m_Controls->m_ExtractionMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_RemovalMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
         connect(m_Controls->m_ModificationMethodBox, SIGNAL(currentIndexChanged(int)), this, SLOT(UpdateGui()));
 
         m_Controls->m_ColorMapBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
         mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
         mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
         mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
         isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
         mitk::NodePredicateNot::Pointer noDiffusionImage = mitk::NodePredicateNot::New(isDiffusionImage);
         mitk::NodePredicateAnd::Pointer finalPredicate = mitk::NodePredicateAnd::New(isMitkImage, noDiffusionImage);
         m_Controls->m_ColorMapBox->SetPredicate(finalPredicate);
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::Modify()
 {
     switch (m_Controls->m_ModificationMethodBox->currentIndex())
     {
     case 0:
     {
         ResampleSelectedBundles();
         break;
     }
     case 1:
     {
         CompressSelectedBundles();
         break;
     }
     case 2:
     {
         DoImageColorCoding();
         break;
     }
     case 3:
     {
         MirrorFibers();
         break;
     }
     case 4:
     {
         WeightFibers();
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::WeightFibers()
 {
     float weight = this->m_Controls->m_BundleWeightBox->value();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->SetFiberWeights(weight);
     }
 }
 
 void QmitkFiberProcessingView::Remove()
 {
     switch (m_Controls->m_RemovalMethodBox->currentIndex())
     {
     case 0:
     {
         RemoveDir();
         break;
     }
     case 1:
     {
         PruneBundle();
         break;
     }
     case 2:
     {
         ApplyCurvatureThreshold();
         break;
     }
     case 3:
     {
         RemoveWithMask(false);
         break;
     }
     case 4:
     {
         RemoveWithMask(true);
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::Extract()
 {
     switch (m_Controls->m_ExtractionMethodBox->currentIndex())
     {
     case 0:
     {
         ExtractWithPlanarFigure();
         break;
     }
     case 1:
     {
         switch (m_Controls->m_ExtractionBoxMask->currentIndex())
         {
         {
         case 0:
             ExtractWithMask(true, false);
             break;
         }
         {
         case 1:
             ExtractWithMask(true, true);
             break;
         }
         {
         case 2:
             ExtractWithMask(false, false);
             break;
         }
         {
         case 3:
             ExtractWithMask(false, true);
             break;
         }
         }
         break;
     }
     }
 }
 
 void QmitkFiberProcessingView::PruneBundle()
 {
     int minLength = this->m_Controls->m_PruneFibersMinBox->value();
     int maxLength = this->m_Controls->m_PruneFibersMaxBox->value();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         if (!fib->RemoveShortFibers(minLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
         else if (!fib->RemoveLongFibers(maxLength))
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::ApplyCurvatureThreshold()
 {
     int angle = this->m_Controls->m_CurvSpinBox->value();
     int dist = this->m_Controls->m_CurvDistanceSpinBox->value();
     std::vector< DataNode::Pointer > nodes = m_SelectedFB;
     for (int i=0; i<nodes.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(nodes.at(i)->GetData());
 
         itk::FiberCurvatureFilter::Pointer filter = itk::FiberCurvatureFilter::New();
         filter->SetInputFiberBundle(fib);
         filter->SetAngularDeviation(angle);
         filter->SetDistance(dist);
         filter->SetRemoveFibers(m_Controls->m_RemoveCurvedFibersBox->isChecked());
         filter->Update();
         mitk::FiberBundleX::Pointer newFib = filter->GetOutputFiberBundle();
         if (newFib->GetNumFibers()>0)
         {
             nodes.at(i)->SetVisibility(false);
             DataNode::Pointer newNode = DataNode::New();
             newNode->SetData(newFib);
             newNode->SetName(nodes.at(i)->GetName()+"_Curvature");
             GetDefaultDataStorage()->Add(newNode, nodes.at(i));
         }
         else
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
 //        if (!fib->ApplyCurvatureThreshold(mm, this->m_Controls->m_RemoveCurvedFibersBox->isChecked()))
 //            QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveDir()
 {
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         vnl_vector_fixed<double,3> dir;
         dir[0] = m_Controls->m_ExtractDirX->value();
         dir[1] = m_Controls->m_ExtractDirY->value();
         dir[2] = m_Controls->m_ExtractDirZ->value();
         fib->RemoveDir(dir,cos((float)m_Controls->m_ExtractAngle->value()*M_PI/180));
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::RemoveWithMask(bool removeInside)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->RemoveFibersOutside(mask, removeInside);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
         if (removeInside)
             name += "_Inside";
         else
             name += "_Outside";
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::ExtractWithMask(bool onlyEnds, bool invert)
 {
     if (m_MaskImageNode.IsNull())
         return;
 
     mitk::Image::Pointer mitkMask = dynamic_cast<mitk::Image*>(m_MaskImageNode->GetData());
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         QString name(m_SelectedFB.at(i)->GetName().c_str());
 
         itkUCharImageType::Pointer mask = itkUCharImageType::New();
         mitk::CastToItkImage(mitkMask, mask);
         mitk::FiberBundleX::Pointer newFib = fib->ExtractFiberSubset(mask, !onlyEnds, invert);
         if (newFib->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         DataNode::Pointer newNode = DataNode::New();
         newNode->SetData(newFib);
 
         if (invert)
         {
             name += "_not";
 
             if (onlyEnds)
                 name += "-ending-in-mask";
             else
                 name += "-passing-mask";
         }
         else
         {
             if (onlyEnds)
                 name += "_ending-in-mask";
             else
                 name += "_passing-mask";
         }
 
         newNode->SetName(name.toStdString());
         GetDefaultDataStorage()->Add(newNode);
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 }
 
 void QmitkFiberProcessingView::GenerateRoiImage()
 {
     if (m_SelectedPF.empty())
         return;
 
     mitk::BaseGeometry::Pointer geometry;
     if (!m_SelectedFB.empty())
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.front()->GetData());
         geometry = fib->GetGeometry();
     }
     else if (m_SelectedImage)
         geometry = m_SelectedImage->GetGeometry();
     else
         return;
 
     itk::Vector<double,3> spacing = geometry->GetSpacing();
     spacing /= m_UpsamplingFactor;
 
     mitk::Point3D newOrigin = geometry->GetOrigin();
     mitk::Geometry3D::BoundsArrayType bounds = geometry->GetBounds();
     newOrigin[0] += bounds.GetElement(0);
     newOrigin[1] += bounds.GetElement(2);
     newOrigin[2] += bounds.GetElement(4);
 
     itk::Matrix<double, 3, 3> direction;
     itk::ImageRegion<3> imageRegion;
     for (int i=0; i<3; i++)
         for (int j=0; j<3; j++)
             direction[j][i] = geometry->GetMatrixColumn(i)[j]/spacing[j];
     imageRegion.SetSize(0, geometry->GetExtent(0)*m_UpsamplingFactor);
     imageRegion.SetSize(1, geometry->GetExtent(1)*m_UpsamplingFactor);
     imageRegion.SetSize(2, geometry->GetExtent(2)*m_UpsamplingFactor);
 
     m_PlanarFigureImage = itkUCharImageType::New();
     m_PlanarFigureImage->SetSpacing( spacing );   // Set the image spacing
     m_PlanarFigureImage->SetOrigin( newOrigin );     // Set the image origin
     m_PlanarFigureImage->SetDirection( direction );  // Set the image direction
     m_PlanarFigureImage->SetRegions( imageRegion );
     m_PlanarFigureImage->Allocate();
     m_PlanarFigureImage->FillBuffer( 0 );
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
 
     std::string name = m_SelectedPF.at(0)->GetName();
     WritePfToImage(m_SelectedPF.at(0), tmpImage);
     for (unsigned int i=1; i<m_SelectedPF.size(); i++)
     {
         name += "+";
         name += m_SelectedPF.at(i)->GetName();
         WritePfToImage(m_SelectedPF.at(i), tmpImage);
     }
 
     DataNode::Pointer node = DataNode::New();
     tmpImage = Image::New();
     tmpImage->InitializeByItk(m_PlanarFigureImage.GetPointer());
     tmpImage->SetVolume(m_PlanarFigureImage->GetBufferPointer());
     node->SetData(tmpImage);
     node->SetName(name);
     this->GetDefaultDataStorage()->Add(node);
 }
 
 void QmitkFiberProcessingView::WritePfToImage(mitk::DataNode::Pointer node, mitk::Image* image)
 {
     if (dynamic_cast<mitk::PlanarFigure*>(node->GetData()))
     {
         m_PlanarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
         AccessFixedDimensionByItk_2(
                     image,
                     InternalReorientImagePlane, 3,
                     m_PlanarFigure->GetGeometry(), -1);
 
         AccessFixedDimensionByItk_2(
                     m_InternalImage,
                     InternalCalculateMaskFromPlanarFigure,
                     3, 2, node->GetName() );
     }
     else if (dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()))
     {
         mitk::PlanarFigureComposite* pfc = dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData());
         for (int j=0; j<pfc->getNumberOfChildren(); j++)
         {
             WritePfToImage(pfc->getDataNodeAt(j), image);
         }
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalReorientImagePlane( const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* planegeo3D, int additionalIndex )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::Image< float, VImageDimension > FloatImageType;
 
     typedef itk::ResampleImageFilter<ImageType, FloatImageType, double> ResamplerType;
     typename ResamplerType::Pointer resampler = ResamplerType::New();
 
     mitk::PlaneGeometry* planegeo = dynamic_cast<mitk::PlaneGeometry*>(planegeo3D);
 
     float upsamp = m_UpsamplingFactor;
     float gausssigma = 0.5;
 
     // Spacing
     typename ResamplerType::SpacingType spacing = planegeo->GetSpacing();
     spacing[0] = image->GetSpacing()[0] / upsamp;
     spacing[1] = image->GetSpacing()[1] / upsamp;
     spacing[2] = image->GetSpacing()[2];
     resampler->SetOutputSpacing( spacing );
 
     // Size
     typename ResamplerType::SizeType size;
     size[0] = planegeo->GetExtentInMM(0) / spacing[0];
     size[1] = planegeo->GetExtentInMM(1) / spacing[1];
     size[2] = 1;
     resampler->SetSize( size );
 
     // Origin
     typename mitk::Point3D orig = planegeo->GetOrigin();
     typename mitk::Point3D corrorig;
     planegeo3D->WorldToIndex(orig,corrorig);
     corrorig[0] += 0.5/upsamp;
     corrorig[1] += 0.5/upsamp;
     corrorig[2] += 0;
     planegeo3D->IndexToWorld(corrorig,corrorig);
     resampler->SetOutputOrigin(corrorig );
 
     // Direction
     typename ResamplerType::DirectionType direction;
     typename mitk::AffineTransform3D::MatrixType matrix = planegeo->GetIndexToWorldTransform()->GetMatrix();
     for(int c=0; c<matrix.ColumnDimensions; c++)
     {
         double sum = 0;
         for(int r=0; r<matrix.RowDimensions; r++)
             sum += matrix(r,c)*matrix(r,c);
         for(int r=0; r<matrix.RowDimensions; r++)
             direction(r,c) = matrix(r,c)/sqrt(sum);
     }
     resampler->SetOutputDirection( direction );
 
     // Gaussian interpolation
     if(gausssigma != 0)
     {
         double sigma[3];
         for( unsigned int d = 0; d < 3; d++ )
             sigma[d] = gausssigma * image->GetSpacing()[d];
         double alpha = 2.0;
         typedef itk::GaussianInterpolateImageFunction<ImageType, double> GaussianInterpolatorType;
         typename GaussianInterpolatorType::Pointer interpolator = GaussianInterpolatorType::New();
         interpolator->SetInputImage( image );
         interpolator->SetParameters( sigma, alpha );
         resampler->SetInterpolator( interpolator );
     }
     else
     {
         typedef typename itk::LinearInterpolateImageFunction<ImageType, double> InterpolatorType;
         typename InterpolatorType::Pointer interpolator = InterpolatorType::New();
         interpolator->SetInputImage( image );
         resampler->SetInterpolator( interpolator );
     }
 
     resampler->SetInput( image );
     resampler->SetDefaultPixelValue(0);
     resampler->Update();
 
     if(additionalIndex < 0)
     {
         this->m_InternalImage = mitk::Image::New();
         this->m_InternalImage->InitializeByItk( resampler->GetOutput() );
         this->m_InternalImage->SetVolume( resampler->GetOutput()->GetBufferPointer() );
     }
 }
 
 template < typename TPixel, unsigned int VImageDimension >
 void QmitkFiberProcessingView::InternalCalculateMaskFromPlanarFigure( itk::Image< TPixel, VImageDimension > *image, unsigned int axis, std::string )
 {
     typedef itk::Image< TPixel, VImageDimension > ImageType;
     typedef itk::CastImageFilter< ImageType, itkUCharImageType > CastFilterType;
 
     // Generate mask image as new image with same header as input image and
     // initialize with "1".
     itkUCharImageType::Pointer newMaskImage = itkUCharImageType::New();
     newMaskImage->SetSpacing( image->GetSpacing() );   // Set the image spacing
     newMaskImage->SetOrigin( image->GetOrigin() );     // Set the image origin
     newMaskImage->SetDirection( image->GetDirection() );  // Set the image direction
     newMaskImage->SetRegions( image->GetLargestPossibleRegion() );
     newMaskImage->Allocate();
     newMaskImage->FillBuffer( 1 );
 
     // Generate VTK polygon from (closed) PlanarFigure polyline
     // (The polyline points are shifted by -0.5 in z-direction to make sure
     // that the extrusion filter, which afterwards elevates all points by +0.5
     // in z-direction, creates a 3D object which is cut by the the plane z=0)
     const PlaneGeometry *planarFigurePlaneGeometry = m_PlanarFigure->GetPlaneGeometry();
     const PlanarFigure::PolyLineType planarFigurePolyline = m_PlanarFigure->GetPolyLine( 0 );
     const BaseGeometry *imageGeometry3D = m_InternalImage->GetGeometry( 0 );
 
     vtkPolyData *polyline = vtkPolyData::New();
     polyline->Allocate( 1, 1 );
 
     // Determine x- and y-dimensions depending on principal axis
     int i0, i1;
     switch ( axis )
     {
     case 0:
         i0 = 1;
         i1 = 2;
         break;
     case 1:
         i0 = 0;
         i1 = 2;
         break;
     case 2:
     default:
         i0 = 0;
         i1 = 1;
         break;
     }
 
     // Create VTK polydata object of polyline contour
     vtkPoints *points = vtkPoints::New();
     PlanarFigure::PolyLineType::const_iterator it;
     unsigned int numberOfPoints = 0;
 
     for ( it = planarFigurePolyline.begin(); it != planarFigurePolyline.end(); ++it )
     {
         Point3D point3D;
 
         // Convert 2D point back to the local index coordinates of the selected image
         Point2D point2D = *it;
         planarFigurePlaneGeometry->WorldToIndex(point2D, point2D);
         point2D[0] -= 0.5/m_UpsamplingFactor;
         point2D[1] -= 0.5/m_UpsamplingFactor;
         planarFigurePlaneGeometry->IndexToWorld(point2D, point2D);
         planarFigurePlaneGeometry->Map( point2D, point3D );
 
         // Polygons (partially) outside of the image bounds can not be processed further due to a bug in vtkPolyDataToImageStencil
         if ( !imageGeometry3D->IsInside( point3D ) )
         {
             float bounds[2] = {0,0};
             bounds[0] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i0);
             bounds[1] =
                     this->m_InternalImage->GetLargestPossibleRegion().GetSize().GetElement(i1);
 
             imageGeometry3D->WorldToIndex( point3D, point3D );
 
             if (point3D[i0]<0)
                 point3D[i0] = 0.0;
             else if (point3D[i0]>bounds[0])
                 point3D[i0] = bounds[0]-0.001;
 
             if (point3D[i1]<0)
                 point3D[i1] = 0.0;
             else if (point3D[i1]>bounds[1])
                 point3D[i1] = bounds[1]-0.001;
 
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
         else
         {
             imageGeometry3D->WorldToIndex( point3D, point3D );
             // Add point to polyline array
             points->InsertNextPoint( point3D[i0], point3D[i1], -0.5 );
             numberOfPoints++;
         }
     }
     polyline->SetPoints( points );
     points->Delete();
 
     vtkIdType *ptIds = new vtkIdType[numberOfPoints];
     for ( vtkIdType i = 0; i < numberOfPoints; ++i )
         ptIds[i] = i;
     polyline->InsertNextCell( VTK_POLY_LINE, numberOfPoints, ptIds );
 
     // Extrude the generated contour polygon
     vtkLinearExtrusionFilter *extrudeFilter = vtkLinearExtrusionFilter::New();
     extrudeFilter->SetInputData( polyline );
     extrudeFilter->SetScaleFactor( 1 );
     extrudeFilter->SetExtrusionTypeToNormalExtrusion();
     extrudeFilter->SetVector( 0.0, 0.0, 1.0 );
 
     // Make a stencil from the extruded polygon
     vtkPolyDataToImageStencil *polyDataToImageStencil = vtkPolyDataToImageStencil::New();
     polyDataToImageStencil->SetInputConnection( extrudeFilter->GetOutputPort() );
 
     // Export from ITK to VTK (to use a VTK filter)
     typedef itk::VTKImageImport< itkUCharImageType > ImageImportType;
     typedef itk::VTKImageExport< itkUCharImageType > ImageExportType;
 
     typename ImageExportType::Pointer itkExporter = ImageExportType::New();
     itkExporter->SetInput( newMaskImage );
 
     vtkImageImport *vtkImporter = vtkImageImport::New();
     this->ConnectPipelines( itkExporter, vtkImporter );
     vtkImporter->Update();
 
     // Apply the generated image stencil to the input image
     vtkImageStencil *imageStencilFilter = vtkImageStencil::New();
     imageStencilFilter->SetInputConnection( vtkImporter->GetOutputPort() );
     imageStencilFilter->SetStencilConnection(polyDataToImageStencil->GetOutputPort() );
     imageStencilFilter->ReverseStencilOff();
     imageStencilFilter->SetBackgroundValue( 0 );
     imageStencilFilter->Update();
 
     // Export from VTK back to ITK
     vtkImageExport *vtkExporter = vtkImageExport::New();
     vtkExporter->SetInputConnection( imageStencilFilter->GetOutputPort() );
     vtkExporter->Update();
 
     typename ImageImportType::Pointer itkImporter = ImageImportType::New();
     this->ConnectPipelines( vtkExporter, itkImporter );
     itkImporter->Update();
 
     // calculate cropping bounding box
     m_InternalImageMask3D = itkImporter->GetOutput();
     m_InternalImageMask3D->SetDirection(image->GetDirection());
 
     itk::ImageRegionConstIterator<itkUCharImageType>
             itmask(m_InternalImageMask3D, m_InternalImageMask3D->GetLargestPossibleRegion());
     itk::ImageRegionIterator<ImageType>
             itimage(image, image->GetLargestPossibleRegion());
 
     itmask.GoToBegin();
     itimage.GoToBegin();
 
     typename ImageType::SizeType lowersize = {{9999999999,9999999999,9999999999}};
     typename ImageType::SizeType uppersize = {{0,0,0}};
     while( !itmask.IsAtEnd() )
     {
         if(itmask.Get() == 0)
             itimage.Set(0);
         else
         {
             typename ImageType::IndexType index = itimage.GetIndex();
             typename ImageType::SizeType signedindex;
             signedindex[0] = index[0];
             signedindex[1] = index[1];
             signedindex[2] = index[2];
 
             lowersize[0] = signedindex[0] < lowersize[0] ? signedindex[0] : lowersize[0];
             lowersize[1] = signedindex[1] < lowersize[1] ? signedindex[1] : lowersize[1];
             lowersize[2] = signedindex[2] < lowersize[2] ? signedindex[2] : lowersize[2];
 
             uppersize[0] = signedindex[0] > uppersize[0] ? signedindex[0] : uppersize[0];
             uppersize[1] = signedindex[1] > uppersize[1] ? signedindex[1] : uppersize[1];
             uppersize[2] = signedindex[2] > uppersize[2] ? signedindex[2] : uppersize[2];
         }
 
         ++itmask;
         ++itimage;
     }
 
     typename ImageType::IndexType index;
     index[0] = lowersize[0];
     index[1] = lowersize[1];
     index[2] = lowersize[2];
 
     typename ImageType::SizeType size;
     size[0] = uppersize[0] - lowersize[0] + 1;
     size[1] = uppersize[1] - lowersize[1] + 1;
     size[2] = uppersize[2] - lowersize[2] + 1;
 
     itk::ImageRegion<3> cropRegion = itk::ImageRegion<3>(index, size);
 
     // crop internal mask
     typedef itk::RegionOfInterestImageFilter< itkUCharImageType, itkUCharImageType > ROIMaskFilterType;
     typename ROIMaskFilterType::Pointer roi2 = ROIMaskFilterType::New();
     roi2->SetRegionOfInterest(cropRegion);
     roi2->SetInput(m_InternalImageMask3D);
     roi2->Update();
     m_InternalImageMask3D = roi2->GetOutput();
 
     Image::Pointer tmpImage = Image::New();
     tmpImage->InitializeByItk(m_InternalImageMask3D.GetPointer());
     tmpImage->SetVolume(m_InternalImageMask3D->GetBufferPointer());
 
     Image::Pointer tmpImage2 = Image::New();
     tmpImage2->InitializeByItk(m_PlanarFigureImage.GetPointer());
     const BaseGeometry *pfImageGeometry3D = tmpImage2->GetGeometry( 0 );
 
     const BaseGeometry *intImageGeometry3D = tmpImage->GetGeometry( 0 );
 
     typedef itk::ImageRegionIteratorWithIndex<itkUCharImageType> IteratorType;
     IteratorType imageIterator (m_InternalImageMask3D, m_InternalImageMask3D->GetRequestedRegion());
     imageIterator.GoToBegin();
     while ( !imageIterator.IsAtEnd() )
     {
         unsigned char val = imageIterator.Value();
         if (val>0)
         {
             itk::Index<3> index = imageIterator.GetIndex();
             Point3D point;
             point[0] = index[0];
             point[1] = index[1];
             point[2] = index[2];
 
             intImageGeometry3D->IndexToWorld(point, point);
             pfImageGeometry3D->WorldToIndex(point, point);
 
             point[i0] += 0.5;
             point[i1] += 0.5;
 
             index[0] = point[0];
             index[1] = point[1];
             index[2] = point[2];
 
             if (pfImageGeometry3D->IsIndexInside(index))
                 m_PlanarFigureImage->SetPixel(index, 1);
         }
         ++imageIterator;
     }
 
     // Clean up VTK objects
     polyline->Delete();
     extrudeFilter->Delete();
     polyDataToImageStencil->Delete();
     vtkImporter->Delete();
     imageStencilFilter->Delete();
     //vtkExporter->Delete(); // TODO: crashes when outcommented; memory leak??
     delete[] ptIds;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 }
 
 void QmitkFiberProcessingView::StdMultiWidgetNotAvailable()
 {
     m_MultiWidget = NULL;
 }
 
 void QmitkFiberProcessingView::UpdateGui()
 {
     m_Controls->m_FibLabel->setText("<font color='red'>mandatory</font>");
     m_Controls->m_PfLabel->setText("<font color='grey'>needed for extraction</font>");
     m_Controls->m_InputData->setTitle("Please Select Input Data");
 
     m_Controls->m_RemoveButton->setEnabled(false);
 
     m_Controls->m_PlanarFigureButtonsFrame->setEnabled(false);
     m_Controls->PFCompoANDButton->setEnabled(false);
     m_Controls->PFCompoORButton->setEnabled(false);
     m_Controls->PFCompoNOTButton->setEnabled(false);
 
     m_Controls->m_GenerateRoiImage->setEnabled(false);
     m_Controls->m_ExtractFibersButton->setEnabled(false);
     m_Controls->m_ModifyButton->setEnabled(false);
 
     m_Controls->m_JoinBundles->setEnabled(false);
     m_Controls->m_SubstractBundles->setEnabled(false);
 
     // disable alle frames
     m_Controls->m_BundleWeightFrame->setVisible(false);
     m_Controls->m_ExtractionBoxMask->setVisible(false);
     m_Controls->m_ExtactionFramePF->setVisible(false);
     m_Controls->m_RemoveDirectionFrame->setVisible(false);
     m_Controls->m_RemoveLengthFrame->setVisible(false);
     m_Controls->m_RemoveCurvatureFrame->setVisible(false);
     m_Controls->m_SmoothFibersFrame->setVisible(false);
     m_Controls->m_CompressFibersFrame->setVisible(false);
     m_Controls->m_ColorFibersFrame->setVisible(false);
     m_Controls->m_MirrorFibersFrame->setVisible(false);
 
     bool pfSelected = !m_SelectedPF.empty();
     bool fibSelected = !m_SelectedFB.empty();
     bool multipleFibsSelected = (m_SelectedFB.size()>1);
     bool maskSelected = m_MaskImageNode.IsNotNull();
     bool imageSelected = m_SelectedImage.IsNotNull();
 
     // toggle visibility of elements according to selected method
     switch ( m_Controls->m_ExtractionMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_ExtactionFramePF->setVisible(true);
         break;
     case 1:
         m_Controls->m_ExtractionBoxMask->setVisible(true);
         break;
     }
 
     switch ( m_Controls->m_RemovalMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_RemoveDirectionFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 1:
         m_Controls->m_RemoveLengthFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 2:
         m_Controls->m_RemoveCurvatureFrame->setVisible(true);
         if ( fibSelected )
             m_Controls->m_RemoveButton->setEnabled(true);
         break;
     case 3:
         break;
     case 4:
         break;
     }
 
     switch ( m_Controls->m_ModificationMethodBox->currentIndex() )
     {
     case 0:
         m_Controls->m_SmoothFibersFrame->setVisible(true);
         break;
     case 1:
         m_Controls->m_CompressFibersFrame->setVisible(true);
         break;
     case 2:
         m_Controls->m_ColorFibersFrame->setVisible(true);
         break;
     case 3:
         m_Controls->m_MirrorFibersFrame->setVisible(true);
         break;
     case 4:
         m_Controls->m_BundleWeightFrame->setVisible(true);
     }
 
     // are fiber bundles selected?
     if ( fibSelected )
     {
         m_Controls->m_ModifyButton->setEnabled(true);
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
         m_Controls->m_FibLabel->setText(QString(m_SelectedFB.at(0)->GetName().c_str()));
 
         // one bundle and one planar figure needed to extract fibers
         if (pfSelected)
         {
             m_Controls->m_InputData->setTitle("Input Data");
             m_Controls->m_PfLabel->setText(QString(m_SelectedPF.at(0)->GetName().c_str()));
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
 
         // more than two bundles needed to join/subtract
         if (multipleFibsSelected)
         {
             m_Controls->m_FibLabel->setText("multiple bundles selected");
 
             m_Controls->m_JoinBundles->setEnabled(true);
             m_Controls->m_SubstractBundles->setEnabled(true);
         }
 
         if (maskSelected)
         {
             m_Controls->m_RemoveButton->setEnabled(true);
             m_Controls->m_ExtractFibersButton->setEnabled(true);
         }
     }
 
     // are planar figures selected?
     if (pfSelected)
     {
         if ( fibSelected || m_SelectedImage.IsNotNull())
             m_Controls->m_GenerateRoiImage->setEnabled(true);
 
         if (m_SelectedPF.size() > 1)
         {
             m_Controls->PFCompoANDButton->setEnabled(true);
             m_Controls->PFCompoORButton->setEnabled(true);
         }
         else
             m_Controls->PFCompoNOTButton->setEnabled(true);
     }
 
     // is image selected
     if (imageSelected || maskSelected)
     {
         m_Controls->m_PlanarFigureButtonsFrame->setEnabled(true);
     }
 }
 
 void QmitkFiberProcessingView::NodeRemoved(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::NodeAdded(const mitk::DataNode* node)
 {
     std::vector<mitk::DataNode*> nodes;
     OnSelectionChanged(nodes);
 }
 
 void QmitkFiberProcessingView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     //reset existing Vectors containing FiberBundles and PlanarFigures from a previous selection
     m_SelectedFB.clear();
     m_SelectedPF.clear();
     m_SelectedSurfaces.clear();
     m_SelectedImage = NULL;
     m_MaskImageNode = NULL;
 
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
         if ( dynamic_cast<mitk::FiberBundleX*>(node->GetData()) )
             m_SelectedFB.push_back(node);
         else if (dynamic_cast<mitk::PlanarPolygon*>(node->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(node->GetData()) || dynamic_cast<mitk::PlanarCircle*>(node->GetData()))
             m_SelectedPF.push_back(node);
         else if (dynamic_cast<mitk::Image*>(node->GetData()))
         {
             m_SelectedImage = dynamic_cast<mitk::Image*>(node->GetData());
             bool isBinary = false;
             node->GetPropertyValue<bool>("binary", isBinary);
             if (isBinary)
                 m_MaskImageNode = node;
         }
         else if (dynamic_cast<mitk::Surface*>(node->GetData()))
             m_SelectedSurfaces.push_back(dynamic_cast<mitk::Surface*>(node->GetData()));
     }
 
     if (m_SelectedFB.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::FiberBundleX*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedFB.clear();
                     m_SelectedFB.push_back(nodes->at(i));
                 }
             }
     }
 
     if (m_SelectedPF.empty())
     {
         int maxLayer = 0;
         itk::VectorContainer<unsigned int, mitk::DataNode::Pointer>::ConstPointer nodes = this->GetDefaultDataStorage()->GetAll();
         for (unsigned int i=0; i<nodes->Size(); i++)
             if (dynamic_cast<mitk::PlanarPolygon*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarFigureComposite*>(nodes->at(i)->GetData()) || dynamic_cast<mitk::PlanarCircle*>(nodes->at(i)->GetData()))
             {
                 mitk::DataStorage::SetOfObjects::ConstPointer sources = GetDataStorage()->GetSources(nodes->at(i));
                 if (sources->Size()>0)
                     continue;
 
                 int layer = 0;
                 nodes->at(i)->GetPropertyValue("layer", layer);
                 if (layer>=maxLayer)
                 {
                     maxLayer = layer;
                     m_SelectedPF.clear();
                     m_SelectedPF.push_back(nodes->at(i));
                 }
             }
     }
 
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::OnDrawPolygon()
 {
     mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
     figure->ClosedOn();
     this->AddFigureToDataStorage(figure, QString("Polygon%1").arg(++m_PolygonCounter));
 }
 
 void QmitkFiberProcessingView::OnDrawCircle()
 {
     mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
     this->AddFigureToDataStorage(figure, QString("Circle%1").arg(++m_CircleCounter));
 }
 
 void QmitkFiberProcessingView::Activated()
 {
 
 }
 
 void QmitkFiberProcessingView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name, const char *, mitk::BaseProperty* )
 {
     // initialize figure's geometry with empty geometry
     mitk::PlaneGeometry::Pointer emptygeometry = mitk::PlaneGeometry::New();
     figure->SetPlaneGeometry( emptygeometry );
 
     //set desired data to DataNode where Planarfigure is stored
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     newNode->SetName(name.toStdString());
     newNode->SetData(figure);
     newNode->SetBoolProperty("planarfigure.3drendering", true);
 
     mitk::PlanarFigureInteractor::Pointer figureInteractor = dynamic_cast<mitk::PlanarFigureInteractor*>(newNode->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(newNode);
     }
 
     // figure drawn on the topmost layer / image
     GetDataStorage()->Add(newNode );
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::ExtractWithPlanarFigure()
 {
     if ( m_SelectedFB.empty() || m_SelectedPF.empty() ){
         QMessageBox::information( NULL, "Warning", "No fibe bundle selected!");
         return;
     }
 
     std::vector<mitk::DataNode::Pointer> fiberBundles = m_SelectedFB;
     mitk::DataNode::Pointer planarFigure = m_SelectedPF.at(0);
     for (unsigned int i=0; i<fiberBundles.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(fiberBundles.at(i)->GetData());
         mitk::BaseData::Pointer roi = planarFigure->GetData();
 
         mitk::FiberBundleX::Pointer extFB = fib->ExtractFiberSubset(roi);
         if (extFB->GetNumFibers()<=0)
         {
             QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers.");
             continue;
         }
 
         mitk::DataNode::Pointer node;
         node = mitk::DataNode::New();
         node->SetData(extFB);
         QString name(fiberBundles.at(i)->GetName().c_str());
         name += "*";
         //name += planarFigure->GetName().c_str();
         node->SetName(name.toStdString());
         fiberBundles.at(i)->SetVisibility(false);
         GetDataStorage()->Add(node);
     }
 }
 
 void QmitkFiberProcessingView::GenerateAndComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCAnd = mitk::PlanarFigureComposite::New();
     PFCAnd->setOperationType(mitk::PFCOMPOSITION_AND_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCAnd->addPlanarFigure( nodePF->GetData() );
         PFCAnd->addDataNode( nodePF );
         PFCAnd->setDisplayName("AND");
     }
     AddCompositeToDatastorage(PFCAnd);
 }
 
 void QmitkFiberProcessingView::GenerateOrComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCOr = mitk::PlanarFigureComposite::New();
     PFCOr->setOperationType(mitk::PFCOMPOSITION_OR_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCOr->addPlanarFigure( nodePF->GetData() );
         PFCOr->addDataNode( nodePF );
         PFCOr->setDisplayName("OR");
     }
     AddCompositeToDatastorage(PFCOr);
 }
 
 void QmitkFiberProcessingView::GenerateNotComposite()
 {
     mitk::PlanarFigureComposite::Pointer PFCNot = mitk::PlanarFigureComposite::New();
     PFCNot->setOperationType(mitk::PFCOMPOSITION_NOT_OPERATION);
     for( std::vector<mitk::DataNode::Pointer>::iterator it = m_SelectedPF.begin(); it != m_SelectedPF.end(); ++it )
     {
         mitk::DataNode::Pointer nodePF = *it;
         PFCNot->addPlanarFigure( nodePF->GetData() );
         PFCNot->addDataNode( nodePF );
         PFCNot->setDisplayName("NOT");
     }
     AddCompositeToDatastorage(PFCNot);
 }
 
 /* CLEANUP NEEDED */
 void QmitkFiberProcessingView::AddCompositeToDatastorage(mitk::PlanarFigureComposite::Pointer pfc, mitk::DataNode::Pointer parentNode )
 {
     mitk::DataNode::Pointer newPFCNode;
     newPFCNode = mitk::DataNode::New();
     newPFCNode->SetName( pfc->getDisplayName() );
     newPFCNode->SetData(pfc);
 
     switch (pfc->getOperationType()) {
     case 0:
     {
         if (parentNode.IsNotNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( pfcompcast.IsNotNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove savedNode here, cuz otherwise its children will change their position in the dataNodeManager
                 // without having its parent anymore
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 1:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             {
                 // child is of type planar Figure composite
                 // make new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName(  savedPFchildNode->GetName()  ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     case 2:
     {
         if (!parentNode.IsNull())
             GetDataStorage()->Add(newPFCNode, parentNode);
         else
             GetDataStorage()->Add(newPFCNode);
 
         //iterate through its childs
         for(int i=0; i<pfc->getNumberOfChildren(); ++i)
         {
             mitk::BaseData::Pointer tmpPFchild = pfc->getChildAt(i);
             mitk::DataNode::Pointer savedPFchildNode = pfc->getDataNodeAt(i);
 
             mitk::PlanarFigureComposite::Pointer pfcompcast= dynamic_cast<mitk::PlanarFigureComposite*>(tmpPFchild.GetPointer());
             if ( !pfcompcast.IsNull() )
             { // child is of type planar Figure composite
                 // makeRemoveBundle new node of the child, cuz later the child has to be removed of its old position in datamanager
                 // feed new dataNode with information of the savedDataNode, which is gonna be removed soon
                 mitk::DataNode::Pointer newChildPFCNode;
                 newChildPFCNode = mitk::DataNode::New();
                 newChildPFCNode->SetData(tmpPFchild);
                 newChildPFCNode->SetName( savedPFchildNode->GetName() );
                 pfcompcast->setDisplayName( savedPFchildNode->GetName() ); //name might be changed in DataManager by user
 
                 //update inside vector the dataNodePointer
                 pfc->replaceDataNodeAt(i, newChildPFCNode);
 
                 AddCompositeToDatastorage(pfcompcast, newPFCNode); //the current PFCNode becomes the childs parent
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
             }
             else
             {
                 // child is not of type PlanarFigureComposite, so its one of the planarFigures
                 // create new dataNode containing the data of the old dataNode, but position in dataManager will be
                 // modified cuz we re setting a (new) parent.
                 mitk::DataNode::Pointer newPFchildNode = mitk::DataNode::New();
                 newPFchildNode->SetName(savedPFchildNode->GetName() );
                 newPFchildNode->SetData(tmpPFchild);
                 newPFchildNode->SetVisibility(true);
                 newPFchildNode->SetBoolProperty("planarfigure.3drendering", true);
 
                 // replace the dataNode in PFComp DataNodeVector
                 pfc->replaceDataNodeAt(i, newPFchildNode);
 
                 // remove old child position in dataStorage
                 GetDataStorage()->Remove(savedPFchildNode);
 
                 //add new child to datamanager with its new position as child of newPFCNode parent
                 GetDataStorage()->Add(newPFchildNode, newPFCNode);
             }
         }
         break;
     }
     default:
         MITK_DEBUG << "we have an UNDEFINED composition... ERROR" ;
         break;
     }
 
     for(unsigned int i = 0; i < m_SelectedPF.size(); i++)
         m_SelectedPF[i]->SetSelected(false);
 
     newPFCNode->SetSelected(true);
     m_SelectedPF.clear();
     m_SelectedPF.push_back(newPFCNode);
     UpdateGui();
 }
 
 void QmitkFiberProcessingView::JoinBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->AddBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         name += "+"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::SubstractBundles()
 {
     if ( m_SelectedFB.size()<2 ){
         QMessageBox::information( NULL, "Warning", "Select at least two fiber bundles!");
         MITK_WARN("QmitkFiberProcessingView") << "Select at least two fiber bundles!";
         return;
     }
 
     mitk::FiberBundleX::Pointer newBundle = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(0)->GetData());
     m_SelectedFB.at(0)->SetVisibility(false);
     QString name("");
     name += QString(m_SelectedFB.at(0)->GetName().c_str());
     for (unsigned int i=1; i<m_SelectedFB.size(); i++)
     {
         newBundle = newBundle->SubtractBundle(dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData()));
         if (newBundle.IsNull())
             break;
         name += "-"+QString(m_SelectedFB.at(i)->GetName().c_str());
         m_SelectedFB.at(i)->SetVisibility(false);
     }
     if (newBundle.IsNull())
     {
         QMessageBox::information(NULL, "No output generated:", "The resulting fiber bundle contains no fibers. Did you select the fiber bundles in the correct order? X-Y is not equal to Y-X!");
         return;
     }
 
     mitk::DataNode::Pointer fbNode = mitk::DataNode::New();
     fbNode->SetData(newBundle);
     fbNode->SetName(name.toStdString());
     fbNode->SetVisibility(true);
     GetDataStorage()->Add(fbNode);
 }
 
 void QmitkFiberProcessingView::ResampleSelectedBundles()
 {
     double factor = this->m_Controls->m_SmoothFibersBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->ResampleSpline(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::CompressSelectedBundles()
 {
     double factor = this->m_Controls->m_ErrorThresholdBox->value();
     for (unsigned int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->Compress(factor);
     }
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkFiberProcessingView::DoImageColorCoding()
 {
     if (m_Controls->m_ColorMapBox->GetSelectedNode().IsNull())
     {
         QMessageBox::information(NULL, "Bundle coloring aborted:", "No image providing the scalar values for coloring the selected bundle available.");
         return;
     }
 
     for(unsigned int i=0; i<m_SelectedFB.size(); i++ )
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
         fib->ColorFibersByScalarMap(dynamic_cast<mitk::Image*>(m_Controls->m_ColorMapBox->GetSelectedNode()->GetData()), m_Controls->m_FiberOpacityBox->isChecked());
     }
 
     if(m_MultiWidget)
         m_MultiWidget->RequestUpdate();
 }
 
 
 void QmitkFiberProcessingView::MirrorFibers()
 {
     unsigned int axis = this->m_Controls->m_MirrorFibersBox->currentIndex();
     for (int i=0; i<m_SelectedFB.size(); i++)
     {
         mitk::FiberBundleX::Pointer fib = dynamic_cast<mitk::FiberBundleX*>(m_SelectedFB.at(i)->GetData());
+        if (m_SelectedImage.IsNotNull())
+            fib->SetReferenceGeometry(m_SelectedImage->GetGeometry());
         fib->MirrorFibers(axis);
     }
 
     if (m_SelectedSurfaces.size()>0)
     {
         for (int i=0; i<m_SelectedSurfaces.size(); i++)
         {
             mitk::Surface::Pointer surf = m_SelectedSurfaces.at(i);
             vtkSmartPointer<vtkPolyData> poly = surf->GetVtkPolyData();
             vtkSmartPointer<vtkPoints> vtkNewPoints = vtkSmartPointer<vtkPoints>::New();
 
             for (int i=0; i<poly->GetNumberOfPoints(); i++)
             {
                 double* point = poly->GetPoint(i);
                 point[axis] *= -1;
                 vtkNewPoints->InsertNextPoint(point);
             }
             poly->SetPoints(vtkNewPoints);
             surf->CalculateBoundingBox();
         }
     }
 
     RenderingManager::GetInstance()->RequestUpdateAll();
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingViewControls.ui
index 4127bda448..4e21fead9b 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberProcessingViewControls.ui
@@ -1,1320 +1,1320 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberProcessingViewControls</class>
  <widget class="QWidget" name="QmitkFiberProcessingViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>386</width>
     <height>540</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_3">
    <item row="1" column="0">
     <widget class="QToolBox" name="toolBoxx">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="page">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>355</width>
         <height>302</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Extraction</string>
       </attribute>
       <attribute name="toolTip">
        <string>Extract a fiber subset from the selected fiber bundle using manually placed planar figures as waypoints or binary regions of interest.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_14">
        <item row="5" column="0">
         <widget class="QCommandLinkButton" name="m_ExtractFibersButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Extract fibers passing through selected ROI or composite ROI. Select ROI and fiber bundle to execute.</string>
          </property>
          <property name="text">
           <string>Extract</string>
          </property>
         </widget>
        </item>
        <item row="6" column="0">
         <spacer name="verticalSpacer_5">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="4" column="0">
         <widget class="QComboBox" name="m_ExtractionBoxMask">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Ending in mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Not ending in mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Passing mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Not passing mask</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ExtactionFramePF">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_8">
           <property name="leftMargin">
            <number>9</number>
           </property>
           <property name="topMargin">
            <number>9</number>
           </property>
           <property name="rightMargin">
            <number>9</number>
           </property>
           <property name="bottomMargin">
            <number>9</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="2" column="0">
            <widget class="QCommandLinkButton" name="m_GenerateRoiImage">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>16777215</height>
              </size>
             </property>
             <property name="font">
              <font>
               <pointsize>11</pointsize>
              </font>
             </property>
             <property name="toolTip">
              <string>Generate a binary image containing all selected ROIs. Select at least one ROI (planar figure) and a reference fiber bundle or image.</string>
             </property>
             <property name="text">
              <string>Generate ROI Image</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QFrame" name="m_PlanarFigureButtonsFrame_2">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>200</width>
               <height>0</height>
              </size>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>60</height>
              </size>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="1">
               <widget class="QCommandLinkButton" name="PFCompoORButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create OR composition with selected ROIs.</string>
                </property>
                <property name="text">
                 <string>OR</string>
                </property>
               </widget>
              </item>
              <item row="0" column="3">
               <spacer name="horizontalSpacer_3">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="2">
               <widget class="QCommandLinkButton" name="PFCompoNOTButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create NOT composition from selected ROI.</string>
                </property>
                <property name="text">
                 <string>NOT</string>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QCommandLinkButton" name="PFCompoANDButton">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="maximumSize">
                 <size>
                  <width>60</width>
                  <height>16777215</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Create AND composition with selected ROIs.</string>
                </property>
                <property name="text">
                 <string>AND</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QFrame" name="m_PlanarFigureButtonsFrame">
             <property name="sizePolicy">
              <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
               <horstretch>0</horstretch>
               <verstretch>0</verstretch>
              </sizepolicy>
             </property>
             <property name="minimumSize">
              <size>
               <width>200</width>
               <height>0</height>
              </size>
             </property>
             <property name="maximumSize">
              <size>
               <width>16777215</width>
               <height>60</height>
              </size>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QPushButton" name="m_CircleButton">
                <property name="maximumSize">
                 <size>
                  <width>30</width>
                  <height>30</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Draw circular ROI. Select reference fiber bundle to execute.</string>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="icon">
                 <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                  <normaloff>:/QmitkDiffusionImaging/circle.png</normaloff>:/QmitkDiffusionImaging/circle.png</iconset>
                </property>
                <property name="iconSize">
                 <size>
                  <width>32</width>
                  <height>32</height>
                 </size>
                </property>
                <property name="checkable">
                 <bool>false</bool>
                </property>
                <property name="flat">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <spacer name="horizontalSpacer">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="1">
               <widget class="QPushButton" name="m_PolygonButton">
                <property name="maximumSize">
                 <size>
                  <width>30</width>
                  <height>30</height>
                 </size>
                </property>
                <property name="toolTip">
                 <string>Draw polygonal ROI. Select reference fiber bundle to execute.</string>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="icon">
                 <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
                  <normaloff>:/QmitkDiffusionImaging/polygon.png</normaloff>:/QmitkDiffusionImaging/polygon.png</iconset>
                </property>
                <property name="iconSize">
                 <size>
                  <width>32</width>
                  <height>32</height>
                 </size>
                </property>
                <property name="checkable">
                 <bool>true</bool>
                </property>
                <property name="flat">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QComboBox" name="m_ExtractionMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Extract using planar figures</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Extract using binary ROI image</string>
           </property>
          </item>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_3">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>270</width>
         <height>380</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Fiber Removal</string>
       </attribute>
       <attribute name="toolTip">
        <string>Remove fibers that satisfy certain criteria from the selected bundle.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="0" column="0">
         <widget class="QComboBox" name="m_RemovalMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Remove fibers in direction</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fibers by length</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fibers by curvature</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fiber parts outside mask</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Remove fiber parts inside mask</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QFrame" name="m_RemoveLengthFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_6">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="2">
            <spacer name="horizontalSpacer_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
           <item row="0" column="1">
            <widget class="QSpinBox" name="m_PruneFibersMinBox">
             <property name="toolTip">
              <string>Minimum fiber length in mm</string>
             </property>
             <property name="minimum">
              <number>0</number>
             </property>
             <property name="maximum">
              <number>999999999</number>
             </property>
             <property name="value">
              <number>20</number>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_9">
             <property name="text">
              <string>Max. Length:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_7">
             <property name="text">
              <string>Min. Length:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="1">
            <widget class="QSpinBox" name="m_PruneFibersMaxBox">
             <property name="toolTip">
              <string>Maximum fiber length in mm</string>
             </property>
             <property name="minimum">
              <number>0</number>
             </property>
             <property name="maximum">
              <number>999999999</number>
             </property>
             <property name="value">
              <number>300</number>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_RemoveDirectionFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_2">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="horizontalSpacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label">
             <property name="text">
              <string>X:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QLabel" name="label_3">
             <property name="text">
              <string>Y:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirX"/>
           </item>
           <item row="1" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirY"/>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="label_4">
             <property name="text">
              <string>Z:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractDirZ"/>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="label_5">
             <property name="text">
              <string>Angle:</string>
             </property>
            </widget>
           </item>
           <item row="3" column="1">
            <widget class="QDoubleSpinBox" name="m_ExtractAngle">
             <property name="toolTip">
              <string>Angular deviation threshold in degree</string>
             </property>
             <property name="decimals">
              <number>1</number>
             </property>
             <property name="maximum">
              <double>90.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>1.000000000000000</double>
             </property>
             <property name="value">
              <double>5.000000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_RemoveCurvatureFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="2" column="2">
            <widget class="QCheckBox" name="m_RemoveCurvedFibersBox">
             <property name="toolTip">
              <string>If unchecked, the fiber exceeding the threshold will be split in two instead of removed.</string>
             </property>
             <property name="text">
              <string>Remove Fiber</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QFrame" name="frame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_12">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="verticalSpacing">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="label_8">
                <property name="text">
                 <string>Max. Angular Deviation:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <spacer name="horizontalSpacer_5">
                <property name="orientation">
                 <enum>Qt::Horizontal</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>40</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_CurvSpinBox">
                <property name="toolTip">
                 <string>Maximum angular deviation in degree</string>
                </property>
                <property name="maximum">
                 <double>180.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>15.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="label_14">
                <property name="text">
                 <string>Distance:</string>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_CurvDistanceSpinBox">
                <property name="toolTip">
                 <string>Distance in mm</string>
                </property>
                <property name="decimals">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <double>999.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>1.000000000000000</double>
                </property>
                <property name="value">
                 <double>10.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QCommandLinkButton" name="m_RemoveButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Remove</string>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_4">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>355</width>
         <height>349</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Bundle Modification</string>
       </attribute>
       <attribute name="toolTip">
        <string>Modify the selected bundle with operations such as fiber resampling, FA coloring, etc.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_10">
        <item row="2" column="0">
         <widget class="QFrame" name="m_CompressFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_15">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_10">
             <property name="text">
              <string>Error threshold in mm:</string>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QDoubleSpinBox" name="m_ErrorThresholdBox">
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>0.100000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QFrame" name="m_MirrorFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_17">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QComboBox" name="m_MirrorFibersBox">
             <item>
              <property name="text">
-              <string>Axial</string>
+              <string>Sagittal</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Sagittal</string>
+              <string>Coronal</string>
              </property>
             </item>
             <item>
              <property name="text">
-              <string>Coronal</string>
+              <string>Axial</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_13">
             <property name="text">
              <string>Select direction:</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="m_ColorFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_16">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_12">
             <property name="text">
              <string>Scalar map:</string>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QmitkDataStorageComboBox" name="m_ColorMapBox"/>
           </item>
           <item row="1" column="0">
            <widget class="QCheckBox" name="m_FiberOpacityBox">
             <property name="toolTip">
              <string>If checked, the image values are not only used to color the fibers but are also used as opaxity values.</string>
             </property>
             <property name="text">
              <string>Values as opacity</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QComboBox" name="m_ModificationMethodBox">
          <property name="sizePolicy">
           <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <item>
           <property name="text">
            <string>Smooth fibers</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Compress fibers</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Color fibers by scalar map (e.g. FA)</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Mirror fibers</string>
           </property>
          </item>
          <item>
           <property name="text">
            <string>Weight Bundle</string>
           </property>
          </item>
         </widget>
        </item>
        <item row="1" column="0">
         <widget class="QFrame" name="m_SmoothFibersFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_7">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="1" column="0">
            <widget class="QDoubleSpinBox" name="m_SmoothFibersBox">
             <property name="minimum">
              <double>0.010000000000000</double>
             </property>
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="value">
              <double>1.000000000000000</double>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QLabel" name="label_11">
             <property name="text">
              <string>Point distance in mm:</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="7" column="0">
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="6" column="0">
         <widget class="QCommandLinkButton" name="m_ModifyButton">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string/>
          </property>
          <property name="text">
           <string>Execute</string>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QFrame" name="m_BundleWeightFrame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_18">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <property name="spacing">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QLabel" name="label_15">
             <property name="text">
              <string>Weight:</string>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QDoubleSpinBox" name="m_BundleWeightBox">
             <property name="decimals">
              <number>7</number>
             </property>
             <property name="maximum">
              <double>999999999.000000000000000</double>
             </property>
             <property name="singleStep">
              <double>0.100000000000000</double>
             </property>
             <property name="value">
              <double>1.000000000000000</double>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="page_2">
       <property name="geometry">
        <rect>
         <x>0</x>
         <y>0</y>
         <width>360</width>
         <height>61</height>
        </rect>
       </property>
       <attribute name="label">
        <string>Binary Bundle Operations</string>
       </attribute>
       <attribute name="toolTip">
        <string>Join or subtract bundles.</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_13">
        <item row="0" column="0">
         <widget class="QCommandLinkButton" name="m_SubstractBundles">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Returns all fibers contained in bundle X that are not contained in bundle Y (not commutative!). Select at least two fiber bundles to execute.</string>
          </property>
          <property name="text">
           <string>Substract</string>
          </property>
         </widget>
        </item>
        <item row="0" column="2">
         <widget class="QCommandLinkButton" name="m_JoinBundles">
          <property name="enabled">
           <bool>false</bool>
          </property>
          <property name="sizePolicy">
           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
            <horstretch>0</horstretch>
            <verstretch>0</verstretch>
           </sizepolicy>
          </property>
          <property name="maximumSize">
           <size>
            <width>200</width>
            <height>16777215</height>
           </size>
          </property>
          <property name="font">
           <font>
            <pointsize>11</pointsize>
           </font>
          </property>
          <property name="toolTip">
           <string>Merge selected fiber bundles. Select at least two fiber bundles to execute.</string>
          </property>
          <property name="text">
           <string>Join</string>
          </property>
         </widget>
        </item>
        <item row="1" column="0">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="0" column="0">
     <widget class="QGroupBox" name="m_InputData">
      <property name="title">
       <string>Please Select Input Data</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_9">
       <item row="0" column="1">
        <widget class="QLabel" name="m_FibLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;mandatory&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QLabel" name="m_PfLabel">
         <property name="text">
          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#969696;&quot;&gt;needed for extraction&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="0" column="0">
        <widget class="QLabel" name="label_2">
         <property name="toolTip">
          <string>Input DTI</string>
         </property>
         <property name="text">
          <string>Fiber Bundle:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label_6">
         <property name="toolTip">
          <string>Binary seed ROI. If not specified, the whole image area is seeded.</string>
         </property>
         <property name="text">
          <string>ROI:</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="3" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../resources/QmitkDiffusionImaging.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
index 82fed1491d..8a1452baff 100755
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFiberfoxViewControls.ui
@@ -1,3117 +1,3135 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkFiberfoxViewControls</class>
  <widget class="QWidget" name="QmitkFiberfoxViewControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>479</width>
     <height>2397</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QGridLayout" name="gridLayout_2">
    <item row="3" column="0">
     <widget class="QCommandLinkButton" name="m_LoadParametersButton">
      <property name="text">
       <string>Load Parameters</string>
      </property>
      <property name="icon">
       <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
        <normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</normaloff>:/QmitkDiffusionImaging/general_icons/upload.ico</iconset>
      </property>
     </widget>
    </item>
    <item row="1" column="0">
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Fiber Definition</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_8">
        <item row="7" column="0">
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="m_FiberGenMessage">
          <property name="styleSheet">
           <string notr="true">color: rgb(255, 0, 0);</string>
          </property>
          <property name="text">
           <string>Please select an image or an existing fiber bundle to draw the fiber fiducials. If you can't provide a suitable image, generate one using the &quot;Signal Generation&quot; tab.</string>
          </property>
          <property name="textFormat">
           <enum>Qt::AutoText</enum>
          </property>
          <property name="alignment">
           <set>Qt::AlignJustify|Qt::AlignVCenter</set>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="5" column="0">
         <widget class="QGroupBox" name="groupBox_7">
          <property name="title">
           <string>Fiducial Options</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_16">
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_ConstantRadiusBox">
             <property name="toolTip">
              <string>All fiducials are treated as circles with the same radius as the first fiducial. </string>
             </property>
             <property name="text">
              <string>Use Constant Fiducial Radius</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QCommandLinkButton" name="m_AlignOnGrid">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="toolTip">
              <string>Align selected fiducials with voxel grid. Shifts selected fiducials to nearest voxel center.</string>
             </property>
             <property name="text">
              <string>Align With Grid</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="6" column="0" colspan="2">
         <widget class="QGroupBox" name="groupBox_4">
          <property name="title">
           <string>Operations</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_11">
           <item row="5" column="0">
            <widget class="QCommandLinkButton" name="m_JoinBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Join Bundles</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/plus.ico</normaloff>:/QmitkDiffusionImaging/general_icons/plus.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QFrame" name="frame_4">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_12">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="1" column="2">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_18">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Y</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QDoubleSpinBox" name="m_XrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around x-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_22">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Axis:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="2">
               <widget class="QDoubleSpinBox" name="m_YrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around y-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_21">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Translation:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="3">
               <widget class="QDoubleSpinBox" name="m_ZtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the z-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="2">
               <widget class="QDoubleSpinBox" name="m_YtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the y-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_17">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>X</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_20">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Rotation:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="3">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_19">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Z</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="3">
               <widget class="QDoubleSpinBox" name="m_ZrotBox">
                <property name="toolTip">
                 <string>Rotation angle (in degree) around z-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-360.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>360.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QDoubleSpinBox" name="m_XtransBox">
                <property name="toolTip">
                 <string>Translation (in mm) in direction of the x-axis.</string>
                </property>
+               <property name="decimals">
+                <number>3</number>
+               </property>
                <property name="minimum">
                 <double>-1000.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_24">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Scaling:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="4" column="1">
               <widget class="QDoubleSpinBox" name="m_XscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the x-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="2">
               <widget class="QDoubleSpinBox" name="m_YscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the y-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="4" column="3">
               <widget class="QDoubleSpinBox" name="m_ZscaleBox">
                <property name="toolTip">
                 <string>Scaling factor for selected fiber bundle along the z-axis.</string>
                </property>
                <property name="minimum">
                 <double>0.010000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QCommandLinkButton" name="m_CopyBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Copy Bundles</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/copy2.ico</normaloff>:/QmitkDiffusionImaging/general_icons/copy2.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCommandLinkButton" name="m_TransformBundlesButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Transform Selection</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/refresh.ico</normaloff>:/QmitkDiffusionImaging/general_icons/refresh.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_IncludeFiducials">
             <property name="toolTip">
              <string>If checked, the fiducials belonging to the modified bundle are also modified.</string>
             </property>
             <property name="text">
              <string>Include Fiducials</string>
             </property>
             <property name="checked">
              <bool>true</bool>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QGroupBox" name="groupBox_8">
          <property name="title">
           <string>Fiber Options</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_15">
           <item row="2" column="0">
            <widget class="QFrame" name="frame_5">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_9">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="2" column="0">
               <widget class="QFrame" name="m_AdvancedFiberOptionsFrame">
                <property name="frameShape">
                 <enum>QFrame::NoFrame</enum>
                </property>
                <property name="frameShadow">
                 <enum>QFrame::Raised</enum>
                </property>
                <layout class="QGridLayout" name="gridLayout_21">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_5">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Tension:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_8">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Fiber Sampling:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_TensionBox">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="3" column="1">
                  <widget class="QDoubleSpinBox" name="m_BiasBox">
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="3" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_7">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Bias:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_6">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Continuity:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="2" column="1">
                  <widget class="QDoubleSpinBox" name="m_ContinuityBox">
                   <property name="decimals">
                    <number>3</number>
                   </property>
                   <property name="minimum">
                    <double>-1.000000000000000</double>
                   </property>
                   <property name="maximum">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QDoubleSpinBox" name="m_FiberSamplingBox">
                   <property name="toolTip">
                    <string>Distance of fiber sampling points (in mm)</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="minimum">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>0.100000000000000</double>
                   </property>
                   <property name="value">
                    <double>1.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QFrame" name="frame_2">
                <property name="frameShape">
                 <enum>QFrame::NoFrame</enum>
                </property>
                <property name="frameShadow">
                 <enum>QFrame::Raised</enum>
                </property>
                <layout class="QGridLayout" name="gridLayout_25">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <property name="verticalSpacing">
                  <number>6</number>
                 </property>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_4">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>#Fibers:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QSpinBox" name="m_FiberDensityBox">
                   <property name="toolTip">
                    <string>Specify number of fibers to generate for the selected bundle.</string>
                   </property>
                   <property name="minimum">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <number>1000000</number>
                   </property>
                   <property name="singleStep">
                    <number>100</number>
                   </property>
                   <property name="value">
                    <number>100</number>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCommandLinkButton" name="m_GenerateFibersButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="text">
              <string>Generate Fibers</string>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QFrame" name="frame_3">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="1">
               <widget class="QComboBox" name="m_DistributionBox">
                <property name="toolTip">
                 <string>Select fiber distribution inside of the fiducials.</string>
                </property>
                <item>
                 <property name="text">
                  <string>Uniform</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Gaussian</string>
                 </property>
                </item>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_9">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Fiber Distribution:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QDoubleSpinBox" name="m_VarianceBox">
                <property name="toolTip">
                 <string>Variance of the gaussian</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.001000000000000</double>
                </property>
                <property name="maximum">
                 <double>10.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QFrame" name="frame_8">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_22">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QCheckBox" name="m_RealTimeFibers">
                <property name="toolTip">
                 <string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
                </property>
                <property name="text">
                 <string>Real Time Fibers</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QCheckBox" name="m_AdvancedOptionsBox">
                <property name="toolTip">
                 <string>Disable to only generate fibers if &quot;Generate Fibers&quot; button is pressed.</string>
                </property>
                <property name="text">
                 <string>Advanced Options</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QFrame" name="frame">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="frameShadow">
           <enum>QFrame::Raised</enum>
          </property>
          <layout class="QGridLayout" name="gridLayout_3">
           <property name="leftMargin">
            <number>0</number>
           </property>
           <property name="topMargin">
            <number>0</number>
           </property>
           <property name="rightMargin">
            <number>0</number>
           </property>
           <property name="bottomMargin">
            <number>0</number>
           </property>
           <item row="0" column="0">
            <widget class="QPushButton" name="m_CircleButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Draw elliptical fiducial.</string>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/circle.png</normaloff>:/QmitkDiffusionImaging/circle.png</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="1">
            <widget class="QPushButton" name="m_FlipButton">
             <property name="enabled">
              <bool>false</bool>
             </property>
             <property name="maximumSize">
              <size>
               <width>30</width>
               <height>30</height>
              </size>
             </property>
             <property name="toolTip">
              <string>Flip fiber waypoints of selcted fiducial around one axis.</string>
             </property>
             <property name="text">
              <string/>
             </property>
             <property name="icon">
              <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
               <normaloff>:/QmitkDiffusionImaging/refresh.xpm</normaloff>:/QmitkDiffusionImaging/refresh.xpm</iconset>
             </property>
             <property name="iconSize">
              <size>
               <width>32</width>
               <height>32</height>
              </size>
             </property>
             <property name="checkable">
              <bool>false</bool>
             </property>
             <property name="flat">
              <bool>true</bool>
             </property>
            </widget>
           </item>
           <item row="0" column="2">
            <spacer name="horizontalSpacer">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="sizeHint" stdset="0">
              <size>
               <width>40</width>
               <height>20</height>
              </size>
             </property>
            </spacer>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Signal Generation</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_4">
        <item row="10" column="0">
         <widget class="QGroupBox" name="groupBox_6">
          <property name="title">
           <string>Extra-axonal Compartments</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_14">
           <item row="17" column="0">
            <widget class="QFrame" name="m_Comp4FractionFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_18">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_3">
                <property name="text">
                 <string>Volume Fraction:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBox" name="m_Comp4VolumeFraction">
                <property name="toolTip">
                 <string/>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QComboBox" name="m_Compartment3Box">
             <property name="toolTip">
              <string>Select signal model for extra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>Ball Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Astrosticks Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Dot Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="8" column="0">
            <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget1" native="true"/>
           </item>
           <item row="10" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget3" native="true"/>
           </item>
           <item row="15" column="0">
            <widget class="QmitkDotModelParametersWidget" name="m_DotWidget2" native="true"/>
           </item>
           <item row="9" column="0">
            <widget class="QmitkDotModelParametersWidget" name="m_DotWidget1" native="true"/>
           </item>
           <item row="11" column="0">
            <widget class="Line" name="line_2">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="13" column="0">
            <widget class="QmitkBallModelParametersWidget" name="m_BallWidget2" native="true"/>
           </item>
           <item row="7" column="0">
            <widget class="QmitkBallModelParametersWidget" name="m_BallWidget1" native="true"/>
           </item>
           <item row="14" column="0">
            <widget class="QmitkAstrosticksModelParametersWidget" name="m_AstrosticksWidget2" native="true"/>
           </item>
           <item row="12" column="0">
            <widget class="QComboBox" name="m_Compartment4Box">
             <property name="toolTip">
              <string>Select signal model for extra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>--</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Ball Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Astrosticks Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Dot Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="16" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget4" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item row="13" column="0">
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="7" column="0">
         <widget class="QGroupBox" name="groupBox">
          <property name="title">
           <string>Image Settings</string>
          </property>
          <layout class="QGridLayout" name="gridLayout">
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_AdvancedOptionsBox_2">
             <property name="text">
              <string>Advanced Options</string>
             </property>
            </widget>
           </item>
           <item row="5" column="0">
            <widget class="QFrame" name="m_TensorsToDWIFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_24">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="spacing">
               <number>6</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel">
                <property name="text">
                 <string>Gradient Directions:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_NumGradientsBox">
                <property name="toolTip">
                 <string>Number of gradient directions distributed over the half sphere.</string>
                </property>
                <property name="minimum">
                 <number>0</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>30</number>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;b-Value&lt;span style=&quot; font-style:italic;&quot;&gt; [s/mm&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:super;&quot;&gt;2&lt;/span&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;]&lt;/span&gt;:&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QSpinBox" name="m_BvalueBox">
                <property name="toolTip">
                 <string>b-value in s/mm²</string>
                </property>
                <property name="minimum">
                 <number>0</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>100</number>
                </property>
                <property name="value">
                 <number>1000</number>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="m_GeometryMessage">
             <property name="styleSheet">
              <string notr="true">color: rgb(255, 0, 0);</string>
             </property>
             <property name="text">
              <string>Using  geometry of selected image!</string>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QLabel" name="m_DiffusionPropsMessage">
             <property name="styleSheet">
              <string notr="true">color: rgb(255, 0, 0);</string>
             </property>
             <property name="text">
              <string>Using  gradients of selected DWI!</string>
             </property>
            </widget>
           </item>
           <item row="7" column="0">
            <widget class="QFrame" name="m_AdvancedSignalOptionsFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_23">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_SignalScaleBox">
                <property name="toolTip">
                 <string>TE in milliseconds</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>100</number>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_13">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Echo Time &lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;:  &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QDoubleSpinBox" name="m_LineReadoutTimeBox">
                <property name="toolTip">
                 <string>T2* relaxation time (in milliseconds).</string>
                </property>
                <property name="maximum">
                 <double>100.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>1.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="9" column="0">
               <widget class="QCheckBox" name="m_VolumeFractionsBox">
                <property name="toolTip">
                 <string>Output one image per compartment containing the corresponding volume fractions per voxel.</string>
                </property>
                <property name="text">
                 <string>Output Volume Fractions</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="5" column="1">
               <widget class="QComboBox" name="m_DiffusionDirectionBox">
                <item>
                 <property name="text">
                  <string>Fiber tangent</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Main fiber directions</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Random</string>
                 </property>
                </item>
               </widget>
              </item>
              <item row="7" column="0">
               <widget class="QCheckBox" name="m_RelaxationBox">
                <property name="toolTip">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;TE&lt;/span&gt;, &lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; and &lt;span style=&quot; font-style:italic;&quot;&gt;T2&lt;/span&gt; will have no effect if unchecked.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="text">
                 <string>Simulate Signal Relaxation</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="4" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_4">
                <property name="text">
                 <string>Fiber Radius:</string>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_15">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Line Readout Time:  </string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="3" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_12">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-style:italic;&quot;&gt;T&lt;/span&gt;&lt;span style=&quot; font-style:italic; vertical-align:sub;&quot;&gt;inhom&lt;/span&gt; Relaxation: &lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="5" column="0">
               <widget class="QLabel" name="label_3">
                <property name="text">
                 <string>Diffusion Direction:</string>
                </property>
               </widget>
              </item>
              <item row="3" column="1">
               <widget class="QSpinBox" name="m_T2starBox">
                <property name="toolTip">
                 <string>Relaxation time due to magnetic field inhomogeneities (T2', in milliseconds).</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>50</number>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QSpinBox" name="m_TEbox">
                <property name="toolTip">
                 <string>TE in milliseconds</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>100</number>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWINumDirsLabel_5">
                <property name="text">
                 <string>Signal Scale:</string>
                </property>
               </widget>
              </item>
              <item row="4" column="1">
               <widget class="QSpinBox" name="m_FiberRadius">
                <property name="toolTip">
                 <string>Fiber radius used to calculate volume fractions (in µm). Set to 0 for automatic radius estimation.</string>
                </property>
                <property name="minimum">
                 <number>0</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="value">
                 <number>0</number>
                </property>
               </widget>
              </item>
              <item row="6" column="0">
               <widget class="QLabel" name="label_4">
                <property name="text">
                 <string>Separation Angle:</string>
                </property>
               </widget>
              </item>
              <item row="8" column="0">
               <widget class="QCheckBox" name="m_EnforcePureFiberVoxelsBox">
                <property name="toolTip">
                 <string>Disable partial volume. Treat voxel content as fiber-only if at least one fiber is present.</string>
                </property>
                <property name="text">
                 <string>Disable Partial Volume Effects</string>
                </property>
                <property name="checked">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="6" column="1">
               <widget class="QDoubleSpinBox" name="m_SeparationAngleBox">
                <property name="decimals">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <double>90.000000000000000</double>
                </property>
                <property name="value">
                 <double>45.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QFrame" name="m_GeometryFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_7">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="2" column="2">
               <widget class="QDoubleSpinBox" name="m_SpacingY">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="2" column="0">
               <widget class="QLabel" name="label_2">
                <property name="text">
                 <string>Image Spacing:</string>
                </property>
               </widget>
              </item>
              <item row="2" column="3">
               <widget class="QDoubleSpinBox" name="m_SpacingZ">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="2" column="1">
               <widget class="QDoubleSpinBox" name="m_SpacingX">
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="minimum">
                 <double>0.100000000000000</double>
                </property>
                <property name="maximum">
                 <double>50.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>2.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="label">
                <property name="text">
                 <string>Image Dimensions:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_SizeX">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>11</number>
                </property>
               </widget>
              </item>
              <item row="0" column="2">
               <widget class="QSpinBox" name="m_SizeY">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>11</number>
                </property>
               </widget>
              </item>
              <item row="0" column="3">
               <widget class="QSpinBox" name="m_SizeZ">
                <property name="toolTip">
                 <string>Fiber sampling factor which determines the accuracy of the calculated fiber and non-fiber volume fractions.</string>
                </property>
                <property name="minimum">
                 <number>1</number>
                </property>
                <property name="maximum">
                 <number>1000</number>
                </property>
                <property name="singleStep">
                 <number>1</number>
                </property>
                <property name="value">
                 <number>3</number>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="9" column="0">
         <widget class="QGroupBox" name="groupBox_5">
          <property name="title">
           <string>Inter-axonal Compartment</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_17">
           <item row="0" column="0">
            <widget class="QComboBox" name="m_Compartment2Box">
             <property name="toolTip">
              <string>Select signal model for intra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>--</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Stick Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Zeppelin Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Tensor Model</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget2" native="true"/>
           </item>
           <item row="2" column="0">
            <widget class="QmitkStickModelParametersWidget" name="m_StickWidget2" native="true"/>
           </item>
           <item row="3" column="0">
            <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget2" native="true"/>
           </item>
           <item row="4" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget2" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item row="3" column="0">
         <widget class="QCommandLinkButton" name="m_AbortSimulationButton">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="toolTip">
           <string>Stop current simulation.</string>
          </property>
          <property name="text">
           <string>Abort Simulation</string>
          </property>
          <property name="icon">
           <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
            <normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</normaloff>:/QmitkDiffusionImaging/general_icons/abort.ico</iconset>
          </property>
         </widget>
        </item>
        <item row="0" column="0" rowspan="2">
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
           <string>Data</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_10">
           <item row="4" column="2">
            <widget class="QFrame" name="frame_6">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QGridLayout" name="gridLayout_20">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <property name="spacing">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLineEdit" name="m_SavePathEdit">
                <property name="text">
                 <string>-</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QToolButton" name="m_OutputPathButton">
                <property name="text">
                 <string>...</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="2" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_MaskComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a binary image to define the area of signal generation. Outside of the mask image only noise will be actively generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
           <item row="0" column="0" rowspan="2" colspan="2">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_16">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Fiber Bundle:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_10">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Save path:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_3">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Tissue Mask:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_FiberBundleComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a fiber bundle to generate the white matter signal from. You can either use the fiber definition tab to manually define an input fiber bundle or you can also use any existing bundle, e.g. yielded by a tractography algorithm.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QLabel" name="m_TensorsToDWIBValueLabel_11">
             <property name="toolTip">
              <string/>
             </property>
             <property name="statusTip">
              <string/>
             </property>
             <property name="whatsThis">
              <string/>
             </property>
             <property name="text">
              <string>Template Image:</string>
             </property>
             <property name="wordWrap">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="3" column="2">
            <widget class="QmitkDataStorageComboBoxWithSelectNone" name="m_TemplateComboBox">
             <property name="toolTip">
              <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The parameters for the simulation (e.g. spacing, size, diffuison-weighted gradients, b-value) are adopted from this image.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
             </property>
             <property name="sizeAdjustPolicy">
              <enum>QComboBox::AdjustToMinimumContentsLength</enum>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="4" column="0">
         <widget class="QTextEdit" name="m_SimulationStatusText">
          <property name="font">
           <font>
            <pointsize>8</pointsize>
           </font>
          </property>
          <property name="readOnly">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item row="12" column="0">
         <widget class="QGroupBox" name="groupBox_3">
          <property name="title">
           <string>Noise and other Artifacts</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_6">
           <item row="20" column="0">
            <widget class="Line" name="line">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="0" column="0">
            <widget class="QCheckBox" name="m_AddNoise">
             <property name="text">
              <string>Add Noise</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="21" column="0">
            <widget class="QCheckBox" name="m_AddGibbsRinging">
             <property name="toolTip">
              <string>Add ringing artifacts occuring at strong edges in the image.</string>
             </property>
             <property name="text">
              <string>Add Gibbs Ringing</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="10" column="0">
            <widget class="QFrame" name="m_AliasingFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_10">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_27">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Shrink FOV (%):</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_WrapBox">
                <property name="toolTip">
                 <string>Shrink FOV by this percentage.</string>
                </property>
                <property name="decimals">
                 <number>1</number>
                </property>
                <property name="minimum">
                 <double>0.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>90.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>25.000000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="17" column="0">
            <widget class="Line" name="line_4">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="4" column="0">
            <widget class="QFrame" name="m_SpikeFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_9">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_2">
                <property name="text">
                 <string>Num. Spikes:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QSpinBox" name="m_SpikeNumBox">
                <property name="toolTip">
                 <string>The number of randomly occurring signal spikes.</string>
                </property>
                <property name="value">
                 <number>1</number>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_SpikeScaleBox">
                <property name="toolTip">
                 <string>Spike amplitude relative to the largest signal amplitude of the corresponding k-space slice.</string>
                </property>
                <property name="singleStep">
                 <double>0.100000000000000</double>
                </property>
                <property name="value">
                 <double>0.100000000000000</double>
                </property>
               </widget>
              </item>
              <item row="1" column="0">
               <widget class="QLabel" name="m_NoiseLabel_4">
                <property name="text">
                 <string>Scale:</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="18" column="0">
            <widget class="QCheckBox" name="m_AddEddy">
             <property name="toolTip">
              <string>!!!EXPERIMENTAL!!!</string>
             </property>
             <property name="text">
              <string>Add Eddy Current Effects</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="3" column="0">
            <widget class="QCheckBox" name="m_AddSpikes">
             <property name="text">
              <string>Add Spikes</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QFrame" name="m_NoiseFrame">
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_5">
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="1" column="0">
               <widget class="QLabel" name="m_NoiseLabel">
                <property name="text">
                 <string>Variance:</string>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_NoiseLevel">
                <property name="toolTip">
                 <string>Variance of selected noise distribution.</string>
                </property>
                <property name="decimals">
                 <number>4</number>
                </property>
                <property name="minimum">
                 <double>0.000000000000000</double>
                </property>
                <property name="maximum">
                 <double>999999999.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.001000000000000</double>
                </property>
                <property name="value">
                 <double>50.000000000000000</double>
                </property>
               </widget>
              </item>
              <item row="0" column="0">
               <widget class="QLabel" name="m_NoiseLabel_5">
                <property name="text">
                 <string>Distribution:</string>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QComboBox" name="m_NoiseDistributionBox">
                <property name="toolTip">
                 <string>Noise distribution</string>
                </property>
                <item>
                 <property name="text">
                  <string>Rician</string>
                 </property>
                </item>
                <item>
                 <property name="text">
                  <string>Chi-squared</string>
                 </property>
                </item>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="6" column="0">
            <widget class="QCheckBox" name="m_AddGhosts">
             <property name="text">
              <string>Add N/2 Ghosts</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="13" column="0">
            <widget class="QFrame" name="m_DistortionsFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_7">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_25">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Frequency Map:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QmitkDataStorageComboBox" name="m_FrequencyMapBox">
                <property name="toolTip">
                 <string>Select image specifying the frequency inhomogeneities (in Hz).</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="14" column="0">
            <widget class="Line" name="line_5">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="8" column="0">
            <widget class="Line" name="line_7">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="11" column="0">
            <widget class="Line" name="line_6">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="16" column="0">
            <widget class="QFrame" name="m_MotionArtifactFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_11">
              <property name="fieldGrowthPolicy">
               <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>6</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QCheckBox" name="m_RandomMotion">
                <property name="toolTip">
                 <string>Toggle between random movement and linear movement.</string>
                </property>
                <property name="text">
                 <string>Randomize motion</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="0" colspan="2">
               <widget class="QGroupBox" name="m_RotationArtifactFrame">
                <property name="title">
                 <string>Rotation</string>
                </property>
                <layout class="QGridLayout" name="gridLayout_19">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="topMargin">
                  <number>9</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_36">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Degree:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_29">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>x</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_28">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Axis:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxX">
                   <property name="toolTip">
                    <string>Maximum rotation around x-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="3">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxZ">
                   <property name="toolTip">
                    <string>Maximum rotation around z-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>15.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="2">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_30">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>y</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="3">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_31">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>z</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="2">
                  <widget class="QDoubleSpinBox" name="m_MaxRotationBoxY">
                   <property name="toolTip">
                    <string>Maximum rotation around y-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>360.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
              <item row="2" column="0" colspan="2">
               <widget class="QGroupBox" name="m_TranslationArtifactFrame">
                <property name="title">
                 <string>Translation</string>
                </property>
                <layout class="QGridLayout" name="gridLayout_28">
                 <property name="leftMargin">
                  <number>0</number>
                 </property>
                 <property name="rightMargin">
                  <number>0</number>
                 </property>
                 <property name="bottomMargin">
                  <number>0</number>
                 </property>
                 <item row="1" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_48">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Distance:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="1">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_51">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>x</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="2">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_52">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>y</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="0">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_47">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>Axis:</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="0" column="3">
                  <widget class="QLabel" name="m_TensorsToDWIBValueLabel_53">
                   <property name="toolTip">
                    <string/>
                   </property>
                   <property name="statusTip">
                    <string/>
                   </property>
                   <property name="whatsThis">
                    <string/>
                   </property>
                   <property name="text">
                    <string>z</string>
                   </property>
                   <property name="wordWrap">
                    <bool>false</bool>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="1">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxX">
                   <property name="toolTip">
                    <string>Maximum translation along x-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="2">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxY">
                   <property name="toolTip">
                    <string>Maximum translation along y-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                 <item row="1" column="3">
                  <widget class="QDoubleSpinBox" name="m_MaxTranslationBoxZ">
                   <property name="toolTip">
                    <string>Maximum translation along z-axis.</string>
                   </property>
                   <property name="decimals">
                    <number>1</number>
                   </property>
                   <property name="maximum">
                    <double>1000.000000000000000</double>
                   </property>
                   <property name="singleStep">
                    <double>1.000000000000000</double>
                   </property>
                   <property name="value">
                    <double>0.000000000000000</double>
                   </property>
                  </widget>
                 </item>
                </layout>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="15" column="0">
            <widget class="QCheckBox" name="m_AddMotion">
             <property name="text">
              <string>Add Motion Artifacts</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="12" column="0">
            <widget class="QCheckBox" name="m_AddDistortions">
             <property name="text">
              <string>Add Distortions</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="9" column="0">
            <widget class="QCheckBox" name="m_AddAliasing">
             <property name="text">
              <string>Add Aliasing</string>
             </property>
             <property name="checked">
              <bool>false</bool>
             </property>
            </widget>
           </item>
           <item row="7" column="0">
            <widget class="QFrame" name="m_GhostFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_6">
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="0" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_23">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>K-Space Line Offset:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QDoubleSpinBox" name="m_kOffsetBox">
                <property name="toolTip">
                 <string>A larger offset increases the inensity of the ghost image.</string>
                </property>
                <property name="decimals">
                 <number>3</number>
                </property>
                <property name="maximum">
                 <double>1.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.010000000000000</double>
                </property>
                <property name="value">
                 <double>0.250000000000000</double>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="19" column="0">
            <widget class="QFrame" name="m_EddyFrame">
             <property name="enabled">
              <bool>true</bool>
             </property>
             <property name="frameShape">
              <enum>QFrame::NoFrame</enum>
             </property>
             <property name="frameShadow">
              <enum>QFrame::Raised</enum>
             </property>
             <layout class="QFormLayout" name="formLayout_8">
              <property name="fieldGrowthPolicy">
               <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
              </property>
              <property name="horizontalSpacing">
               <number>6</number>
              </property>
              <property name="leftMargin">
               <number>0</number>
              </property>
              <property name="topMargin">
               <number>0</number>
              </property>
              <property name="rightMargin">
               <number>0</number>
              </property>
              <property name="bottomMargin">
               <number>0</number>
              </property>
              <item row="1" column="0">
               <widget class="QLabel" name="m_TensorsToDWIBValueLabel_26">
                <property name="toolTip">
                 <string/>
                </property>
                <property name="statusTip">
                 <string/>
                </property>
                <property name="whatsThis">
                 <string/>
                </property>
                <property name="text">
                 <string>Magnitude:</string>
                </property>
                <property name="wordWrap">
                 <bool>false</bool>
                </property>
               </widget>
              </item>
              <item row="1" column="1">
               <widget class="QDoubleSpinBox" name="m_EddyGradientStrength">
                <property name="toolTip">
                 <string>Maximum magnitude of eddy current induced magnetic field inhomogeneities (in mT).</string>
                </property>
                <property name="decimals">
                 <number>5</number>
                </property>
                <property name="maximum">
                 <double>1000.000000000000000</double>
                </property>
                <property name="singleStep">
                 <double>0.001000000000000</double>
                </property>
                <property name="value">
                 <double>0.005000000000000</double>
                </property>
               </widget>
              </item>
              <item row="0" column="1">
               <widget class="QLabel" name="m_DiffusionPropsMessage_2">
                <property name="styleSheet">
                 <string notr="true">color: rgb(255, 0, 0);</string>
                </property>
                <property name="text">
                 <string>Experimental!</string>
                </property>
               </widget>
              </item>
             </layout>
            </widget>
           </item>
           <item row="5" column="0">
            <widget class="Line" name="line_8">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
           <item row="2" column="0">
            <widget class="Line" name="line_9">
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item row="2" column="0">
         <widget class="QCommandLinkButton" name="m_GenerateImageButton">
          <property name="enabled">
           <bool>true</bool>
          </property>
          <property name="toolTip">
           <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Start DWI generation from selected fiber bundle.&lt;/p&gt;&lt;p&gt;If no fiber bundle but an existing diffusion weighted image is selected, the enabled artifacts are added to this image.&lt;/p&gt;&lt;p&gt;If neither a fiber bundle nor a diffusion weighted image is selected, a grayscale image containing a simple gradient is generated.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
          <property name="text">
           <string>Start Simulation</string>
          </property>
          <property name="icon">
           <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
            <normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</normaloff>:/QmitkDiffusionImaging/general_icons/right.ico</iconset>
          </property>
         </widget>
        </item>
        <item row="8" column="0">
         <widget class="QGroupBox" name="m_IntraAxonalGroupBox">
          <property name="title">
           <string>Intra-axonal Compartment</string>
          </property>
          <layout class="QGridLayout" name="gridLayout_13">
           <item row="2" column="0">
            <widget class="QmitkZeppelinModelParametersWidget" name="m_ZeppelinWidget1" native="true"/>
           </item>
           <item row="3" column="0">
            <widget class="QmitkTensorModelParametersWidget" name="m_TensorWidget1" native="true"/>
           </item>
           <item row="0" column="0">
            <widget class="QComboBox" name="m_Compartment1Box">
             <property name="toolTip">
              <string>Select signal model for intra-axonal compartment.</string>
             </property>
             <item>
              <property name="text">
               <string>Stick Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Zeppelin Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Tensor Model</string>
              </property>
             </item>
             <item>
              <property name="text">
               <string>Prototype Signal</string>
              </property>
             </item>
            </widget>
           </item>
           <item row="1" column="0">
            <widget class="QmitkStickModelParametersWidget" name="m_StickWidget1" native="true"/>
           </item>
           <item row="4" column="0">
            <widget class="QmitkPrototypeSignalParametersWidget" name="m_PrototypeWidget1" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="2" column="0">
     <widget class="QCommandLinkButton" name="m_SaveParametersButton">
      <property name="text">
       <string>Save Parameters</string>
      </property>
      <property name="icon">
       <iconset resource="../../resources/QmitkDiffusionImaging.qrc">
        <normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</normaloff>:/QmitkDiffusionImaging/general_icons/download.ico</iconset>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkDataStorageComboBox</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBox.h</header>
   </customwidget>
   <customwidget>
    <class>QmitkTensorModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkTensorModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkStickModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkStickModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkZeppelinModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkZeppelinModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkBallModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkBallModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkAstrosticksModelParametersWidget</class>
    <extends>QWidget</extends>
    <header location="global">QmitkAstrosticksModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDotModelParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkDotModelParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkPrototypeSignalParametersWidget</class>
    <extends>QWidget</extends>
    <header>QmitkPrototypeSignalParametersWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkDataStorageComboBoxWithSelectNone</class>
    <extends>QComboBox</extends>
    <header location="global">QmitkDataStorageComboBoxWithSelectNone.h</header>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>m_CircleButton</tabstop>
   <tabstop>m_FlipButton</tabstop>
   <tabstop>m_RealTimeFibers</tabstop>
   <tabstop>m_AdvancedOptionsBox</tabstop>
   <tabstop>m_DistributionBox</tabstop>
   <tabstop>m_VarianceBox</tabstop>
   <tabstop>m_FiberDensityBox</tabstop>
   <tabstop>m_FiberSamplingBox</tabstop>
   <tabstop>m_TensionBox</tabstop>
   <tabstop>m_ContinuityBox</tabstop>
   <tabstop>m_BiasBox</tabstop>
   <tabstop>m_GenerateFibersButton</tabstop>
   <tabstop>m_ConstantRadiusBox</tabstop>
   <tabstop>m_AlignOnGrid</tabstop>
   <tabstop>m_XrotBox</tabstop>
   <tabstop>m_YrotBox</tabstop>
   <tabstop>m_ZrotBox</tabstop>
   <tabstop>m_XtransBox</tabstop>
   <tabstop>m_YtransBox</tabstop>
   <tabstop>m_ZtransBox</tabstop>
   <tabstop>m_XscaleBox</tabstop>
   <tabstop>m_YscaleBox</tabstop>
   <tabstop>m_ZscaleBox</tabstop>
   <tabstop>m_TransformBundlesButton</tabstop>
   <tabstop>m_CopyBundlesButton</tabstop>
   <tabstop>m_JoinBundlesButton</tabstop>
   <tabstop>m_IncludeFiducials</tabstop>
   <tabstop>m_GenerateImageButton</tabstop>
   <tabstop>m_SizeX</tabstop>
   <tabstop>m_SizeY</tabstop>
   <tabstop>m_SizeZ</tabstop>
   <tabstop>m_SpacingX</tabstop>
   <tabstop>m_SpacingY</tabstop>
   <tabstop>m_SpacingZ</tabstop>
   <tabstop>m_NumGradientsBox</tabstop>
   <tabstop>m_BvalueBox</tabstop>
   <tabstop>m_AdvancedOptionsBox_2</tabstop>
   <tabstop>m_SignalScaleBox</tabstop>
   <tabstop>m_TEbox</tabstop>
   <tabstop>m_LineReadoutTimeBox</tabstop>
   <tabstop>m_T2starBox</tabstop>
   <tabstop>m_FiberRadius</tabstop>
   <tabstop>m_RelaxationBox</tabstop>
   <tabstop>m_EnforcePureFiberVoxelsBox</tabstop>
   <tabstop>m_VolumeFractionsBox</tabstop>
   <tabstop>m_Compartment1Box</tabstop>
   <tabstop>m_Compartment2Box</tabstop>
   <tabstop>m_Compartment3Box</tabstop>
   <tabstop>m_Compartment4Box</tabstop>
   <tabstop>m_AddNoise</tabstop>
   <tabstop>m_NoiseLevel</tabstop>
   <tabstop>m_AddSpikes</tabstop>
   <tabstop>m_SpikeNumBox</tabstop>
   <tabstop>m_SpikeScaleBox</tabstop>
   <tabstop>m_AddGhosts</tabstop>
   <tabstop>m_kOffsetBox</tabstop>
   <tabstop>m_AddAliasing</tabstop>
   <tabstop>m_WrapBox</tabstop>
   <tabstop>m_AddDistortions</tabstop>
   <tabstop>m_FrequencyMapBox</tabstop>
   <tabstop>m_AddMotion</tabstop>
   <tabstop>m_RandomMotion</tabstop>
   <tabstop>m_MaxRotationBoxX</tabstop>
   <tabstop>m_MaxRotationBoxY</tabstop>
   <tabstop>m_MaxRotationBoxZ</tabstop>
   <tabstop>m_MaxTranslationBoxX</tabstop>
   <tabstop>m_MaxTranslationBoxY</tabstop>
   <tabstop>m_MaxTranslationBoxZ</tabstop>
   <tabstop>m_AddEddy</tabstop>
   <tabstop>m_EddyGradientStrength</tabstop>
   <tabstop>m_AddGibbsRinging</tabstop>
   <tabstop>m_SaveParametersButton</tabstop>
   <tabstop>m_LoadParametersButton</tabstop>
   <tabstop>tabWidget</tabstop>
  </tabstops>
  <resources>
   <include location="../../resources/QmitkDiffusionImaging.qrc"/>
  </resources>
  <connections/>
 </ui>